@voidzero-dev/vite-plus-test 0.1.8 → 0.1.10

package/dist/@vitest/runner/index.js

@@ -1,8 +1,8 @@
 import { processError } from '../utils/error.js';
-import { isObject, createDefer, assertTypes, toArray, isNegativeNaN, objectAttr, shuffle } from '../utils/helpers.js';
+import { isObject, filterOutComments, ordinal, createDefer, assertTypes, toArray, isNegativeNaN, unique, objectAttr, shuffle } from '../utils/helpers.js';
 import { getSafeTimers } from '../utils/timers.js';
 import { format, formatRegExp, objDisplay } from '../utils/display.js';
-import { c as createChainable, e as createTaskName, f as findTestFileStackTrace, b as createFileTask, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, l as limitConcurrency, p as partitionSuiteChildren, r as hasTests, q as hasFailed } from './chunk-tasks.js';
+import { w as getChainableContext, a as createChainable, v as validateTags, e as createTaskName, x as createNoTagsError, f as findTestFileStackTrace, d as createTagsFilter, b as createFileTask, c as calculateSuiteHash, u as someTasksAreOnly, q as interpretTaskModes, s as limitConcurrency, t as partitionSuiteChildren, p as hasTests, o as hasFailed } from './chunk-tasks.js';
 import '../utils/source-map.js';
 import '../../vendor/pathe.mjs';
 
@@ -24,6 +24,24 @@ class TestRunAbortError extends Error {
     this.reason = reason;
   }
 }
+class FixtureDependencyError extends Error {
+  name = "FixtureDependencyError";
+}
+class FixtureAccessError extends Error {
+  name = "FixtureAccessError";
+}
+class FixtureParseError extends Error {
+  name = "FixtureParseError";
+}
+class AroundHookSetupError extends Error {
+  name = "AroundHookSetupError";
+}
+class AroundHookTeardownError extends Error {
+  name = "AroundHookTeardownError";
+}
+class AroundHookMultipleCallsError extends Error {
+  name = "AroundHookMultipleCallsError";
+}
 
 // use WeakMap here to make the Test and Suite object serializable
 const fnMap = new WeakMap();
@@ -38,7 +56,7 @@ function getFn(key) {
 function setTestFixture(key, fixture) {
   testFixtureMap.set(key, fixture);
 }
-function getTestFixture(key) {
+function getTestFixtures(key) {
   return testFixtureMap.get(key);
 }
 function setHooks(key, hooks) {
@@ -48,85 +66,182 @@ function getHooks(key) {
   return hooksMap.get(key);
 }
 
-function mergeScopedFixtures(testFixtures, scopedFixtures) {
-  const scopedFixturesMap = scopedFixtures.reduce((map, fixture) => {
-    map[fixture.prop] = fixture;
-    return map;
-  }, {});
-  const newFixtures = {};
-  testFixtures.forEach((fixture) => {
-    const useFixture = scopedFixturesMap[fixture.prop] || { ...fixture };
-    newFixtures[useFixture.prop] = useFixture;
-  });
-  for (const fixtureKep in newFixtures) {
-    var _fixture$deps;
-    const fixture = newFixtures[fixtureKep];
-    // if the fixture was define before the scope, then its dep
-    // will reference the original fixture instead of the scope
-    fixture.deps = (_fixture$deps = fixture.deps) === null || _fixture$deps === void 0 ? void 0 : _fixture$deps.map((dep) => newFixtures[dep.prop]);
-  }
-  return Object.values(newFixtures);
-}
-function mergeContextFixtures(fixtures, context, runner) {
-  const fixtureOptionKeys = [
+class TestFixtures {
+  _suiteContexts;
+  _overrides = new WeakMap();
+  _registrations;
+  static _definitions = [];
+  static _builtinFixtures = [
+    "task",
+    "signal",
+    "onTestFailed",
+    "onTestFinished",
+    "skip",
+    "annotate"
+  ];
+  static _fixtureOptionKeys = [
     "auto",
     "injected",
     "scope"
   ];
-  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))) {
-      var _runner$injectValue;
-      // fixture with options
-      Object.assign(fixtureItem, value[1]);
-      const userValue = value[0];
-      fixtureItem.value = fixtureItem.injected ? ((_runner$injectValue = runner.injectValue) === null || _runner$injectValue === void 0 ? void 0 : _runner$injectValue.call(runner, prop)) ?? userValue : userValue;
-    }
-    fixtureItem.scope = fixtureItem.scope || "test";
-    if (fixtureItem.scope === "worker" && !runner.getWorkerContext) {
-      fixtureItem.scope = "file";
-    }
-    fixtureItem.prop = prop;
-    fixtureItem.isFn = typeof fixtureItem.value === "function";
-    return fixtureItem;
-  });
-  if (Array.isArray(context.fixtures)) {
-    context.fixtures = context.fixtures.concat(fixtureArray);
-  } else {
-    context.fixtures = fixtureArray;
-  }
-  // Update dependencies of fixture functions
-  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));
+  static _fixtureScopes = [
+    "test",
+    "file",
+    "worker"
+  ];
+  static _workerContextSuite = { type: "worker" };
+  static clearDefinitions() {
+    TestFixtures._definitions.length = 0;
+  }
+  static getWorkerContexts() {
+    return TestFixtures._definitions.map((f) => f.getWorkerContext());
+  }
+  static getFileContexts(file) {
+    return TestFixtures._definitions.map((f) => f.getFileContext(file));
+  }
+  constructor(registrations) {
+    this._registrations = registrations ?? new Map();
+    this._suiteContexts = new WeakMap();
+    TestFixtures._definitions.push(this);
+  }
+  extend(runner, userFixtures) {
+    const { suite } = getCurrentSuite();
+    const isTopLevel = !suite || suite.file === suite;
+    const registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel);
+    return new TestFixtures(registrations);
+  }
+  get(suite) {
+    let currentSuite = suite;
+    while (currentSuite) {
+      const overrides = this._overrides.get(currentSuite);
+      // return the closest override
+      if (overrides) {
+        return overrides;
       }
-      // test can access anything, so we ignore it
-      if (fixture.scope !== "test") {
-        var _fixture$deps2;
-        (_fixture$deps2 = fixture.deps) === null || _fixture$deps2 === void 0 ? void 0 : _fixture$deps2.forEach((dep) => {
-          if (!dep.isFn) {
-            // non fn fixtures are always resolved and available to anyone
-            return;
-          }
-          // worker scope can only import from worker scope
-          if (fixture.scope === "worker" && dep.scope === "worker") {
-            return;
-          }
-          // file scope an import from file and worker scopes
-          if (fixture.scope === "file" && dep.scope !== "test") {
-            return;
-          }
-          throw new SyntaxError(`cannot use the ${dep.scope} fixture "${dep.prop}" inside the ${fixture.scope} fixture "${fixture.prop}"`);
-        });
+      if (currentSuite === currentSuite.file) {
+        break;
       }
+      currentSuite = currentSuite.suite || currentSuite.file;
+    }
+    return this._registrations;
+  }
+  override(runner, userFixtures) {
+    const { suite: currentSuite, file } = getCurrentSuite();
+    const suite = currentSuite || file;
+    const isTopLevel = !currentSuite || currentSuite.file === currentSuite;
+    // Create a copy of the closest parent's registrations to avoid modifying them
+    // For chained calls, this.get(suite) returns this suite's overrides; for first call, returns parent's
+    const suiteRegistrations = new Map(this.get(suite));
+    const registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel, suiteRegistrations);
+    // If defined in top-level, just override all registrations
+    // We don't support overriding suite-level fixtures anyway (it will throw an error)
+    if (isTopLevel) {
+      this._registrations = registrations;
+    } else {
+      this._overrides.set(suite, registrations);
     }
-  });
-  return context;
+  }
+  getFileContext(file) {
+    if (!this._suiteContexts.has(file)) {
+      this._suiteContexts.set(file, Object.create(null));
+    }
+    return this._suiteContexts.get(file);
+  }
+  getWorkerContext() {
+    if (!this._suiteContexts.has(TestFixtures._workerContextSuite)) {
+      this._suiteContexts.set(TestFixtures._workerContextSuite, Object.create(null));
+    }
+    return this._suiteContexts.get(TestFixtures._workerContextSuite);
+  }
+  parseUserFixtures(runner, userFixtures, supportNonTest, registrations = new Map(this._registrations)) {
+    const errors = [];
+    Object.entries(userFixtures).forEach(([name, fn]) => {
+      let options;
+      let value;
+      let _options;
+      if (Array.isArray(fn) && fn.length >= 2 && isObject(fn[1]) && Object.keys(fn[1]).some((key) => TestFixtures._fixtureOptionKeys.includes(key))) {
+        _options = fn[1];
+        options = {
+          auto: _options.auto ?? false,
+          scope: _options.scope ?? "test",
+          injected: _options.injected ?? false
+        };
+        value = options.injected ? runner.injectValue?.(name) ?? fn[0] : fn[0];
+      } else {
+        value = fn;
+      }
+      const parent = registrations.get(name);
+      if (parent && options) {
+        if (parent.scope !== options.scope) {
+          errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered with a "${options.scope}" scope.`));
+        }
+        if (parent.auto !== options.auto) {
+          errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered as { auto: ${options.auto} }.`));
+        }
+      } else if (parent) {
+        options = {
+          auto: parent.auto,
+          scope: parent.scope,
+          injected: parent.injected
+        };
+      } else if (!options) {
+        options = {
+          auto: false,
+          injected: false,
+          scope: "test"
+        };
+      }
+      if (options.scope && !TestFixtures._fixtureScopes.includes(options.scope)) {
+        errors.push(new FixtureDependencyError(`The "${name}" fixture has unknown scope "${options.scope}".`));
+      }
+      if (!supportNonTest && options.scope !== "test") {
+        errors.push(new FixtureDependencyError(`The "${name}" fixture cannot be defined with a ${options.scope} scope${!_options?.scope && parent?.scope ? " (inherited from the base fixture)" : ""} inside the describe block. Define it at the top level of the file instead.`));
+      }
+      const deps = isFixtureFunction(value) ? getUsedProps(value) : new Set();
+      const item = {
+        name,
+        value,
+        auto: options.auto ?? false,
+        injected: options.injected ?? false,
+        scope: options.scope ?? "test",
+        deps,
+        parent
+      };
+      registrations.set(name, item);
+      if (item.scope === "worker" && (runner.pool === "vmThreads" || runner.pool === "vmForks")) {
+        item.scope = "file";
+      }
+    });
+    // validate fixture dependency scopes
+    for (const fixture of registrations.values()) {
+      for (const depName of fixture.deps) {
+        if (TestFixtures._builtinFixtures.includes(depName)) {
+          continue;
+        }
+        const dep = registrations.get(depName);
+        if (!dep) {
+          errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on unknown fixture "${depName}".`));
+          continue;
+        }
+        if (depName === fixture.name && !fixture.parent) {
+          errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on itself, but does not have a base implementation.`));
+          continue;
+        }
+        if (TestFixtures._fixtureScopes.indexOf(fixture.scope) > TestFixtures._fixtureScopes.indexOf(dep.scope)) {
+          errors.push(new FixtureDependencyError(`The ${fixture.scope} "${fixture.name}" fixture cannot depend on a ${dep.scope} fixture "${dep.name}".`));
+          continue;
+        }
+      }
+    }
+    if (errors.length === 1) {
+      throw errors[0];
+    } else if (errors.length > 1) {
+      throw new AggregateError(errors, "Cannot resolve user fixtures. See errors for more information.");
+    }
+    return registrations;
+  }
 }
-const fixtureValueMaps = new Map();
-const cleanupFnArrayMap = new Map();
+const cleanupFnArrayMap = new WeakMap();
 async function callFixtureCleanup(context) {
   const cleanupFnArray = cleanupFnArrayMap.get(context) ?? [];
   for (const cleanup of cleanupFnArray.reverse()) {
@@ -134,96 +249,152 @@ async function callFixtureCleanup(context) {
   }
   cleanupFnArrayMap.delete(context);
 }
-function withFixtures(runner, fn, testContext) {
-  return (hookContext) => {
-    const context = hookContext || testContext;
+/**
+* Returns the current number of cleanup functions registered for the context.
+* This can be used as a checkpoint to later clean up only fixtures added after this point.
+*/
+function getFixtureCleanupCount(context) {
+  return cleanupFnArrayMap.get(context)?.length ?? 0;
+}
+/**
+* Cleans up only fixtures that were added after the given checkpoint index.
+* This is used by aroundEach to clean up fixtures created inside runTest()
+* while preserving fixtures that were created for aroundEach itself.
+*/
+async function callFixtureCleanupFrom(context, fromIndex) {
+  const cleanupFnArray = cleanupFnArrayMap.get(context);
+  if (!cleanupFnArray || cleanupFnArray.length <= fromIndex) {
+    return;
+  }
+  // Get items added after the checkpoint
+  const toCleanup = cleanupFnArray.slice(fromIndex);
+  // Clean up in reverse order
+  for (const cleanup of toCleanup.reverse()) {
+    await cleanup();
+  }
+  // Remove cleaned up items from the array, keeping items before checkpoint
+  cleanupFnArray.length = fromIndex;
+}
+const contextHasFixturesCache = new WeakMap();
+function withFixtures(fn, options) {
+  const collector = getCurrentSuite();
+  const suite = options?.suite || collector.suite || collector.file;
+  return async (hookContext) => {
+    const context = hookContext || options?.context;
     if (!context) {
+      if (options?.suiteHook) {
+        validateSuiteHook(fn, options.suiteHook, options.stackTraceError);
+      }
       return fn({});
     }
-    const fixtures = getTestFixture(context);
-    if (!(fixtures === null || fixtures === void 0 ? void 0 : fixtures.length)) {
+    const fixtures = options?.fixtures || getTestFixtures(context);
+    if (!fixtures) {
       return fn(context);
     }
-    const usedProps = getUsedProps(fn);
-    const hasAutoFixture = fixtures.some(({ auto }) => auto);
-    if (!usedProps.length && !hasAutoFixture) {
+    const registrations = fixtures.get(suite);
+    if (!registrations.size) {
       return fn(context);
     }
-    if (!fixtureValueMaps.get(context)) {
-      fixtureValueMaps.set(context, new Map());
+    const usedFixtures = [];
+    const usedProps = getUsedProps(fn);
+    for (const fixture of registrations.values()) {
+      if (fixture.auto || usedProps.has(fixture.name)) {
+        usedFixtures.push(fixture);
+      }
+    }
+    if (!usedFixtures.length) {
+      return fn(context);
     }
-    const fixtureValueMap = fixtureValueMaps.get(context);
     if (!cleanupFnArrayMap.has(context)) {
       cleanupFnArrayMap.set(context, []);
     }
     const cleanupFnArray = cleanupFnArrayMap.get(context);
-    const usedFixtures = fixtures.filter(({ prop, auto }) => auto || usedProps.includes(prop));
-    const pendingFixtures = resolveDeps(usedFixtures);
+    const pendingFixtures = resolveDeps(usedFixtures, registrations);
     if (!pendingFixtures.length) {
       return fn(context);
     }
-    async function resolveFixtures() {
-      for (const fixture of pendingFixtures) {
+    // Check if suite-level hook is trying to access test-scoped fixtures
+    // Suite hooks (beforeAll/afterAll/aroundAll) can only access file/worker scoped fixtures
+    if (options?.suiteHook) {
+      const testScopedFixtures = pendingFixtures.filter((f) => f.scope === "test");
+      if (testScopedFixtures.length > 0) {
+        const fixtureNames = testScopedFixtures.map((f) => `"${f.name}"`).join(", ");
+        const alternativeHook = {
+          aroundAll: "aroundEach",
+          beforeAll: "beforeEach",
+          afterAll: "afterEach"
+        };
+        const error = new FixtureDependencyError(`Test-scoped fixtures cannot be used inside ${options.suiteHook} hook. ` + `The following fixtures are test-scoped: ${fixtureNames}. ` + `Use { scope: 'file' } or { scope: 'worker' } fixtures instead, or move the logic to ${alternativeHook[options.suiteHook]} hook.`);
+        // Use stack trace from hook registration for better error location
+        if (options.stackTraceError?.stack) {
+          error.stack = error.message + options.stackTraceError.stack.replace(options.stackTraceError.message, "");
+        }
+        throw error;
+      }
+    }
+    if (!contextHasFixturesCache.has(context)) {
+      contextHasFixturesCache.set(context, new WeakSet());
+    }
+    const cachedFixtures = contextHasFixturesCache.get(context);
+    for (const fixture of pendingFixtures) {
+      if (fixture.scope === "test") {
         // fixture could be already initialized during "before" hook
-        if (fixtureValueMap.has(fixture)) {
+        // we can't check "fixture.name" in context because context may
+        // access the parent fixture ({ a: ({ a }) => {} })
+        if (cachedFixtures.has(fixture)) {
           continue;
         }
-        const resolvedValue = await resolveFixtureValue(runner, fixture, context, cleanupFnArray);
-        context[fixture.prop] = resolvedValue;
-        fixtureValueMap.set(fixture, resolvedValue);
-        if (fixture.scope === "test") {
-          cleanupFnArray.unshift(() => {
-            fixtureValueMap.delete(fixture);
-          });
-        }
+        cachedFixtures.add(fixture);
+        const resolvedValue = await resolveTestFixtureValue(fixture, context, cleanupFnArray);
+        context[fixture.name] = resolvedValue;
+        cleanupFnArray.push(() => {
+          cachedFixtures.delete(fixture);
+        });
+      } else {
+        const resolvedValue = await resolveScopeFixtureValue(fixtures, suite, fixture);
+        context[fixture.name] = resolvedValue;
       }
     }
-    return resolveFixtures().then(() => fn(context));
+    return fn(context);
   };
 }
-const globalFixturePromise = new WeakMap();
-function resolveFixtureValue(runner, fixture, context, cleanupFnArray) {
-  var _runner$getWorkerCont;
-  const fileContext = getFileContext(context.task.file);
-  const workerContext = (_runner$getWorkerCont = runner.getWorkerContext) === null || _runner$getWorkerCont === void 0 ? void 0 : _runner$getWorkerCont.call(runner);
-  if (!fixture.isFn) {
-    var _fixture$prop;
-    fileContext[_fixture$prop = fixture.prop] ?? (fileContext[_fixture$prop] = fixture.value);
-    if (workerContext) {
-      var _fixture$prop2;
-      workerContext[_fixture$prop2 = fixture.prop] ?? (workerContext[_fixture$prop2] = fixture.value);
-    }
+function isFixtureFunction(value) {
+  return typeof value === "function";
+}
+function resolveTestFixtureValue(fixture, context, cleanupFnArray) {
+  if (!isFixtureFunction(fixture.value)) {
     return fixture.value;
   }
-  if (fixture.scope === "test") {
-    return resolveFixtureFunction(fixture.value, context, cleanupFnArray);
-  }
-  // in case the test runs in parallel
-  if (globalFixturePromise.has(fixture)) {
-    return globalFixturePromise.get(fixture);
+  return resolveFixtureFunction(fixture.value, context, cleanupFnArray);
+}
+const scopedFixturePromiseCache = new WeakMap();
+async function resolveScopeFixtureValue(fixtures, suite, fixture) {
+  const workerContext = fixtures.getWorkerContext();
+  const fileContext = fixtures.getFileContext(suite.file);
+  const fixtureContext = fixture.scope === "worker" ? workerContext : fileContext;
+  if (!isFixtureFunction(fixture.value)) {
+    fixtureContext[fixture.name] = fixture.value;
+    return fixture.value;
   }
-  let fixtureContext;
-  if (fixture.scope === "worker") {
-    if (!workerContext) {
-      throw new TypeError("[@vitest/runner] The worker context is not available in the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.");
-    }
-    fixtureContext = workerContext;
-  } else {
-    fixtureContext = fileContext;
+  if (fixture.name in fixtureContext) {
+    return fixtureContext[fixture.name];
   }
-  if (fixture.prop in fixtureContext) {
-    return fixtureContext[fixture.prop];
+  if (scopedFixturePromiseCache.has(fixture)) {
+    return scopedFixturePromiseCache.get(fixture);
   }
   if (!cleanupFnArrayMap.has(fixtureContext)) {
     cleanupFnArrayMap.set(fixtureContext, []);
   }
   const cleanupFnFileArray = cleanupFnArrayMap.get(fixtureContext);
-  const promise = resolveFixtureFunction(fixture.value, fixtureContext, cleanupFnFileArray).then((value) => {
-    fixtureContext[fixture.prop] = value;
-    globalFixturePromise.delete(fixture);
+  const promise = resolveFixtureFunction(fixture.value, fixture.scope === "file" ? {
+    ...workerContext,
+    ...fileContext
+  } : fixtureContext, cleanupFnFileArray).then((value) => {
+    fixtureContext[fixture.name] = value;
+    scopedFixturePromiseCache.delete(fixture);
     return value;
   });
-  globalFixturePromise.set(fixture, promise);
+  scopedFixturePromiseCache.set(fixture, promise);
   return promise;
 }
 async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
@@ -254,27 +425,60 @@ async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
   });
   return useFnArgPromise;
 }
-function resolveDeps(fixtures, depSet = new Set(), pendingFixtures = []) {
-  fixtures.forEach((fixture) => {
+function resolveDeps(usedFixtures, registrations, depSet = new Set(), pendingFixtures = []) {
+  usedFixtures.forEach((fixture) => {
     if (pendingFixtures.includes(fixture)) {
       return;
     }
-    if (!fixture.isFn || !fixture.deps) {
+    if (!isFixtureFunction(fixture.value) || !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 (fixture.parent) {
+        fixture = fixture.parent;
+      } else {
+        throw new Error(`Circular fixture dependency detected: ${fixture.name} <- ${[...depSet].reverse().map((d) => d.name).join(" <- ")}`);
+      }
     }
     depSet.add(fixture);
-    resolveDeps(fixture.deps, depSet, pendingFixtures);
+    resolveDeps([...fixture.deps].map((n) => n === fixture.name ? fixture.parent : registrations.get(n)).filter((n) => !!n), registrations, depSet, pendingFixtures);
     pendingFixtures.push(fixture);
     depSet.clear();
   });
   return pendingFixtures;
 }
-function getUsedProps(fn) {
-  let fnString = filterOutComments(fn.toString());
+function validateSuiteHook(fn, hook, suiteError) {
+  const usedProps = getUsedProps(fn, {
+    sourceError: suiteError,
+    suiteHook: hook
+  });
+  if (usedProps.size) {
+    const error = new FixtureAccessError(`The ${hook} hook uses fixtures "${[...usedProps].join("\", \"")}", but has no access to context. ` + `Did you forget to call it as "test.${hook}()" instead of "${hook}()"?\n` + `If you used internal "suite" task as the first argument previously, access it in the second argument instead. ` + `See https://vitest.dev/guide/test-context#suite-level-hooks`);
+    if (suiteError) {
+      error.stack = suiteError.stack?.replace(suiteError.message, error.message);
+    }
+    throw error;
+  }
+}
+const kPropsSymbol = Symbol("$vitest:fixture-props");
+const kPropNamesSymbol = Symbol("$vitest:fixture-prop-names");
+function configureProps(fn, options) {
+  Object.defineProperty(fn, kPropsSymbol, {
+    value: options,
+    enumerable: false
+  });
+}
+function memoProps(fn, props) {
+  fn[kPropNamesSymbol] = props;
+  return props;
+}
+function getUsedProps(fn, { sourceError, suiteHook } = {}) {
+  if (kPropNamesSymbol in fn) {
+    return fn[kPropNamesSymbol];
+  }
+  const { index: fixturesIndex = 0, original: implementation = fn } = kPropsSymbol in fn ? fn[kPropsSymbol] : {};
+  let fnString = filterOutComments(implementation.toString());
   // match lowered async function and strip it off
   // example code on esbuild-try https://esbuild.github.io/try/#YgAwLjI0LjAALS1zdXBwb3J0ZWQ6YXN5bmMtYXdhaXQ9ZmFsc2UAZQBlbnRyeS50cwBjb25zdCBvID0gewogIGYxOiBhc3luYyAoKSA9PiB7fSwKICBmMjogYXN5bmMgKGEpID0+IHt9LAogIGYzOiBhc3luYyAoYSwgYikgPT4ge30sCiAgZjQ6IGFzeW5jIGZ1bmN0aW9uKGEpIHt9LAogIGY1OiBhc3luYyBmdW5jdGlvbiBmZihhKSB7fSwKICBhc3luYyBmNihhKSB7fSwKCiAgZzE6IGFzeW5jICgpID0+IHt9LAogIGcyOiBhc3luYyAoeyBhIH0pID0+IHt9LAogIGczOiBhc3luYyAoeyBhIH0sIGIpID0+IHt9LAogIGc0OiBhc3luYyBmdW5jdGlvbiAoeyBhIH0pIHt9LAogIGc1OiBhc3luYyBmdW5jdGlvbiBnZyh7IGEgfSkge30sCiAgYXN5bmMgZzYoeyBhIH0pIHt9LAoKICBoMTogYXN5bmMgKCkgPT4ge30sCiAgLy8gY29tbWVudCBiZXR3ZWVuCiAgaDI6IGFzeW5jIChhKSA9PiB7fSwKfQ
   //   __async(this, null, function*
@@ -285,56 +489,37 @@ function getUsedProps(fn) {
   }
   const match = fnString.match(/[^(]*\(([^)]*)/);
   if (!match) {
-    return [];
+    return memoProps(fn, new Set());
   }
   const args = splitByComma(match[1]);
   if (!args.length) {
-    return [];
+    return memoProps(fn, new Set());
   }
-  let first = args[0];
-  if ("__VITEST_FIXTURE_INDEX__" in fn) {
-    first = args[fn.__VITEST_FIXTURE_INDEX__];
-    if (!first) {
-      return [];
-    }
+  const fixturesArgument = args[fixturesIndex];
+  if (!fixturesArgument) {
+    return memoProps(fn, new Set());
   }
-  if (!(first[0] === "{" && first.endsWith("}"))) {
-    throw new Error(`The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`);
+  if (!(fixturesArgument[0] === "{" && fixturesArgument.endsWith("}"))) {
+    const ordinalArgument = ordinal(fixturesIndex + 1);
+    const error = new FixtureParseError(`The ${ordinalArgument} argument inside a fixture must use object destructuring pattern, e.g. ({ task } => {}). ` + `Instead, received "${fixturesArgument}".` + `${suiteHook ? ` If you used internal "suite" task as the ${ordinalArgument} argument previously, access it in the ${ordinal(fixturesIndex + 2)} argument instead.` : ""}`);
+    if (sourceError) {
+      error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+    }
+    throw error;
   }
-  const _first = first.slice(1, -1).replace(/\s/g, "");
+  const _first = fixturesArgument.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}".`);
-  }
-  return props;
-}
-function filterOutComments(s) {
-  const result = [];
-  let commentState = "none";
-  for (let i = 0; i < s.length; ++i) {
-    if (commentState === "singleline") {
-      if (s[i] === "\n") {
-        commentState = "none";
-      }
-    } else if (commentState === "multiline") {
-      if (s[i - 1] === "*" && s[i] === "/") {
-        commentState = "none";
-      }
-    } else if (commentState === "none") {
-      if (s[i] === "/" && s[i + 1] === "/") {
-        commentState = "singleline";
-      } else if (s[i] === "/" && s[i + 1] === "*") {
-        commentState = "multiline";
-        i += 2;
-      } else {
-        result.push(s[i]);
-      }
+    const error = new FixtureParseError(`Rest parameters are not supported in fixtures, received "${last}".`);
+    if (sourceError) {
+      error.stack = sourceError.stack?.replace(sourceError.message, error.message);
     }
+    throw error;
   }
-  return result.join("");
+  return memoProps(fn, new Set(props));
 }
 function splitByComma(s) {
   const result = [];
@@ -383,6 +568,8 @@ function getDefaultHookTimeout() {
 }
 const CLEANUP_TIMEOUT_KEY = Symbol.for("VITEST_CLEANUP_TIMEOUT");
 const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
+const AROUND_TIMEOUT_KEY = Symbol.for("VITEST_AROUND_TIMEOUT");
+const AROUND_STACK_TRACE_KEY = Symbol.for("VITEST_AROUND_STACK_TRACE");
 function getBeforeHookCleanupCallback(hook, result, context) {
   if (typeof result === "function") {
     const timeout = CLEANUP_TIMEOUT_KEY in hook && typeof hook[CLEANUP_TIMEOUT_KEY] === "number" ? hook[CLEANUP_TIMEOUT_KEY] : getDefaultHookTimeout();
@@ -414,7 +601,8 @@ function getBeforeHookCleanupCallback(hook, result, context) {
 function beforeAll(fn, timeout = getDefaultHookTimeout()) {
   assertTypes(fn, "\"beforeAll\" callback", ["function"]);
   const stackTraceError = new Error("STACK_TRACE_ERROR");
-  return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(fn, timeout, true, stackTraceError), {
+  const context = getChainableContext(this);
+  return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(withSuiteFixtures("beforeAll", fn, context, stackTraceError), timeout, true, stackTraceError), {
     [CLEANUP_TIMEOUT_KEY]: timeout,
     [CLEANUP_STACK_TRACE_KEY]: stackTraceError
   }));
@@ -438,7 +626,9 @@ function beforeAll(fn, timeout = getDefaultHookTimeout()) {
 */
 function afterAll(fn, timeout) {
   assertTypes(fn, "\"afterAll\" callback", ["function"]);
-  return getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR")));
+  const context = getChainableContext(this);
+  const stackTraceError = new Error("STACK_TRACE_ERROR");
+  return getCurrentSuite().on("afterAll", withTimeout(withSuiteFixtures("afterAll", fn, context, stackTraceError), timeout ?? getDefaultHookTimeout(), true, stackTraceError));
 }
 /**
 * Registers a callback function to be executed before each test within the current suite.
@@ -460,8 +650,11 @@ function afterAll(fn, timeout) {
 function beforeEach(fn, timeout = getDefaultHookTimeout()) {
   assertTypes(fn, "\"beforeEach\" callback", ["function"]);
   const stackTraceError = new Error("STACK_TRACE_ERROR");
-  const runner = getRunner();
-  return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(withFixtures(runner, fn), timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
+  const wrapper = (context, suite) => {
+    const fixtureResolver = withFixtures(fn, { suite });
+    return fixtureResolver(context);
+  };
+  return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
     [CLEANUP_TIMEOUT_KEY]: timeout,
     [CLEANUP_STACK_TRACE_KEY]: stackTraceError
   }));
@@ -485,8 +678,11 @@ function beforeEach(fn, timeout = getDefaultHookTimeout()) {
 */
 function afterEach(fn, timeout) {
   assertTypes(fn, "\"afterEach\" callback", ["function"]);
-  const runner = getRunner();
-  return getCurrentSuite().on("afterEach", withTimeout(withFixtures(runner, fn), timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+  const wrapper = (context, suite) => {
+    const fixtureResolver = withFixtures(fn, { suite });
+    return fixtureResolver(context);
+  };
+  return getCurrentSuite().on("afterEach", withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
 }
 /**
 * Registers a callback function to be executed when a test fails within the current suite.
@@ -507,7 +703,7 @@ function afterEach(fn, timeout) {
 * ```
 */
 const onTestFailed = createTestHook("onTestFailed", (test, handler, timeout) => {
-  test.onFailed || (test.onFailed = []);
+  test.onFailed ||= [];
   test.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
 });
 /**
@@ -534,9 +730,116 @@ const onTestFailed = createTestHook("onTestFailed", (test, handler, timeout) =>
 * ```
 */
 const onTestFinished = createTestHook("onTestFinished", (test, handler, timeout) => {
-  test.onFinished || (test.onFinished = []);
+  test.onFinished ||= [];
   test.onFinished.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error("STACK_TRACE_ERROR"), abortIfTimeout));
 });
+/**
+* Registers a callback function that wraps around all tests within the current suite.
+* The callback receives a `runSuite` function that must be called to run the suite's tests.
+* This hook is useful for scenarios where you need to wrap an entire suite in a context
+* (e.g., starting a server, opening a database connection that all tests share).
+*
+* **Note:** When multiple `aroundAll` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* @param {Function} fn - The callback function that wraps the suite. Must call `runSuite()` to run the tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using aroundAll to wrap suite in a tracing span
+* aroundAll(async (runSuite) => {
+*   await tracer.trace('test-suite', runSuite);
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundAll with fixtures
+* aroundAll(async (runSuite, { db }) => {
+*   await db.transaction(() => runSuite());
+* });
+* ```
+*/
+function aroundAll(fn, timeout) {
+  assertTypes(fn, "\"aroundAll\" callback", ["function"]);
+  const stackTraceError = new Error("STACK_TRACE_ERROR");
+  const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+  const context = getChainableContext(this);
+  return getCurrentSuite().on("aroundAll", Object.assign(withSuiteFixtures("aroundAll", fn, context, stackTraceError, 1), {
+    [AROUND_TIMEOUT_KEY]: resolvedTimeout,
+    [AROUND_STACK_TRACE_KEY]: stackTraceError
+  }));
+}
+/**
+* Registers a callback function that wraps around each test within the current suite.
+* The callback receives a `runTest` function that must be called to run the test.
+* This hook is useful for scenarios where you need to wrap tests in a context (e.g., database transactions).
+*
+* **Note:** When multiple `aroundEach` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* @param {Function} fn - The callback function that wraps the test. Must call `runTest()` to run the test.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using aroundEach to wrap tests in a database transaction
+* aroundEach(async (runTest) => {
+*   await database.transaction(() => runTest());
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundEach with fixtures
+* aroundEach(async (runTest, { db }) => {
+*   await db.transaction(() => runTest());
+* });
+* ```
+*/
+function aroundEach(fn, timeout) {
+  assertTypes(fn, "\"aroundEach\" callback", ["function"]);
+  const stackTraceError = new Error("STACK_TRACE_ERROR");
+  const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+  const wrapper = (runTest, context, suite) => {
+    const innerFn = (ctx) => fn(runTest, ctx, suite);
+    configureProps(innerFn, {
+      index: 1,
+      original: fn
+    });
+    const fixtureResolver = withFixtures(innerFn, { suite });
+    return fixtureResolver(context);
+  };
+  return getCurrentSuite().on("aroundEach", Object.assign(wrapper, {
+    [AROUND_TIMEOUT_KEY]: resolvedTimeout,
+    [AROUND_STACK_TRACE_KEY]: stackTraceError
+  }));
+}
+function withSuiteFixtures(suiteHook, fn, context, stackTraceError, contextIndex = 0) {
+  return (...args) => {
+    const suite = args.at(-1);
+    const prefix = args.slice(0, -1);
+    const wrapper = (ctx) => fn(...prefix, ctx, suite);
+    configureProps(wrapper, {
+      index: contextIndex,
+      original: fn
+    });
+    const fixtures = context?.getFixtures();
+    const fileContext = fixtures?.getFileContext(suite.file);
+    const fixtured = withFixtures(wrapper, {
+      suiteHook,
+      fixtures,
+      context: fileContext,
+      stackTraceError
+    });
+    return fixtured();
+  };
+}
+function getAroundHookTimeout(hook) {
+  return AROUND_TIMEOUT_KEY in hook && typeof hook[AROUND_TIMEOUT_KEY] === "number" ? hook[AROUND_TIMEOUT_KEY] : getDefaultHookTimeout();
+}
+function getAroundHookStackTrace(hook) {
+  return AROUND_STACK_TRACE_KEY in hook && hook[AROUND_STACK_TRACE_KEY] instanceof Error ? hook[AROUND_STACK_TRACE_KEY] : undefined;
+}
 function createTestHook(name, handler) {
   return (fn, timeout) => {
     assertTypes(fn, `"${name}" callback`, ["function"]);
@@ -693,18 +996,22 @@ function getRunner() {
 }
 function createDefaultSuite(runner) {
   const config = runner.config.sequence;
-  const collector = suite("", { concurrent: config.concurrent }, () => {});
+  const options = {};
+  if (config.concurrent != null) {
+    options.concurrent = config.concurrent;
+  }
+  const collector = suite("", options, () => {});
   // no parent suite for top-level tests
   delete collector.suite;
   return collector;
 }
 function clearCollectorContext(file, currentRunner) {
+  currentTestFilepath = file.filepath;
+  runner = currentRunner;
   if (!defaultSuite) {
     defaultSuite = createDefaultSuite(currentRunner);
   }
   defaultSuite.file = file;
-  runner = currentRunner;
-  currentTestFilepath = file.filepath;
   collectorContext.tasks.length = 0;
   defaultSuite.clear();
   collectorContext.currentSuite = defaultSuite;
@@ -719,9 +1026,12 @@ function createSuiteHooks() {
     beforeAll: [],
     afterAll: [],
     beforeEach: [],
-    afterEach: []
+    afterEach: [],
+    aroundEach: [],
+    aroundAll: []
   };
 }
+const POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
 function parseArguments(optionsOrFn, timeoutOrTest) {
   if (timeoutOrTest != null && typeof timeoutOrTest === "object") {
     throw new TypeError(`Signature "test(name, fn, { ... })" was deprecated in Vitest 3 and removed in Vitest 4. Please, provide options as a second argument instead.`);
@@ -748,32 +1058,66 @@ function parseArguments(optionsOrFn, timeoutOrTest) {
   };
 }
 // implementations
-function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions, parentCollectorFixtures) {
+function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions) {
   const tasks = [];
   let suite;
   initSuite(true);
   const task = function(name = "", options = {}) {
-    var _collectorContext$cur, _collectorContext$cur2, _collectorContext$cur3;
-    const timeout = (options === null || options === void 0 ? void 0 : options.timeout) ?? runner.config.testTimeout;
-    const currentSuite = (_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.suite;
+    const currentSuite = collectorContext.currentSuite?.suite;
+    const parentTask = currentSuite ?? collectorContext.currentSuite?.file;
+    const parentTags = parentTask?.tags || [];
+    const testTags = unique([...parentTags, ...toArray(options.tags)]);
+    const tagsOptions = testTags.map((tag) => {
+      const tagDefinition = runner.config.tags?.find((t) => t.name === tag);
+      if (!tagDefinition && runner.config.strictTags) {
+        throw createNoTagsError(runner.config.tags, tag);
+      }
+      return tagDefinition;
+    }).filter((r) => r != null).sort((tag1, tag2) => (tag2.priority ?? POSITIVE_INFINITY) - (tag1.priority ?? POSITIVE_INFINITY)).reduce((acc, tag) => {
+      const { name, description, priority, meta, ...options } = tag;
+      Object.assign(acc, options);
+      if (meta) {
+        acc.meta = Object.assign(acc.meta ?? Object.create(null), meta);
+      }
+      return acc;
+    }, {});
+    const testOwnMeta = options.meta;
+    options = {
+      ...tagsOptions,
+      ...options
+    };
+    const timeout = options.timeout ?? runner.config.testTimeout;
+    const parentMeta = currentSuite?.meta;
+    const tagMeta = tagsOptions.meta;
+    const testMeta = Object.create(null);
+    if (tagMeta) {
+      Object.assign(testMeta, tagMeta);
+    }
+    if (parentMeta) {
+      Object.assign(testMeta, parentMeta);
+    }
+    if (testOwnMeta) {
+      Object.assign(testMeta, testOwnMeta);
+    }
     const task = {
       id: "",
       name,
-      fullName: createTaskName([(currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur2 = collectorContext.currentSuite) === null || _collectorContext$cur2 === void 0 || (_collectorContext$cur2 = _collectorContext$cur2.file) === null || _collectorContext$cur2 === void 0 ? void 0 : _collectorContext$cur2.fullName), name]),
-      fullTestName: createTaskName([currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName, name]),
+      fullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name]),
+      fullTestName: createTaskName([currentSuite?.fullTestName, name]),
       suite: currentSuite,
       each: options.each,
       fails: options.fails,
       context: undefined,
       type: "test",
-      file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur3 = collectorContext.currentSuite) === null || _collectorContext$cur3 === void 0 ? void 0 : _collectorContext$cur3.file),
+      file: currentSuite?.file ?? collectorContext.currentSuite?.file,
       timeout,
       retry: options.retry ?? runner.config.retry,
       repeats: options.repeats,
       mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
-      meta: options.meta ?? Object.create(null),
+      meta: testMeta,
       annotations: [],
-      artifacts: []
+      artifacts: [],
+      tags: testTags
     };
     const handler = options.handler;
     if (task.mode === "run" && !handler) {
@@ -782,21 +1126,20 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
     if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
       task.concurrent = true;
     }
-    task.shuffle = suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.shuffle;
+    task.shuffle = suiteOptions?.shuffle;
     const context = createTestContext(task, runner);
     // create test context
     Object.defineProperty(task, "context", {
       value: context,
       enumerable: false
     });
-    setTestFixture(context, options.fixtures);
-    // custom can be called from any place, let's assume the limit is 15 stacks
+    setTestFixture(context, options.fixtures ?? new TestFixtures());
     const limit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 15;
+    Error.stackTraceLimit = 10;
     const stackTraceError = new Error("STACK_TRACE_ERROR");
     Error.stackTraceLimit = limit;
     if (handler) {
-      setFn(task, withTimeout(withAwaitAsyncAssertions(withFixtures(runner, handler, context), task), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
+      setFn(task, withTimeout(withCancel(withAwaitAsyncAssertions(withFixtures(handler, { context }), task), task.context.signal), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
     }
     if (runner.config.includeTaskLocation) {
       const error = stackTraceError.stack;
@@ -818,8 +1161,14 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
       options = Object.assign({}, suiteOptions, options);
     }
     // inherit concurrent / sequential from suite
-    options.concurrent = this.concurrent || !this.sequential && (options === null || options === void 0 ? void 0 : options.concurrent);
-    options.sequential = this.sequential || !this.concurrent && (options === null || options === void 0 ? void 0 : options.sequential);
+    const concurrent = this.concurrent ?? (!this.sequential && options?.concurrent);
+    if (options.concurrent != null && concurrent != null) {
+      options.concurrent = concurrent;
+    }
+    const sequential = this.sequential ?? (!this.concurrent && options?.sequential);
+    if (options.sequential != null && sequential != null) {
+      options.sequential = sequential;
+    }
     const test = task(formatName(name), {
       ...this,
       ...options,
@@ -827,7 +1176,6 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
     });
     test.type = "test";
   });
-  let collectorFixtures = parentCollectorFixtures;
   const collector = {
     type: "collector",
     name,
@@ -835,44 +1183,39 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
     suite,
     options: suiteOptions,
     test,
+    file: suite.file,
     tasks,
     collect,
     task,
     clear,
-    on: addHook,
-    fixtures() {
-      return collectorFixtures;
-    },
-    scoped(fixtures) {
-      const parsed = mergeContextFixtures(fixtures, { fixtures: collectorFixtures }, runner);
-      if (parsed.fixtures) {
-        collectorFixtures = parsed.fixtures;
-      }
-    }
+    on: addHook
   };
   function addHook(name, ...fn) {
     getHooks(suite)[name].push(...fn);
   }
   function initSuite(includeLocation) {
-    var _collectorContext$cur4, _collectorContext$cur5, _collectorContext$cur6;
     if (typeof suiteOptions === "number") {
       suiteOptions = { timeout: suiteOptions };
     }
-    const currentSuite = (_collectorContext$cur4 = collectorContext.currentSuite) === null || _collectorContext$cur4 === void 0 ? void 0 : _collectorContext$cur4.suite;
+    const currentSuite = collectorContext.currentSuite?.suite;
+    const parentTask = currentSuite ?? collectorContext.currentSuite?.file;
+    const suiteTags = toArray(suiteOptions?.tags);
+    validateTags(runner.config, suiteTags);
     suite = {
       id: "",
       type: "suite",
       name,
-      fullName: createTaskName([(currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullName) ?? ((_collectorContext$cur5 = collectorContext.currentSuite) === null || _collectorContext$cur5 === void 0 || (_collectorContext$cur5 = _collectorContext$cur5.file) === null || _collectorContext$cur5 === void 0 ? void 0 : _collectorContext$cur5.fullName), name]),
-      fullTestName: createTaskName([currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fullTestName, name]),
+      fullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name]),
+      fullTestName: createTaskName([currentSuite?.fullTestName, name]),
       suite: currentSuite,
       mode,
       each,
-      file: (currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.file) ?? ((_collectorContext$cur6 = collectorContext.currentSuite) === null || _collectorContext$cur6 === void 0 ? void 0 : _collectorContext$cur6.file),
-      shuffle: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.shuffle,
+      file: currentSuite?.file ?? collectorContext.currentSuite?.file,
+      shuffle: suiteOptions?.shuffle,
       tasks: [],
-      meta: Object.create(null),
-      concurrent: suiteOptions === null || suiteOptions === void 0 ? void 0 : suiteOptions.concurrent
+      meta: suiteOptions?.meta ?? Object.create(null),
+      concurrent: suiteOptions?.concurrent,
+      tags: unique([...parentTask?.tags || [], ...suiteTags])
     };
     if (runner && includeLocation && runner.config.includeTaskLocation) {
       const limit = Error.stackTraceLimit;
@@ -926,34 +1269,46 @@ function withAwaitAsyncAssertions(fn, task) {
 }
 function createSuite() {
   function suiteFn(name, factoryOrOptions, optionsOrFactory) {
-    var _currentSuite$options;
     if (getCurrentTest()) {
       throw new Error("Calling the suite function inside test function is not allowed. It can be only called at the top level or inside another suite function.");
     }
-    let mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
     const currentSuite = collectorContext.currentSuite || defaultSuite;
     let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
-    if (mode === "run" && !factory) {
-      mode = "todo";
-    }
     const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
     const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
+    const { meta: parentMeta, ...parentOptions } = currentSuite?.options || {};
     // inherit options from current suite
     options = {
-      ...currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.options,
-      ...options,
-      shuffle: this.shuffle ?? options.shuffle ?? (currentSuite === null || currentSuite === void 0 || (_currentSuite$options = currentSuite.options) === null || _currentSuite$options === void 0 ? void 0 : _currentSuite$options.shuffle) ?? (runner === null || runner === void 0 ? void 0 : runner.config.sequence.shuffle)
+      ...parentOptions,
+      ...options
     };
+    const shuffle = this.shuffle ?? options.shuffle ?? currentSuite?.options?.shuffle ?? runner?.config.sequence.shuffle;
+    if (shuffle != null) {
+      options.shuffle = shuffle;
+    }
+    let mode = this.only ?? options.only ? "only" : this.skip ?? options.skip ? "skip" : this.todo ?? options.todo ? "todo" : "run";
+    // passed as test(name), assume it's a "todo"
+    if (mode === "run" && !factory) {
+      mode = "todo";
+    }
     // inherit concurrent / sequential from suite
     const isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;
     const isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;
-    options.concurrent = isConcurrent && !isSequential;
-    options.sequential = isSequential && !isConcurrent;
-    return createSuiteCollector(formatName(name), factory, mode, this.each, options, currentSuite === null || currentSuite === void 0 ? void 0 : currentSuite.fixtures());
+    if (isConcurrent != null) {
+      options.concurrent = isConcurrent && !isSequential;
+    }
+    if (isSequential != null) {
+      options.sequential = isSequential && !isConcurrent;
+    }
+    if (parentMeta) {
+      options.meta = Object.assign(Object.create(null), parentMeta, options.meta);
+    }
+    return createSuiteCollector(formatName(name), factory, mode, this.each, options);
   }
   suiteFn.each = function(cases, ...args) {
-    const suite = this.withContext();
-    this.setContext("each", true);
+    const context = getChainableContext(this);
+    const suite = context.withContext();
+    context.setContext("each", true);
     if (Array.isArray(cases) && args.length) {
       cases = formatTemplateString(cases, args);
     }
@@ -978,7 +1333,7 @@ function createSuite() {
           }
         }
       });
-      this.setContext("each", undefined);
+      context.setContext("each", undefined);
     };
   };
   suiteFn.for = function(cases, ...args) {
@@ -1004,11 +1359,12 @@ function createSuite() {
     "todo"
   ], suiteFn);
 }
-function createTaskCollector(fn, context) {
+function createTaskCollector(fn) {
   const taskFn = fn;
   taskFn.each = function(cases, ...args) {
-    const test = this.withContext();
-    this.setContext("each", true);
+    const context = getChainableContext(this);
+    const test = context.withContext();
+    context.setContext("each", true);
     if (Array.isArray(cases) && args.length) {
       cases = formatTemplateString(cases, args);
     }
@@ -1033,11 +1389,12 @@ function createTaskCollector(fn, context) {
           }
         }
       });
-      this.setContext("each", undefined);
+      context.setContext("each", undefined);
     };
   };
   taskFn.for = function(cases, ...args) {
-    const test = this.withContext();
+    const context = getChainableContext(this);
+    const test = context.withContext();
     if (Array.isArray(cases) && args.length) {
       cases = formatTemplateString(cases, args);
     }
@@ -1048,8 +1405,10 @@ function createTaskCollector(fn, context) {
         // monkey-patch handler to allow parsing fixture
         const handlerWrapper = handler ? (ctx) => handler(item, ctx) : undefined;
         if (handlerWrapper) {
-          handlerWrapper.__VITEST_FIXTURE_INDEX__ = 1;
-          handlerWrapper.toString = () => handler.toString();
+          configureProps(handlerWrapper, {
+            index: 1,
+            original: handler
+          });
         }
         test(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
       });
@@ -1061,27 +1420,91 @@ function createTaskCollector(fn, context) {
   taskFn.runIf = function(condition) {
     return condition ? this : this.skip;
   };
+  /**
+  * Parse builder pattern arguments into a fixtures object.
+  * Handles both builder pattern (name, options?, value) and object syntax.
+  */
+  function parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn) {
+    // Object syntax: just return as-is
+    if (typeof fixturesOrName !== "string") {
+      return fixturesOrName;
+    }
+    const fixtureName = fixturesOrName;
+    let fixtureOptions;
+    let fixtureValue;
+    if (maybeFn !== undefined) {
+      // (name, options, value) or (name, options, fn)
+      fixtureOptions = optionsOrFn;
+      fixtureValue = maybeFn;
+    } else {
+      // (name, value) or (name, fn)
+      // Check if optionsOrFn looks like fixture options (has scope or auto)
+      if (optionsOrFn !== null && typeof optionsOrFn === "object" && !Array.isArray(optionsOrFn) && ("scope" in optionsOrFn || "auto" in optionsOrFn)) {
+        // (name, options) with no value - treat as empty object fixture
+        fixtureOptions = optionsOrFn;
+        fixtureValue = {};
+      } else {
+        // (name, value) or (name, fn)
+        fixtureOptions = undefined;
+        fixtureValue = optionsOrFn;
+      }
+    }
+    // Function value: wrap with onCleanup pattern
+    if (typeof fixtureValue === "function") {
+      const builderFn = fixtureValue;
+      // Wrap builder pattern function (returns value) to use() pattern
+      const fixture = async (ctx, use) => {
+        let cleanup;
+        const onCleanup = (fn) => {
+          if (cleanup !== undefined) {
+            throw new Error(`onCleanup can only be called once per fixture. ` + `Define separate fixtures if you need multiple cleanup functions.`);
+          }
+          cleanup = fn;
+        };
+        const value = await builderFn(ctx, { onCleanup });
+        await use(value);
+        if (cleanup) {
+          await cleanup();
+        }
+      };
+      configureProps(fixture, { original: builderFn });
+      if (fixtureOptions) {
+        return { [fixtureName]: [fixture, fixtureOptions] };
+      }
+      return { [fixtureName]: fixture };
+    }
+    // Non-function value: use directly
+    if (fixtureOptions) {
+      return { [fixtureName]: [fixtureValue, fixtureOptions] };
+    }
+    return { [fixtureName]: fixtureValue };
+  }
+  taskFn.override = function(fixturesOrName, optionsOrFn, maybeFn) {
+    const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+    getChainableContext(this).getFixtures().override(runner, userFixtures);
+    return this;
+  };
   taskFn.scoped = function(fixtures) {
-    const collector = getCurrentSuite();
-    collector.scoped(fixtures);
+    console.warn(`test.scoped() is deprecated and will be removed in future versions. Please use test.override() instead.`);
+    return this.override(fixtures);
   };
-  taskFn.extend = function(fixtures) {
-    const _context = mergeContextFixtures(fixtures, context || {}, runner);
-    const originalWrapper = fn;
-    return createTest(function(name, optionsOrFn, optionsOrTest) {
-      const collector = getCurrentSuite();
-      const scopedFixtures = collector.fixtures();
-      const context = { ...this };
-      if (scopedFixtures) {
-        context.fixtures = mergeScopedFixtures(context.fixtures || [], scopedFixtures);
-      }
-      originalWrapper.call(context, formatName(name), optionsOrFn, optionsOrTest);
-    }, _context);
+  taskFn.extend = function(fixturesOrName, optionsOrFn, maybeFn) {
+    const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+    const fixtures = getChainableContext(this).getFixtures().extend(runner, userFixtures);
+    const _test = createTest(function(name, optionsOrFn, optionsOrTest) {
+      fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+    });
+    getChainableContext(_test).mergeContext({ fixtures });
+    return _test;
   };
+  taskFn.describe = suite;
+  taskFn.suite = suite;
   taskFn.beforeEach = beforeEach;
   taskFn.afterEach = afterEach;
   taskFn.beforeAll = beforeAll;
   taskFn.afterAll = afterAll;
+  taskFn.aroundEach = aroundEach;
+  taskFn.aroundAll = aroundAll;
   const _test = createChainable([
     "concurrent",
     "sequential",
@@ -1089,14 +1512,11 @@ function createTaskCollector(fn, context) {
     "only",
     "todo",
     "fails"
-  ], taskFn);
-  if (context) {
-    _test.mergeContext(context);
-  }
+  ], taskFn, { fixtures: new TestFixtures() });
   return _test;
 }
-function createTest(fn, context) {
-  return createTaskCollector(fn, context);
+function createTest(fn) {
+  return createTaskCollector(fn);
 }
 function formatName(name) {
   return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
@@ -1123,14 +1543,13 @@ function formatTitle(template, items, idx) {
   const isObjectItem = isObject(items[0]);
   function formatAttribute(s) {
     return s.replace(/\$([$\w.]+)/g, (_, key) => {
-      var _runner$config;
       const isArrayKey = /^\d+$/.test(key);
       if (!isObjectItem && !isArrayKey) {
         return `$${key}`;
       }
       const arrayElement = isArrayKey ? objectAttr(items, key) : undefined;
       const value = isObjectItem ? objectAttr(items[0], key, arrayElement) : arrayElement;
-      return objDisplay(value, { truncate: runner === null || runner === void 0 || (_runner$config = runner.config) === null || _runner$config === void 0 || (_runner$config = _runner$config.chaiConfig) === null || _runner$config === void 0 ? void 0 : _runner$config.truncateThreshold });
+      return objDisplay(value, { truncate: runner?.config?.chaiConfig?.truncateThreshold });
     });
   }
   let output = "";
@@ -1180,14 +1599,13 @@ function formatTemplateString(cases, args) {
   return res;
 }
 
-const now$2 = Date.now;
+const now$2 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 const collectorContext = {
   tasks: [],
   currentSuite: null
 };
 function collectTask(task) {
-  var _collectorContext$cur;
-  (_collectorContext$cur = collectorContext.currentSuite) === null || _collectorContext$cur === void 0 ? void 0 : _collectorContext$cur.tasks.push(task);
+  collectorContext.currentSuite?.tasks.push(task);
 }
 async function runWithSuite(suite, fn) {
   const prev = collectorContext.currentSuite;
@@ -1207,16 +1625,15 @@ function withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {
     runner._currentTaskStartTime = startTime;
     runner._currentTaskTimeout = timeout;
     return new Promise((resolve_, reject_) => {
-      var _timer$unref;
       const timer = setTimeout(() => {
         clearTimeout(timer);
         rejectTimeoutError();
       }, timeout);
       // `unref` might not exist in browser
-      (_timer$unref = timer.unref) === null || _timer$unref === void 0 ? void 0 : _timer$unref.call(timer);
+      timer.unref?.();
       function rejectTimeoutError() {
         const error = makeTimeoutError(isHook, timeout, stackTraceError);
-        onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(args, error);
+        onTimeout?.(args, error);
         reject_(error);
       }
       function resolve(result) {
@@ -1256,6 +1673,23 @@ catch (error) {
     });
   });
 }
+function withCancel(fn, signal) {
+  return (function runWithCancel(...args) {
+    return new Promise((resolve, reject) => {
+      signal.addEventListener("abort", () => reject(signal.reason));
+      try {
+        const result = fn(...args);
+        if (typeof result === "object" && result != null && typeof result.then === "function") {
+          result.then(resolve, reject);
+        } else {
+          resolve(result);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
 const abortControllers = new WeakMap();
 function abortIfTimeout([context], error) {
   if (context) {
@@ -1264,10 +1698,9 @@ function abortIfTimeout([context], error) {
 }
 function abortContextSignal(context, error) {
   const abortController = abortControllers.get(context);
-  abortController === null || abortController === void 0 ? void 0 : abortController.abort(error);
+  abortController?.abort(error);
 }
 function createTestContext(test, runner) {
-  var _runner$extendTaskCon;
   const context = function() {
     throw new Error("done() callback is deprecated, use promise instead");
   };
@@ -1283,7 +1716,7 @@ function createTestContext(test, runner) {
       // do nothing
       return undefined;
     }
-    test.result ?? (test.result = { state: "skip" });
+    test.result ??= { state: "skip" };
     test.result.pending = true;
     throw new PendingError("test is skipped; abort execution", test, typeof condition === "string" ? condition : note);
   };
@@ -1314,34 +1747,23 @@ function createTestContext(test, runner) {
     }));
   });
   context.onTestFailed = (handler, timeout) => {
-    test.onFailed || (test.onFailed = []);
+    test.onFailed ||= [];
     test.onFailed.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
   };
   context.onTestFinished = (handler, timeout) => {
-    test.onFinished || (test.onFinished = []);
+    test.onFinished ||= [];
     test.onFinished.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
   };
-  return ((_runner$extendTaskCon = runner.extendTaskContext) === null || _runner$extendTaskCon === void 0 ? void 0 : _runner$extendTaskCon.call(runner, context)) || context;
+  return runner.extendTaskContext?.(context) || context;
 }
 function makeTimeoutError(isHook, timeout, stackTraceError) {
   const message = `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.\nIf this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
   const error = new Error(message);
-  if (stackTraceError === null || stackTraceError === void 0 ? void 0 : stackTraceError.stack) {
+  if (stackTraceError?.stack) {
     error.stack = stackTraceError.stack.replace(error.message, stackTraceError.message);
   }
   return error;
 }
-const fileContexts = new WeakMap();
-function getFileContext(file) {
-  const context = fileContexts.get(file);
-  if (!context) {
-    throw new Error(`Cannot find file context for ${file.name}`);
-  }
-  return context;
-}
-function setFileContext(file, context) {
-  fileContexts.set(file, context);
-}
 
 async function runSetupFiles(config, files, runner) {
   if (config.sequence.setupFiles === "parallel") {
@@ -1360,18 +1782,22 @@ async function collectTests(specs, runner) {
   const files = [];
   const config = runner.config;
   const $ = runner.trace;
+  let defaultTagsFilter;
   for (const spec of specs) {
     const filepath = typeof spec === "string" ? spec : spec.filepath;
     await $("collect_spec", { "code.file.path": filepath }, async () => {
-      var _runner$onCollectStar;
       const testLocations = typeof spec === "string" ? undefined : spec.testLocations;
+      const testNamePattern = typeof spec === "string" ? undefined : spec.testNamePattern;
+      const testIds = typeof spec === "string" ? undefined : spec.testIds;
+      const testTagsFilter = typeof spec === "object" && spec.testTagsFilter ? createTagsFilter(spec.testTagsFilter, config.tags) : undefined;
+      const fileTags = typeof spec === "string" ? [] : spec.fileTags || [];
       const file = createFileTask(filepath, config.root, config.name, runner.pool, runner.viteEnvironment);
-      setFileContext(file, Object.create(null));
+      file.tags = fileTags;
       file.shuffle = config.sequence.shuffle;
-      (_runner$onCollectStar = runner.onCollectStart) === null || _runner$onCollectStar === void 0 ? void 0 : _runner$onCollectStar.call(runner, file);
-      clearCollectorContext(file, runner);
       try {
-        var _runner$getImportDura;
+        validateTags(runner.config, fileTags);
+        runner.onCollectStart?.(file);
+        clearCollectorContext(file, runner);
         const setupFiles = toArray(config.setupFiles);
         if (setupFiles.length) {
           const setupStart = now$1();
@@ -1383,7 +1809,7 @@ async function collectTests(specs, runner) {
         }
         const collectStart = now$1();
         await runner.importFile(filepath, "collect");
-        const durations = (_runner$getImportDura = runner.getImportDurations) === null || _runner$getImportDura === void 0 ? void 0 : _runner$getImportDura.call(runner);
+        const durations = runner.getImportDurations?.();
         if (durations) {
           file.importDurations = durations;
         }
@@ -1407,20 +1833,22 @@ async function collectTests(specs, runner) {
         setHooks(file, fileHooks);
         file.collectDuration = now$1() - collectStart;
       } catch (e) {
-        var _runner$getImportDura2;
-        const error = processError(e);
+        const errors = e instanceof AggregateError ? e.errors.map((e) => processError(e, runner.config.diffOptions)) : [processError(e, runner.config.diffOptions)];
         file.result = {
           state: "fail",
-          errors: [error]
+          errors
         };
-        const durations = (_runner$getImportDura2 = runner.getImportDurations) === null || _runner$getImportDura2 === void 0 ? void 0 : _runner$getImportDura2.call(runner);
+        const durations = runner.getImportDurations?.();
         if (durations) {
           file.importDurations = durations;
         }
       }
       calculateSuiteHash(file);
       const hasOnlyTasks = someTasksAreOnly(file);
-      interpretTaskModes(file, config.testNamePattern, testLocations, hasOnlyTasks, false, config.allowOnly);
+      if (!testTagsFilter && !defaultTagsFilter && config.tagsFilter) {
+        defaultTagsFilter = createTagsFilter(config.tagsFilter, config.tags);
+      }
+      interpretTaskModes(file, testNamePattern ?? config.testNamePattern, testLocations, testIds, testTagsFilter ?? defaultTagsFilter, hasOnlyTasks, false, config.allowOnly);
       if (file.mode === "queued") {
         file.mode = "run";
       }
@@ -1440,6 +1868,38 @@ function mergeHooks(baseHooks, hooks) {
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 const unixNow = Date.now;
 const { clearTimeout, setTimeout } = getSafeTimers();
+let limitMaxConcurrency;
+/**
+* Normalizes retry configuration to extract individual values.
+* Handles both number and object forms.
+*/
+function getRetryCount(retry) {
+  if (retry === undefined) {
+    return 0;
+  }
+  if (typeof retry === "number") {
+    return retry;
+  }
+  return retry.count ?? 0;
+}
+function getRetryDelay(retry) {
+  if (retry === undefined) {
+    return 0;
+  }
+  if (typeof retry === "number") {
+    return 0;
+  }
+  return retry.delay ?? 0;
+}
+function getRetryCondition(retry) {
+  if (retry === undefined) {
+    return undefined;
+  }
+  if (typeof retry === "number") {
+    return undefined;
+  }
+  return retry.condition;
+}
 function updateSuiteHookState(task, name, state, runner) {
   if (!task.result) {
     task.result = { state: "run" };
@@ -1482,14 +1942,14 @@ async function callTestHooks(runner, test, hooks, sequence) {
   };
   if (sequence === "parallel") {
     try {
-      await Promise.all(hooks.map((fn) => fn(test.context)));
+      await Promise.all(hooks.map((fn) => limitMaxConcurrency(() => fn(test.context))));
     } catch (e) {
       failTask(test.result, e, runner.config.diffOptions);
     }
   } else {
     for (const fn of hooks) {
       try {
-        await fn(test.context);
+        await limitMaxConcurrency(() => fn(test.context));
       } catch (e) {
         failTask(test.result, e, runner.config.diffOptions);
       }
@@ -1511,7 +1971,9 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
     updateSuiteHookState(currentTask, name, "run", runner);
   }
   async function runHook(hook) {
-    return getBeforeHookCleanupCallback(hook, await hook(...args), name === "beforeEach" ? args[0] : undefined);
+    return limitMaxConcurrency(async () => {
+      return getBeforeHookCleanupCallback(hook, await hook(...args), name === "beforeEach" ? args[0] : undefined);
+    });
   }
   if (sequence === "parallel") {
     callbacks.push(...await Promise.all(hooks.map((hook) => runHook(hook))));
@@ -1528,12 +1990,185 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
   }
   return callbacks;
 }
+function getAroundEachHooks(suite) {
+  const hooks = [];
+  const parentSuite = "filepath" in suite ? null : suite.suite || suite.file;
+  if (parentSuite) {
+    hooks.push(...getAroundEachHooks(parentSuite));
+  }
+  hooks.push(...getHooks(suite).aroundEach);
+  return hooks;
+}
+function getAroundAllHooks(suite) {
+  return getHooks(suite).aroundAll;
+}
+function makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError) {
+  const message = `The ${phase} phase of "${hookName}" hook timed out after ${timeout}ms.`;
+  const ErrorClass = phase === "setup" ? AroundHookSetupError : AroundHookTeardownError;
+  const error = new ErrorClass(message);
+  if (stackTraceError?.stack) {
+    error.stack = stackTraceError.stack.replace(stackTraceError.message, error.message);
+  }
+  return error;
+}
+async function callAroundHooks(runInner, options) {
+  const { hooks, hookName, callbackName, onTimeout, invokeHook } = options;
+  if (!hooks.length) {
+    await runInner();
+    return;
+  }
+  const hookErrors = [];
+  const createTimeoutPromise = (timeout, phase, stackTraceError) => {
+    let timer;
+    let timedout = false;
+    const promise = new Promise((_, reject) => {
+      if (timeout > 0 && timeout !== Number.POSITIVE_INFINITY) {
+        timer = setTimeout(() => {
+          timedout = true;
+          const error = makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError);
+          onTimeout?.(error);
+          reject(error);
+        }, timeout);
+        timer.unref?.();
+      }
+    });
+    const clear = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = undefined;
+      }
+    };
+    return {
+      promise,
+      clear,
+      isTimedOut: () => timedout
+    };
+  };
+  const runNextHook = async (index) => {
+    if (index >= hooks.length) {
+      return runInner();
+    }
+    const hook = hooks[index];
+    const timeout = getAroundHookTimeout(hook);
+    const stackTraceError = getAroundHookStackTrace(hook);
+    let useCalled = false;
+    let setupTimeout;
+    let teardownTimeout;
+    let setupLimitConcurrencyRelease;
+    let teardownLimitConcurrencyRelease;
+    // Promise that resolves when use() is called (setup phase complete)
+    let resolveUseCalled;
+    const useCalledPromise = new Promise((resolve) => {
+      resolveUseCalled = resolve;
+    });
+    // Promise that resolves when use() returns (inner hooks complete, teardown phase starts)
+    let resolveUseReturned;
+    const useReturnedPromise = new Promise((resolve) => {
+      resolveUseReturned = resolve;
+    });
+    // Promise that resolves when hook completes
+    let resolveHookComplete;
+    let rejectHookComplete;
+    const hookCompletePromise = new Promise((resolve, reject) => {
+      resolveHookComplete = resolve;
+      rejectHookComplete = reject;
+    });
+    const use = async () => {
+      // shouldn't continue to next (runTest/Suite or inner aroundEach/All) when aroundEach/All setup timed out.
+      if (setupTimeout.isTimedOut()) {
+        // we can throw any error to bail out.
+        // this error is not seen by end users since `runNextHook` already rejected with timeout error
+        // and this error is caught by `rejectHookComplete`.
+        throw new Error("__VITEST_INTERNAL_AROUND_HOOK_ABORT__");
+      }
+      if (useCalled) {
+        throw new AroundHookMultipleCallsError(`The \`${callbackName}\` callback was called multiple times in the \`${hookName}\` hook. ` + `The callback can only be called once per hook.`);
+      }
+      useCalled = true;
+      resolveUseCalled();
+      // Setup phase completed - clear setup timer
+      setupTimeout.clear();
+      setupLimitConcurrencyRelease?.();
+      // Run inner hooks - don't time this against our teardown timeout
+      await runNextHook(index + 1).catch((e) => hookErrors.push(e));
+      teardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
+      // Start teardown timer after inner hooks complete - only times this hook's teardown code
+      teardownTimeout = createTimeoutPromise(timeout, "teardown", stackTraceError);
+      // Signal that use() is returning (teardown phase starting)
+      resolveUseReturned();
+    };
+    setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
+    // Start setup timeout
+    setupTimeout = createTimeoutPromise(timeout, "setup", stackTraceError);
+    (async () => {
+      try {
+        await invokeHook(hook, use);
+        if (!useCalled) {
+          throw new AroundHookSetupError(`The \`${callbackName}\` callback was not called in the \`${hookName}\` hook. ` + `Make sure to call \`${callbackName}\` to run the ${hookName === "aroundEach" ? "test" : "suite"}.`);
+        }
+        resolveHookComplete();
+      } catch (error) {
+        rejectHookComplete(error);
+      } finally {
+        setupLimitConcurrencyRelease?.();
+        teardownLimitConcurrencyRelease?.();
+      }
+    })();
+    // Wait for either: use() to be called OR hook to complete (error) OR setup timeout
+    try {
+      await Promise.race([
+        useCalledPromise,
+        hookCompletePromise,
+        setupTimeout.promise
+      ]);
+    } finally {
+      setupLimitConcurrencyRelease?.();
+      setupTimeout.clear();
+    }
+    // Wait for use() to return (inner hooks complete) OR hook to complete (error during inner hooks)
+    await Promise.race([useReturnedPromise, hookCompletePromise]);
+    // Now teardownTimeout is guaranteed to be set
+    // Wait for hook to complete (teardown) OR teardown timeout
+    try {
+      await Promise.race([hookCompletePromise, teardownTimeout?.promise]);
+    } finally {
+      teardownLimitConcurrencyRelease?.();
+      teardownTimeout?.clear();
+    }
+  };
+  await runNextHook(0).catch((e) => hookErrors.push(e));
+  if (hookErrors.length > 0) {
+    throw hookErrors;
+  }
+}
+async function callAroundAllHooks(suite, runSuiteInner) {
+  await callAroundHooks(runSuiteInner, {
+    hooks: getAroundAllHooks(suite),
+    hookName: "aroundAll",
+    callbackName: "runSuite()",
+    invokeHook: (hook, use) => hook(use, suite)
+  });
+}
+async function callAroundEachHooks(suite, test, runTest) {
+  await callAroundHooks(
+    // Take checkpoint right before runTest - at this point all aroundEach fixtures
+    // have been resolved, so we can correctly identify which fixtures belong to
+    // aroundEach (before checkpoint) vs inside runTest (after checkpoint)
+    () => runTest(getFixtureCleanupCount(test.context)),
+    {
+      hooks: getAroundEachHooks(suite),
+      hookName: "aroundEach",
+      callbackName: "runTest()",
+      onTimeout: (error) => abortContextSignal(test.context, error),
+      invokeHook: (hook, use) => hook(use, test.context, suite)
+    }
+  );
+}
 const packs = new Map();
 const eventsPacks = [];
 const pendingTasksUpdates = [];
 function sendTasksUpdate(runner) {
   if (packs.size) {
-    var _runner$onTaskUpdate;
     const taskPacks = Array.from(packs).map(([id, task]) => {
       return [
         id,
@@ -1541,7 +2176,7 @@ function sendTasksUpdate(runner) {
         task[1]
       ];
     });
-    const p = (_runner$onTaskUpdate = runner.onTaskUpdate) === null || _runner$onTaskUpdate === void 0 ? void 0 : _runner$onTaskUpdate.call(runner, taskPacks, eventsPacks);
+    const p = runner.onTaskUpdate?.(taskPacks, eventsPacks);
     if (p) {
       pendingTasksUpdates.push(p);
       // remove successful promise to not grow array indefnitely,
@@ -1568,7 +2203,7 @@ function throttle(fn, ms) {
       return fn.apply(this, args);
     }
     // Make sure fn is still called even if there are no further calls
-    pendingCall ?? (pendingCall = setTimeout(() => call.bind(this)(...args), ms));
+    pendingCall ??= setTimeout(() => call.bind(this)(...args), ms);
   };
 }
 // throttle based on summary reporter's DURATION_UPDATE_INTERVAL_MS
@@ -1592,26 +2227,44 @@ async function callCleanupHooks(runner, cleanups) {
       if (typeof fn !== "function") {
         return;
       }
-      await fn();
+      await limitMaxConcurrency(() => fn());
     }));
   } else {
     for (const fn of cleanups) {
       if (typeof fn !== "function") {
         continue;
       }
-      await fn();
+      await limitMaxConcurrency(() => fn());
     }
   }
 }
+/**
+* Determines if a test should be retried based on its retryCondition configuration
+*/
+function passesRetryCondition(test, errors) {
+  const condition = getRetryCondition(test.retry);
+  if (!errors || errors.length === 0) {
+    return false;
+  }
+  if (!condition) {
+    return true;
+  }
+  const error = errors[errors.length - 1];
+  if (condition instanceof RegExp) {
+    return condition.test(error.message || "");
+  } else if (typeof condition === "function") {
+    return condition(error);
+  }
+  return false;
+}
 async function runTest(test, runner) {
-  var _runner$onBeforeRunTa, _test$result, _runner$onAfterRunTas;
-  await ((_runner$onBeforeRunTa = runner.onBeforeRunTask) === null || _runner$onBeforeRunTa === void 0 ? void 0 : _runner$onBeforeRunTa.call(runner, test));
+  await runner.onBeforeRunTask?.(test);
   if (test.mode !== "run" && test.mode !== "queued") {
     updateTask("test-prepare", test, runner);
     updateTask("test-finished", test, runner);
     return;
   }
-  if (((_test$result = test.result) === null || _test$result === void 0 ? void 0 : _test$result.state) === "fail") {
+  if (test.result?.state === "fail") {
     // should not be possible to get here, I think this is just copy pasted from suite
     // TODO: maybe someone fails tests in `beforeAll` hooks?
     // https://github.com/vitest-dev/vitest/pull/7069
@@ -1631,75 +2284,84 @@ async function runTest(test, runner) {
   const $ = runner.trace;
   const repeats = test.repeats ?? 0;
   for (let repeatCount = 0; repeatCount <= repeats; repeatCount++) {
-    const retry = test.retry ?? 0;
+    const retry = getRetryCount(test.retry);
     for (let retryCount = 0; retryCount <= retry; retryCount++) {
-      var _test$onFinished, _test$onFailed, _runner$onAfterRetryT, _test$result2, _test$result3;
       let beforeEachCleanups = [];
-      try {
-        var _runner$onBeforeTryTa, _runner$onAfterTryTas;
-        await ((_runner$onBeforeTryTa = runner.onBeforeTryTask) === null || _runner$onBeforeTryTa === void 0 ? void 0 : _runner$onBeforeTryTa.call(runner, test, {
-          retry: retryCount,
-          repeats: repeatCount
-        }));
-        test.result.repeatCount = repeatCount;
-        beforeEachCleanups = await $("test.beforeEach", () => callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]));
-        if (runner.runTask) {
-          await $("test.callback", () => runner.runTask(test));
-        } else {
-          const fn = getFn(test);
-          if (!fn) {
-            throw new Error("Test function is not found. Did you add it using `setFn`?");
+      // fixtureCheckpoint is passed by callAroundEachHooks - it represents the count
+      // of fixture cleanup functions AFTER all aroundEach fixtures have been resolved
+      // but BEFORE the test runs. This allows us to clean up only fixtures created
+      // inside runTest while preserving aroundEach fixtures for teardown.
+      await callAroundEachHooks(suite, test, async (fixtureCheckpoint) => {
+        try {
+          await runner.onBeforeTryTask?.(test, {
+            retry: retryCount,
+            repeats: repeatCount
+          });
+          test.result.repeatCount = repeatCount;
+          beforeEachCleanups = await $("test.beforeEach", () => callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]));
+          if (runner.runTask) {
+            await $("test.callback", () => limitMaxConcurrency(() => runner.runTask(test)));
+          } else {
+            const fn = getFn(test);
+            if (!fn) {
+              throw new Error("Test function is not found. Did you add it using `setFn`?");
+            }
+            await $("test.callback", () => limitMaxConcurrency(() => fn()));
           }
-          await $("test.callback", () => fn());
-        }
-        await ((_runner$onAfterTryTas = runner.onAfterTryTask) === null || _runner$onAfterTryTas === void 0 ? void 0 : _runner$onAfterTryTas.call(runner, test, {
-          retry: retryCount,
-          repeats: repeatCount
-        }));
-        if (test.result.state !== "fail") {
-          if (!test.repeats) {
-            test.result.state = "pass";
-          } else if (test.repeats && retry === retryCount) {
+          await runner.onAfterTryTask?.(test, {
+            retry: retryCount,
+            repeats: repeatCount
+          });
+          if (test.result.state !== "fail") {
             test.result.state = "pass";
           }
+        } catch (e) {
+          failTask(test.result, e, runner.config.diffOptions);
         }
-      } catch (e) {
-        failTask(test.result, e, runner.config.diffOptions);
-      }
-      try {
-        var _runner$onTaskFinishe;
-        await ((_runner$onTaskFinishe = runner.onTaskFinished) === null || _runner$onTaskFinishe === void 0 ? void 0 : _runner$onTaskFinishe.call(runner, test));
-      } catch (e) {
-        failTask(test.result, e, runner.config.diffOptions);
-      }
-      try {
-        await $("test.afterEach", () => callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]));
-        if (beforeEachCleanups.length) {
-          await $("test.cleanup", () => callCleanupHooks(runner, beforeEachCleanups));
+        try {
+          await runner.onTaskFinished?.(test);
+        } catch (e) {
+          failTask(test.result, e, runner.config.diffOptions);
+        }
+        try {
+          await $("test.afterEach", () => callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]));
+          if (beforeEachCleanups.length) {
+            await $("test.cleanup", () => callCleanupHooks(runner, beforeEachCleanups));
+          }
+          // Only clean up fixtures created inside runTest (after the checkpoint)
+          // Fixtures created for aroundEach will be cleaned up after aroundEach teardown
+          await callFixtureCleanupFrom(test.context, fixtureCheckpoint);
+        } catch (e) {
+          failTask(test.result, e, runner.config.diffOptions);
+        }
+        if (test.onFinished?.length) {
+          await $("test.onFinished", () => callTestHooks(runner, test, test.onFinished, "stack"));
+        }
+        if (test.result.state === "fail" && test.onFailed?.length) {
+          await $("test.onFailed", () => callTestHooks(runner, test, test.onFailed, runner.config.sequence.hooks));
         }
+        test.onFailed = undefined;
+        test.onFinished = undefined;
+        await runner.onAfterRetryTask?.(test, {
+          retry: retryCount,
+          repeats: repeatCount
+        });
+      }).catch((error) => {
+        failTask(test.result, error, runner.config.diffOptions);
+      });
+      // Clean up fixtures that were created for aroundEach (before the checkpoint)
+      // This runs after aroundEach teardown has completed
+      try {
         await callFixtureCleanup(test.context);
       } catch (e) {
         failTask(test.result, e, runner.config.diffOptions);
       }
-      if ((_test$onFinished = test.onFinished) === null || _test$onFinished === void 0 ? void 0 : _test$onFinished.length) {
-        await $("test.onFinished", () => callTestHooks(runner, test, test.onFinished, "stack"));
-      }
-      if (test.result.state === "fail" && ((_test$onFailed = test.onFailed) === null || _test$onFailed === void 0 ? void 0 : _test$onFailed.length)) {
-        await $("test.onFailed", () => callTestHooks(runner, test, test.onFailed, runner.config.sequence.hooks));
-      }
-      test.onFailed = undefined;
-      test.onFinished = undefined;
-      await ((_runner$onAfterRetryT = runner.onAfterRetryTask) === null || _runner$onAfterRetryT === void 0 ? void 0 : _runner$onAfterRetryT.call(runner, test, {
-        retry: retryCount,
-        repeats: repeatCount
-      }));
       // skipped with new PendingError
-      if (((_test$result2 = test.result) === null || _test$result2 === void 0 ? void 0 : _test$result2.pending) || ((_test$result3 = test.result) === null || _test$result3 === void 0 ? void 0 : _test$result3.state) === "skip") {
-        var _test$result4;
+      if (test.result?.pending || test.result?.state === "skip") {
         test.mode = "skip";
         test.result = {
           state: "skip",
-          note: (_test$result4 = test.result) === null || _test$result4 === void 0 ? void 0 : _test$result4.note,
+          note: test.result?.note,
           pending: true,
           duration: now() - start
         };
@@ -1712,9 +2374,16 @@ async function runTest(test, runner) {
         break;
       }
       if (retryCount < retry) {
-        // reset state when retry test
+        const shouldRetry = passesRetryCondition(test, test.result.errors);
+        if (!shouldRetry) {
+          break;
+        }
         test.result.state = "run";
         test.result.retryCount = (test.result.retryCount ?? 0) + 1;
+        const delay = getRetryDelay(test.retry);
+        if (delay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
       }
       // update retry info
       updateTask("test-retried", test, runner);
@@ -1734,7 +2403,7 @@ async function runTest(test, runner) {
   cleanupRunningTest();
   setCurrentTest(undefined);
   test.result.duration = now() - start;
-  await ((_runner$onAfterRunTas = runner.onAfterRunTask) === null || _runner$onAfterRunTas === void 0 ? void 0 : _runner$onAfterRunTas.call(runner, test));
+  await runner.onAfterRunTask?.(test);
   updateTask("test-finished", test, runner);
 }
 function failTask(result, err, diffOptions) {
@@ -1744,12 +2413,17 @@ function failTask(result, err, diffOptions) {
     result.pending = true;
     return;
   }
+  if (err instanceof TestRunAbortError) {
+    result.state = "skip";
+    result.note = err.message;
+    return;
+  }
   result.state = "fail";
   const errors = Array.isArray(err) ? err : [err];
   for (const e of errors) {
-    const error = processError(e, diffOptions);
-    result.errors ?? (result.errors = []);
-    result.errors.push(error);
+    const errors = e instanceof AggregateError ? e.errors.map((e) => processError(e, diffOptions)) : [processError(e, diffOptions)];
+    result.errors ??= [];
+    result.errors.push(...errors);
   }
 }
 function markTasksAsSkipped(suite, runner) {
@@ -1765,10 +2439,25 @@ function markTasksAsSkipped(suite, runner) {
     }
   });
 }
+function markPendingTasksAsSkipped(suite, runner, note) {
+  suite.tasks.forEach((t) => {
+    if (!t.result || t.result.state === "run") {
+      t.mode = "skip";
+      t.result = {
+        ...t.result,
+        state: "skip",
+        note
+      };
+      updateTask("test-cancel", t, runner);
+    }
+    if (t.type === "suite") {
+      markPendingTasksAsSkipped(t, runner, note);
+    }
+  });
+}
 async function runSuite(suite, runner) {
-  var _runner$onBeforeRunSu, _suite$result;
-  await ((_runner$onBeforeRunSu = runner.onBeforeRunSuite) === null || _runner$onBeforeRunSu === void 0 ? void 0 : _runner$onBeforeRunSu.call(runner, suite));
-  if (((_suite$result = suite.result) === null || _suite$result === void 0 ? void 0 : _suite$result.state) === "fail") {
+  await runner.onBeforeRunSuite?.(suite);
+  if (suite.result?.state === "fail") {
     markTasksAsSkipped(suite, runner);
     // failed during collection
     updateTask("suite-failed-early", suite, runner);
@@ -1790,55 +2479,68 @@ async function runSuite(suite, runner) {
     suite.result.state = "todo";
     updateTask("suite-finished", suite, runner);
   } else {
-    var _runner$onAfterRunSui;
+    let suiteRan = false;
     try {
-      try {
-        beforeAllCleanups = await $("suite.beforeAll", () => callSuiteHook(suite, suite, "beforeAll", runner, [suite]));
-      } catch (e) {
-        markTasksAsSkipped(suite, runner);
-        throw e;
-      }
-      if (runner.runSuite) {
-        await runner.runSuite(suite);
-      } else {
-        for (let tasksGroup of partitionSuiteChildren(suite)) {
-          if (tasksGroup[0].concurrent === true) {
-            await Promise.all(tasksGroup.map((c) => runSuiteChild(c, runner)));
+      await callAroundAllHooks(suite, async () => {
+        suiteRan = true;
+        try {
+          // beforeAll
+          try {
+            beforeAllCleanups = await $("suite.beforeAll", () => callSuiteHook(suite, suite, "beforeAll", runner, [suite]));
+          } catch (e) {
+            failTask(suite.result, e, runner.config.diffOptions);
+            markTasksAsSkipped(suite, runner);
+            return;
+          }
+          // run suite children
+          if (runner.runSuite) {
+            await runner.runSuite(suite);
           } else {
-            const { sequence } = runner.config;
-            if (suite.shuffle) {
-              // run describe block independently from tests
-              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));
+            for (let tasksGroup of partitionSuiteChildren(suite)) {
+              if (tasksGroup[0].concurrent === true) {
+                await Promise.all(tasksGroup.map((c) => runSuiteChild(c, runner)));
+              } else {
+                const { sequence } = runner.config;
+                if (suite.shuffle) {
+                  // run describe block independently from tests
+                  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));
+                }
+                for (const c of tasksGroup) {
+                  await runSuiteChild(c, runner);
+                }
+              }
+            }
+          }
+        } finally {
+          // afterAll runs even if beforeAll or suite children fail
+          try {
+            await $("suite.afterAll", () => callSuiteHook(suite, suite, "afterAll", runner, [suite]));
+            if (beforeAllCleanups.length) {
+              await $("suite.cleanup", () => callCleanupHooks(runner, beforeAllCleanups));
             }
-            for (const c of tasksGroup) {
-              await runSuiteChild(c, runner);
+            if (suite.file === suite) {
+              const contexts = TestFixtures.getFileContexts(suite.file);
+              await Promise.all(contexts.map((context) => callFixtureCleanup(context)));
             }
+          } catch (e) {
+            failTask(suite.result, e, runner.config.diffOptions);
           }
         }
-      }
+      });
     } catch (e) {
-      failTask(suite.result, e, runner.config.diffOptions);
-    }
-    try {
-      await $("suite.afterAll", () => callSuiteHook(suite, suite, "afterAll", runner, [suite]));
-      if (beforeAllCleanups.length) {
-        await $("suite.cleanup", () => callCleanupHooks(runner, beforeAllCleanups));
-      }
-      if (suite.file === suite) {
-        const context = getFileContext(suite);
-        await callFixtureCleanup(context);
+      // mark tasks as skipped if aroundAll failed before the suite callback was executed
+      if (!suiteRan) {
+        markTasksAsSkipped(suite, runner);
       }
-    } catch (e) {
       failTask(suite.result, e, runner.config.diffOptions);
     }
     if (suite.mode === "run" || suite.mode === "queued") {
       if (!runner.config.passWithNoTests && !hasTests(suite)) {
-        var _suite$result$errors;
         suite.result.state = "fail";
-        if (!((_suite$result$errors = suite.result.errors) === null || _suite$result$errors === void 0 ? void 0 : _suite$result$errors.length)) {
+        if (!suite.result.errors?.length) {
           const error = processError(new Error(`No test found in suite ${suite.name}`));
           suite.result.errors = [error];
         }
@@ -1849,44 +2551,38 @@ async function runSuite(suite, runner) {
       }
     }
     suite.result.duration = now() - start;
-    await ((_runner$onAfterRunSui = runner.onAfterRunSuite) === null || _runner$onAfterRunSui === void 0 ? void 0 : _runner$onAfterRunSui.call(runner, suite));
+    await runner.onAfterRunSuite?.(suite);
     updateTask("suite-finished", suite, runner);
   }
 }
-let limitMaxConcurrency;
 async function runSuiteChild(c, runner) {
   const $ = runner.trace;
   if (c.type === "test") {
-    return limitMaxConcurrency(() => {
-      var _c$location, _c$location2;
-      return $("run.test", {
-        "vitest.test.id": c.id,
-        "vitest.test.name": c.name,
-        "vitest.test.mode": c.mode,
-        "vitest.test.timeout": c.timeout,
-        "code.file.path": c.file.filepath,
-        "code.line.number": (_c$location = c.location) === null || _c$location === void 0 ? void 0 : _c$location.line,
-        "code.column.number": (_c$location2 = c.location) === null || _c$location2 === void 0 ? void 0 : _c$location2.column
-      }, () => runTest(c, runner));
-    });
+    return $("run.test", {
+      "vitest.test.id": c.id,
+      "vitest.test.name": c.name,
+      "vitest.test.mode": c.mode,
+      "vitest.test.timeout": c.timeout,
+      "code.file.path": c.file.filepath,
+      "code.line.number": c.location?.line,
+      "code.column.number": c.location?.column
+    }, () => runTest(c, runner));
   } else if (c.type === "suite") {
-    var _c$location3, _c$location4;
     return $("run.suite", {
       "vitest.suite.id": c.id,
       "vitest.suite.name": c.name,
       "vitest.suite.mode": c.mode,
       "code.file.path": c.file.filepath,
-      "code.line.number": (_c$location3 = c.location) === null || _c$location3 === void 0 ? void 0 : _c$location3.line,
-      "code.column.number": (_c$location4 = c.location) === null || _c$location4 === void 0 ? void 0 : _c$location4.column
+      "code.line.number": c.location?.line,
+      "code.column.number": c.location?.column
     }, () => runSuite(c, runner));
   }
 }
 async function runFiles(files, runner) {
-  limitMaxConcurrency ?? (limitMaxConcurrency = limitConcurrency(runner.config.maxConcurrency));
+  limitMaxConcurrency ??= limitConcurrency(runner.config.maxConcurrency);
   for (const file of files) {
     if (!file.tasks.length && !runner.config.passWithNoTests) {
-      var _file$result;
-      if (!((_file$result = file.result) === null || _file$result === void 0 || (_file$result = _file$result.errors) === null || _file$result === void 0 ? void 0 : _file$result.length)) {
+      if (!file.result?.errors?.length) {
         const error = processError(new Error(`No test suite found in file ${file.filepath}`));
         file.result = {
           state: "fail",
@@ -1908,37 +2604,35 @@ function defaultTrace(_, attributes, cb) {
   return cb();
 }
 async function startTests(specs, runner) {
-  var _runner$cancel;
-  runner.trace ?? (runner.trace = defaultTrace);
-  const cancel = (_runner$cancel = runner.cancel) === null || _runner$cancel === void 0 ? void 0 : _runner$cancel.bind(runner);
+  runner.trace ??= defaultTrace;
+  const cancel = runner.cancel?.bind(runner);
   // Ideally, we need to have an event listener for this, but only have a runner here.
   // Adding another onCancel felt wrong (maybe it needs to be refactored)
   runner.cancel = (reason) => {
     // We intentionally create only one error since there is only one test run that can be cancelled
     const error = new TestRunAbortError("The test run was aborted by the user.", reason);
-    getRunningTests().forEach((test) => abortContextSignal(test.context, error));
-    return cancel === null || cancel === void 0 ? void 0 : cancel(reason);
+    getRunningTests().forEach((test) => {
+      abortContextSignal(test.context, error);
+      markPendingTasksAsSkipped(test.file, runner, error.message);
+    });
+    return cancel?.(reason);
   };
   if (!workerRunners.has(runner)) {
-    var _runner$onCleanupWork;
-    (_runner$onCleanupWork = runner.onCleanupWorkerContext) === null || _runner$onCleanupWork === void 0 ? void 0 : _runner$onCleanupWork.call(runner, async () => {
-      var _runner$getWorkerCont;
-      const context = (_runner$getWorkerCont = runner.getWorkerContext) === null || _runner$getWorkerCont === void 0 ? void 0 : _runner$getWorkerCont.call(runner);
-      if (context) {
-        await callFixtureCleanup(context);
-      }
+    runner.onCleanupWorkerContext?.(async () => {
+      await Promise.all([...TestFixtures.getWorkerContexts()].map((context) => callFixtureCleanup(context))).finally(() => {
+        TestFixtures.clearDefinitions();
+      });
     });
     workerRunners.add(runner);
   }
   try {
-    var _runner$onBeforeColle, _runner$onCollected, _runner$onBeforeRunFi, _runner$onAfterRunFil;
     const paths = specs.map((f) => typeof f === "string" ? f : f.filepath);
-    await ((_runner$onBeforeColle = runner.onBeforeCollect) === null || _runner$onBeforeColle === void 0 ? void 0 : _runner$onBeforeColle.call(runner, paths));
+    await runner.onBeforeCollect?.(paths);
     const files = await collectTests(specs, runner);
-    await ((_runner$onCollected = runner.onCollected) === null || _runner$onCollected === void 0 ? void 0 : _runner$onCollected.call(runner, files));
-    await ((_runner$onBeforeRunFi = runner.onBeforeRunFiles) === null || _runner$onBeforeRunFi === void 0 ? void 0 : _runner$onBeforeRunFi.call(runner, files));
+    await runner.onCollected?.(files);
+    await runner.onBeforeRunFiles?.(files);
     await runFiles(files, runner);
-    await ((_runner$onAfterRunFil = runner.onAfterRunFiles) === null || _runner$onAfterRunFil === void 0 ? void 0 : _runner$onAfterRunFil.call(runner, files));
+    await runner.onAfterRunFiles?.(files);
     await finishSendTasksUpdate(runner);
     return files;
   } finally {
@@ -1946,12 +2640,11 @@ async function startTests(specs, runner) {
   }
 }
 async function publicCollect(specs, runner) {
-  var _runner$onBeforeColle2, _runner$onCollected2;
-  runner.trace ?? (runner.trace = defaultTrace);
+  runner.trace ??= defaultTrace;
   const paths = specs.map((f) => typeof f === "string" ? f : f.filepath);
-  await ((_runner$onBeforeColle2 = runner.onBeforeCollect) === null || _runner$onBeforeColle2 === void 0 ? void 0 : _runner$onBeforeColle2.call(runner, paths));
+  await runner.onBeforeCollect?.(paths);
   const files = await collectTests(specs, runner);
-  await ((_runner$onCollected2 = runner.onCollected) === null || _runner$onCollected2 === void 0 ? void 0 : _runner$onCollected2.call(runner, files));
+  await runner.onCollected?.(files);
   return files;
 }
 
@@ -1965,12 +2658,13 @@ async function publicCollect(specs, runner) {
 *
 * Vitest automatically injects the source location where the artifact was created and manages any attachments you include.
 *
+* **Note:** artifacts must be recorded before the task is reported. Any artifacts recorded after that will not be included in the task.
+*
 * @param task - The test task context, typically accessed via `this.task` in custom matchers or `context.task` in tests
 * @param artifact - The artifact to record. Must extend {@linkcode TestArtifactBase}
 *
 * @returns A promise that resolves to the recorded artifact with location injected
 *
-* @throws {Error} If called after the test has finished running
 * @throws {Error} If the test runner doesn't support artifacts
 *
 * @example
@@ -1991,9 +2685,6 @@ async function publicCollect(specs, runner) {
 */
 async function recordArtifact(task, artifact) {
   const runner = getRunner();
-  if (task.result && task.result.state !== "run") {
-    throw new Error(`Cannot record a test artifact outside of the test run. The test "${task.name}" finished running with the "${task.result.state}" state already.`);
-  }
   const stack = findTestFileStackTrace(task.file.filepath, new Error("STACK_TRACE").stack);
   if (stack) {
     artifact.location = {
@@ -2111,4 +2802,4 @@ function manageArtifactAttachment(attachment) {
   }
 }
 
-export { afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, recordArtifact, setFn, setHooks, startTests, suite, test, updateTask };
+export { afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, recordArtifact, setFn, setHooks, startTests, suite, test, updateTask };