From 84350412eb77a28ef6a39ed1c08d5d9146aa94b8 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 12:57:35 +0900
Subject: [PATCH 01/33] fix: `beforeAll/afterAll` should respect
 `maxConcurrency`

---
 packages/runner/src/run.ts | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index 398008044aec..3be0a69b05c5 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -786,6 +786,8 @@ function markTasksAsSkipped(suite: Suite, runner: VitestRunner) {
   })
 }
 
+let limitMaxConcurrency: ReturnType<typeof limitConcurrency>
+
 export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void> {
   await runner.onBeforeRunSuite?.(suite)
 
@@ -829,13 +831,13 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
         try {
           // beforeAll
           try {
-            beforeAllCleanups = await $('suite.beforeAll', () => callSuiteHook(
+            beforeAllCleanups = await $('suite.beforeAll', () => limitMaxConcurrency(() => callSuiteHook(
               suite,
               suite,
               'beforeAll',
               runner,
               [suite],
-            ))
+            )))
           }
           catch (e) {
             failTask(suite.result!, e, runner.config.diffOptions)
@@ -875,9 +877,9 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
         finally {
           // afterAll runs even if beforeAll or suite children fail
           try {
-            await $('suite.afterAll', () => callSuiteHook(suite, suite, 'afterAll', runner, [suite]))
+            await $('suite.afterAll', () => limitMaxConcurrency(() => callSuiteHook(suite, suite, 'afterAll', runner, [suite])))
             if (beforeAllCleanups.length) {
-              await $('suite.cleanup', () => callCleanupHooks(runner, beforeAllCleanups))
+              await $('suite.cleanup', () => limitMaxConcurrency(() => callCleanupHooks(runner, beforeAllCleanups)))
             }
             if (suite.file === suite) {
               const contexts = TestFixtures.getFileContexts(suite.file)
@@ -924,8 +926,6 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
   }
 }
 
-let limitMaxConcurrency: ReturnType<typeof limitConcurrency>
-
 async function runSuiteChild(c: Task, runner: VitestRunner) {
   const $ = runner.trace!
   if (c.type === 'test') {

From e202b06ee859fb10438879c91c33a3b88e1f2eed Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 13:01:25 +0900
Subject: [PATCH 02/33] docs: update

---
 docs/config/maxconcurrency.md              | 2 +-
 packages/vitest/src/node/cli/cli-config.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/config/maxconcurrency.md b/docs/config/maxconcurrency.md
index 6026efe77c05..6d59d633d0b0 100644
--- a/docs/config/maxconcurrency.md
+++ b/docs/config/maxconcurrency.md
@@ -9,6 +9,6 @@ outline: deep
 - **Default**: `5`
 - **CLI**: `--max-concurrency=10`, `--maxConcurrency=10`
 
-A number of tests that are allowed to run at the same time marked with `test.concurrent`.
+A number of tests and hooks that are allowed to run at the same time marked with `test.concurrent`.
 
 Test above this limit will be queued to run when available slot appears.
diff --git a/packages/vitest/src/node/cli/cli-config.ts b/packages/vitest/src/node/cli/cli-config.ts
index a1d982da003b..afe132644982 100644
--- a/packages/vitest/src/node/cli/cli-config.ts
+++ b/packages/vitest/src/node/cli/cli-config.ts
@@ -716,7 +716,7 @@ export const cliOptionsConfig: VitestCLIOptions = {
     },
   },
   maxConcurrency: {
-    description: 'Maximum number of concurrent tests in a suite (default: `5`)',
+    description: 'Maximum number of tests and hooks allowed to run concurrently (default: `5`)',
     argument: '<number>',
   },
   expect: {

From 4a709e7f6195b5805c212cfd80ff91c405152478 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 13:03:05 +0900
Subject: [PATCH 03/33] docs: more

---
 docs/config/maxconcurrency.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/config/maxconcurrency.md b/docs/config/maxconcurrency.md
index 6d59d633d0b0..11a467fde226 100644
--- a/docs/config/maxconcurrency.md
+++ b/docs/config/maxconcurrency.md
@@ -9,6 +9,6 @@ outline: deep
 - **Default**: `5`
 - **CLI**: `--max-concurrency=10`, `--maxConcurrency=10`
 
-A number of tests and hooks that are allowed to run at the same time marked with `test.concurrent`.
+A number of tests and hooks that are allowed to run at the same time marked with `test.concurrent` and `describe.concurrent`.
 
 Test above this limit will be queued to run when available slot appears.

From bc91621a7f1728977c70a988aa480924385d832c Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 13:07:21 +0900
Subject: [PATCH 04/33] docs: clarify maxConcurrency includes concurrent hooks

---
 docs/config/maxconcurrency.md | 4 ++--
 docs/guide/cli-generated.md   | 2 +-
 docs/guide/parallelism.md     | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/config/maxconcurrency.md b/docs/config/maxconcurrency.md
index 11a467fde226..08d584b6f052 100644
--- a/docs/config/maxconcurrency.md
+++ b/docs/config/maxconcurrency.md
@@ -9,6 +9,6 @@ outline: deep
 - **Default**: `5`
 - **CLI**: `--max-concurrency=10`, `--maxConcurrency=10`
 
-A number of tests and hooks that are allowed to run at the same time marked with `test.concurrent` and `describe.concurrent`.
+The maximum number of tests and hooks allowed to run at the same time when using `test.concurrent` and `describe.concurrent`.
 
-Test above this limit will be queued to run when available slot appears.
+Tasks above this limit will be queued until a slot becomes available.
diff --git a/docs/guide/cli-generated.md b/docs/guide/cli-generated.md
index b449a9ad481b..ff7c596d2685 100644
--- a/docs/guide/cli-generated.md
+++ b/docs/guide/cli-generated.md
@@ -767,7 +767,7 @@ Default timeout of a teardown function in milliseconds (default: `10000`)
 - **CLI:** `--maxConcurrency <number>`
 - **Config:** [maxConcurrency](/config/maxconcurrency)
 
-Maximum number of concurrent tests in a suite (default: `5`)
+Maximum number of tests and hooks allowed to run concurrently (default: `5`)
 
 ### expect.requireAssertions
 
diff --git a/docs/guide/parallelism.md b/docs/guide/parallelism.md
index c5772b20865d..b35032f67177 100644
--- a/docs/guide/parallelism.md
+++ b/docs/guide/parallelism.md
@@ -20,7 +20,7 @@ If you have a lot of tests, it is usually faster to run them in parallel, but it
 
 Unlike _test files_, Vitest runs _tests_ in sequence. This means that tests inside a single test file will run in the order they are defined.
 
-Vitest supports the [`concurrent`](/api/test#test-concurrent) option to run tests together. If this option is set, Vitest will group concurrent tests in the same _file_ (the number of simultaneously running tests depends on the [`maxConcurrency`](/config/maxconcurrency) option) and run them with [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all).
+Vitest supports the [`concurrent`](/api/test#test-concurrent) option to run tests together. If this option is set, Vitest will group concurrent tests in the same _file_ (the number of simultaneously running tasks, including hooks, depends on the [`maxConcurrency`](/config/maxconcurrency) option) and run them with [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all).
 
 Vitest doesn't perform any smart analysis and doesn't create additional workers to run these tests. This means that the performance of your tests will improve only if you rely heavily on asynchronous operations. For example, these tests will still run one after another even though the `concurrent` option is specified. This is because they are synchronous:
 

From ab411616f2b27fe4b99ee233fafb1a0484da0a73 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 13:30:51 +0900
Subject: [PATCH 05/33] docs: clarify maxConcurrency and sequence.hooks
 behavior

---
 docs/config/maxconcurrency.md              | 6 ++++--
 docs/guide/cli-generated.md                | 2 +-
 docs/guide/parallelism.md                  | 2 +-
 packages/vitest/src/node/cli/cli-config.ts | 2 +-
 4 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/docs/config/maxconcurrency.md b/docs/config/maxconcurrency.md
index 08d584b6f052..199a8fb3cead 100644
--- a/docs/config/maxconcurrency.md
+++ b/docs/config/maxconcurrency.md
@@ -9,6 +9,8 @@ outline: deep
 - **Default**: `5`
 - **CLI**: `--max-concurrency=10`, `--maxConcurrency=10`
 
-The maximum number of tests and hooks allowed to run at the same time when using `test.concurrent` and `describe.concurrent`.
+The maximum number of tests and suite lifecycle hooks allowed to run at the same time when using `test.concurrent` and `describe.concurrent`.
 
-Tasks above this limit will be queued until a slot becomes available.
+Entries above this limit are queued until a slot becomes available.
+
+Within each running test or suite, hooks at the same level can still run fully in parallel when [`sequence.hooks`](/config/sequence#sequence-hooks) is set to `parallel` (for example, `beforeEach` / `afterEach`, and `beforeAll` / `afterAll` registered in the same suite).
diff --git a/docs/guide/cli-generated.md b/docs/guide/cli-generated.md
index ff7c596d2685..055d28b506ef 100644
--- a/docs/guide/cli-generated.md
+++ b/docs/guide/cli-generated.md
@@ -767,7 +767,7 @@ Default timeout of a teardown function in milliseconds (default: `10000`)
 - **CLI:** `--maxConcurrency <number>`
 - **Config:** [maxConcurrency](/config/maxconcurrency)
 
-Maximum number of tests and hooks allowed to run concurrently (default: `5`)
+Maximum number of concurrent tests and suite lifecycle hooks in a file (default: `5`)
 
 ### expect.requireAssertions
 
diff --git a/docs/guide/parallelism.md b/docs/guide/parallelism.md
index b35032f67177..d3c9c7cc0e10 100644
--- a/docs/guide/parallelism.md
+++ b/docs/guide/parallelism.md
@@ -20,7 +20,7 @@ If you have a lot of tests, it is usually faster to run them in parallel, but it
 
 Unlike _test files_, Vitest runs _tests_ in sequence. This means that tests inside a single test file will run in the order they are defined.
 
-Vitest supports the [`concurrent`](/api/test#test-concurrent) option to run tests together. If this option is set, Vitest will group concurrent tests in the same _file_ (the number of simultaneously running tasks, including hooks, depends on the [`maxConcurrency`](/config/maxconcurrency) option) and run them with [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all).
+Vitest supports the [`concurrent`](/api/test#test-concurrent) option to run tests together. If this option is set, Vitest will group concurrent tests in the same _file_ (the number of simultaneously running tests and suite lifecycle hooks depends on the [`maxConcurrency`](/config/maxconcurrency) option) and run them with [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all).
 
 Vitest doesn't perform any smart analysis and doesn't create additional workers to run these tests. This means that the performance of your tests will improve only if you rely heavily on asynchronous operations. For example, these tests will still run one after another even though the `concurrent` option is specified. This is because they are synchronous:
 
diff --git a/packages/vitest/src/node/cli/cli-config.ts b/packages/vitest/src/node/cli/cli-config.ts
index afe132644982..081dd4a5bb68 100644
--- a/packages/vitest/src/node/cli/cli-config.ts
+++ b/packages/vitest/src/node/cli/cli-config.ts
@@ -716,7 +716,7 @@ export const cliOptionsConfig: VitestCLIOptions = {
     },
   },
   maxConcurrency: {
-    description: 'Maximum number of tests and hooks allowed to run concurrently (default: `5`)',
+    description: 'Maximum number of concurrent tests and suite lifecycle hooks in a file (default: `5`)',
     argument: '<number>',
   },
   expect: {

From f60f0255cc5c448b203126c7bdd0b979d6d1e38a Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 14:18:06 +0900
Subject: [PATCH 06/33] docs: simplify maxConcurrency wording and hook note

---
 docs/config/maxconcurrency.md | 6 +++---
 docs/config/sequence.md       | 2 +-
 docs/guide/parallelism.md     | 2 ++
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/docs/config/maxconcurrency.md b/docs/config/maxconcurrency.md
index 199a8fb3cead..b397044eb7c7 100644
--- a/docs/config/maxconcurrency.md
+++ b/docs/config/maxconcurrency.md
@@ -9,8 +9,8 @@ outline: deep
 - **Default**: `5`
 - **CLI**: `--max-concurrency=10`, `--maxConcurrency=10`
 
-The maximum number of tests and suite lifecycle hooks allowed to run at the same time when using `test.concurrent` and `describe.concurrent`.
+The maximum number of tests and hooks that can run at the same time.
 
-Entries above this limit are queued until a slot becomes available.
+Anything above this limit is queued until a slot becomes available.
 
-Within each running test or suite, hooks at the same level can still run fully in parallel when [`sequence.hooks`](/config/sequence#sequence-hooks) is set to `parallel` (for example, `beforeEach` / `afterEach`, and `beforeAll` / `afterAll` registered in the same suite).
+[`sequence.hooks`](/config/sequence#sequence-hooks) controls hook ordering. Even when it is set to `parallel`, hook execution still respects this `maxConcurrency` limit.
diff --git a/docs/config/sequence.md b/docs/config/sequence.md
index f3b05eab398f..50b4e60d0aa6 100644
--- a/docs/config/sequence.md
+++ b/docs/config/sequence.md
@@ -145,7 +145,7 @@ Changes the order in which hooks are executed.
 
 - `stack` will order "after" hooks in reverse order, "before" hooks will run in the order they were defined
 - `list` will order all hooks in the order they are defined
-- `parallel` will run hooks in a single group in parallel (hooks in parent suites will still run before the current suite's hooks)
+- `parallel` runs hooks in a single group in parallel (hooks in parent suites still run before the current suite's hooks). The actual number of simultaneously running hooks still depends on [`maxConcurrency`](/config/maxconcurrency).
 
 ::: tip
 This option doesn't affect [`onTestFinished`](/api/hooks#ontestfinished). It is always called in reverse order.
diff --git a/docs/guide/parallelism.md b/docs/guide/parallelism.md
index d3c9c7cc0e10..4748b52c9625 100644
--- a/docs/guide/parallelism.md
+++ b/docs/guide/parallelism.md
@@ -22,6 +22,8 @@ Unlike _test files_, Vitest runs _tests_ in sequence. This means that tests insi
 
 Vitest supports the [`concurrent`](/api/test#test-concurrent) option to run tests together. If this option is set, Vitest will group concurrent tests in the same _file_ (the number of simultaneously running tests and suite lifecycle hooks depends on the [`maxConcurrency`](/config/maxconcurrency) option) and run them with [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all).
 
+Hook order is controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). Even with `sequence.hooks: 'parallel'`, hook execution still respects [`maxConcurrency`](/config/maxconcurrency).
+
 Vitest doesn't perform any smart analysis and doesn't create additional workers to run these tests. This means that the performance of your tests will improve only if you rely heavily on asynchronous operations. For example, these tests will still run one after another even though the `concurrent` option is specified. This is because they are synchronous:
 
 ```ts

From 87f6d32e6187f36e80907abdb11a41a06002ff3d Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 14:23:46 +0900
Subject: [PATCH 07/33] wip

---
 docs/config/maxconcurrency.md |  4 +---
 docs/config/sequence.md       |  2 +-
 docs/guide/parallelism.md     |  2 +-
 packages/runner/src/run.ts    | 39 ++++++++++++++++++-----------------
 4 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/docs/config/maxconcurrency.md b/docs/config/maxconcurrency.md
index b397044eb7c7..ba68446bbaac 100644
--- a/docs/config/maxconcurrency.md
+++ b/docs/config/maxconcurrency.md
@@ -11,6 +11,4 @@ outline: deep
 
 The maximum number of tests and hooks that can run at the same time.
 
-Anything above this limit is queued until a slot becomes available.
-
-[`sequence.hooks`](/config/sequence#sequence-hooks) controls hook ordering. Even when it is set to `parallel`, hook execution still respects this `maxConcurrency` limit.
+[`sequence.hooks`](/config/sequence#sequence-hooks) controls hook ordering. With `sequence.hooks: 'parallel'`, hook execution is bounded by this `maxConcurrency` limit.
diff --git a/docs/config/sequence.md b/docs/config/sequence.md
index 50b4e60d0aa6..9fc65fb77dbf 100644
--- a/docs/config/sequence.md
+++ b/docs/config/sequence.md
@@ -145,7 +145,7 @@ Changes the order in which hooks are executed.
 
 - `stack` will order "after" hooks in reverse order, "before" hooks will run in the order they were defined
 - `list` will order all hooks in the order they are defined
-- `parallel` runs hooks in a single group in parallel (hooks in parent suites still run before the current suite's hooks). The actual number of simultaneously running hooks still depends on [`maxConcurrency`](/config/maxconcurrency).
+- `parallel` runs hooks in a single group in parallel (hooks in parent suites still run before the current suite's hooks). The actual number of simultaneously running hooks is limited by [`maxConcurrency`](/config/maxconcurrency).
 
 ::: tip
 This option doesn't affect [`onTestFinished`](/api/hooks#ontestfinished). It is always called in reverse order.
diff --git a/docs/guide/parallelism.md b/docs/guide/parallelism.md
index 4748b52c9625..d5e6c01b517b 100644
--- a/docs/guide/parallelism.md
+++ b/docs/guide/parallelism.md
@@ -22,7 +22,7 @@ Unlike _test files_, Vitest runs _tests_ in sequence. This means that tests insi
 
 Vitest supports the [`concurrent`](/api/test#test-concurrent) option to run tests together. If this option is set, Vitest will group concurrent tests in the same _file_ (the number of simultaneously running tests and suite lifecycle hooks depends on the [`maxConcurrency`](/config/maxconcurrency) option) and run them with [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all).
 
-Hook order is controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). Even with `sequence.hooks: 'parallel'`, hook execution still respects [`maxConcurrency`](/config/maxconcurrency).
+Hook order is controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). With `sequence.hooks: 'parallel'`, hook execution is bounded by [`maxConcurrency`](/config/maxconcurrency).
 
 Vitest doesn't perform any smart analysis and doesn't create additional workers to run these tests. This means that the performance of your tests will improve only if you rely heavily on asynchronous operations. For example, these tests will still run one after another even though the `concurrent` option is specified. This is because they are synchronous:
 
diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index 3be0a69b05c5..735537552f73 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -35,6 +35,7 @@ import { hasFailed, hasTests } from './utils/tasks'
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now
 const unixNow = Date.now
 const { clearTimeout, setTimeout } = getSafeTimers()
+let limitMaxConcurrency: ReturnType<typeof limitConcurrency>
 
 /**
  * Normalizes retry configuration to extract individual values.
@@ -141,7 +142,7 @@ async function callTestHooks(
 
   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)
@@ -150,7 +151,7 @@ async function callTestHooks(
   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)
@@ -188,11 +189,13 @@ export async function callSuiteHook<T extends keyof SuiteHooks>(
   }
 
   async function runHook(hook: Function) {
-    return getBeforeHookCleanupCallback(
-      hook,
-      await hook(...args),
-      name === 'beforeEach' ? args[0] as TestContext : undefined,
-    )
+    return limitMaxConcurrency(async () => {
+      return getBeforeHookCleanupCallback(
+        hook,
+        await hook(...args),
+        name === 'beforeEach' ? args[0] as TestContext : undefined,
+      )
+    })
   }
 
   if (sequence === 'parallel') {
@@ -508,7 +511,7 @@ async function callCleanupHooks(runner: VitestRunner, cleanups: unknown[]) {
         if (typeof fn !== 'function') {
           return
         }
-        await fn()
+        await limitMaxConcurrency(() => fn())
       }),
     )
   }
@@ -517,7 +520,7 @@ async function callCleanupHooks(runner: VitestRunner, cleanups: unknown[]) {
       if (typeof fn !== 'function') {
         continue
       }
-      await fn()
+      await limitMaxConcurrency(() => fn())
     }
   }
 }
@@ -607,7 +610,7 @@ export async function runTest(test: Test, runner: VitestRunner): Promise<void> {
           ))
 
           if (runner.runTask) {
-            await $('test.callback', () => runner.runTask!(test))
+            await $('test.callback', () => limitMaxConcurrency(() => runner.runTask!(test)))
           }
           else {
             const fn = getFn(test)
@@ -616,7 +619,7 @@ export async function runTest(test: Test, runner: VitestRunner): Promise<void> {
                 'Test function is not found. Did you add it using `setFn`?',
               )
             }
-            await $('test.callback', () => fn())
+            await $('test.callback', () => limitMaxConcurrency(() => fn()))
           }
 
           await runner.onAfterTryTask?.(test, {
@@ -786,8 +789,6 @@ function markTasksAsSkipped(suite: Suite, runner: VitestRunner) {
   })
 }
 
-let limitMaxConcurrency: ReturnType<typeof limitConcurrency>
-
 export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void> {
   await runner.onBeforeRunSuite?.(suite)
 
@@ -831,13 +832,13 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
         try {
           // beforeAll
           try {
-            beforeAllCleanups = await $('suite.beforeAll', () => limitMaxConcurrency(() => callSuiteHook(
+            beforeAllCleanups = await $('suite.beforeAll', () => callSuiteHook(
               suite,
               suite,
               'beforeAll',
               runner,
               [suite],
-            )))
+            ))
           }
           catch (e) {
             failTask(suite.result!, e, runner.config.diffOptions)
@@ -877,9 +878,9 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
         finally {
           // afterAll runs even if beforeAll or suite children fail
           try {
-            await $('suite.afterAll', () => limitMaxConcurrency(() => callSuiteHook(suite, suite, 'afterAll', runner, [suite])))
+            await $('suite.afterAll', () => callSuiteHook(suite, suite, 'afterAll', runner, [suite]))
             if (beforeAllCleanups.length) {
-              await $('suite.cleanup', () => limitMaxConcurrency(() => callCleanupHooks(runner, beforeAllCleanups)))
+              await $('suite.cleanup', () => callCleanupHooks(runner, beforeAllCleanups))
             }
             if (suite.file === suite) {
               const contexts = TestFixtures.getFileContexts(suite.file)
@@ -929,7 +930,7 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
 async function runSuiteChild(c: Task, runner: VitestRunner) {
   const $ = runner.trace!
   if (c.type === 'test') {
-    return limitMaxConcurrency(() => $(
+    return $(
       'run.test',
       {
         'vitest.test.id': c.id,
@@ -941,7 +942,7 @@ async function runSuiteChild(c: Task, runner: VitestRunner) {
         'code.column.number': c.location?.column,
       },
       () => runTest(c, runner),
-    ))
+    )
   }
   else if (c.type === 'suite') {
     return $(

From 5c329226b1f34fb64368af115577bcbb547b212c Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 14:37:37 +0900
Subject: [PATCH 08/33] docs: tweak

---
 docs/config/maxconcurrency.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/config/maxconcurrency.md b/docs/config/maxconcurrency.md
index ba68446bbaac..78b533f0d1ec 100644
--- a/docs/config/maxconcurrency.md
+++ b/docs/config/maxconcurrency.md
@@ -9,6 +9,6 @@ outline: deep
 - **Default**: `5`
 - **CLI**: `--max-concurrency=10`, `--maxConcurrency=10`
 
-The maximum number of tests and hooks that can run at the same time.
+The maximum number of tests and hooks that can run at the same time when using `test.concurrent` or `describe.concurrent`.
 
-[`sequence.hooks`](/config/sequence#sequence-hooks) controls hook ordering. With `sequence.hooks: 'parallel'`, hook execution is bounded by this `maxConcurrency` limit.
+The execution order of hooks within a single group is controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). With `sequence.hooks: 'parallel'`, the parallelism is limited by `maxConcurrency`.

From e5d6cdf17eedec03a83f2b5be6753b8b93b056c5 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 14:42:37 +0900
Subject: [PATCH 09/33] docs: tweak

---
 docs/config/maxconcurrency.md              | 2 +-
 docs/guide/cli-generated.md                | 2 +-
 docs/guide/parallelism.md                  | 4 ++--
 packages/vitest/src/node/cli/cli-config.ts | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/config/maxconcurrency.md b/docs/config/maxconcurrency.md
index 78b533f0d1ec..deb88476b2a0 100644
--- a/docs/config/maxconcurrency.md
+++ b/docs/config/maxconcurrency.md
@@ -11,4 +11,4 @@ outline: deep
 
 The maximum number of tests and hooks that can run at the same time when using `test.concurrent` or `describe.concurrent`.
 
-The execution order of hooks within a single group is controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). With `sequence.hooks: 'parallel'`, the parallelism is limited by `maxConcurrency`.
+The hook execution order within a single group is also controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). With `sequence.hooks: 'parallel'`, the execution is bounded by the same limit of [`maxConcurrency`](/config/maxconcurrency).
diff --git a/docs/guide/cli-generated.md b/docs/guide/cli-generated.md
index 055d28b506ef..cedaf6a0eb84 100644
--- a/docs/guide/cli-generated.md
+++ b/docs/guide/cli-generated.md
@@ -767,7 +767,7 @@ Default timeout of a teardown function in milliseconds (default: `10000`)
 - **CLI:** `--maxConcurrency <number>`
 - **Config:** [maxConcurrency](/config/maxconcurrency)
 
-Maximum number of concurrent tests and suite lifecycle hooks in a file (default: `5`)
+Maximum number of concurrent tests and suites during test file execution (default: `5`)
 
 ### expect.requireAssertions
 
diff --git a/docs/guide/parallelism.md b/docs/guide/parallelism.md
index d5e6c01b517b..c2033531e1ff 100644
--- a/docs/guide/parallelism.md
+++ b/docs/guide/parallelism.md
@@ -20,9 +20,9 @@ If you have a lot of tests, it is usually faster to run them in parallel, but it
 
 Unlike _test files_, Vitest runs _tests_ in sequence. This means that tests inside a single test file will run in the order they are defined.
 
-Vitest supports the [`concurrent`](/api/test#test-concurrent) option to run tests together. If this option is set, Vitest will group concurrent tests in the same _file_ (the number of simultaneously running tests and suite lifecycle hooks depends on the [`maxConcurrency`](/config/maxconcurrency) option) and run them with [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all).
+Vitest supports the [`concurrent`](/api/test#test-concurrent) option to run tests together. If this option is set, Vitest will group concurrent tests in the same _file_ (the number of simultaneously running tests depends on the [`maxConcurrency`](/config/maxconcurrency) option) and run them with [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all).
 
-Hook order is controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). With `sequence.hooks: 'parallel'`, hook execution is bounded by [`maxConcurrency`](/config/maxconcurrency).
+The hook execution order within a single group is also controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). With `sequence.hooks: 'parallel'`, the execution is bounded by the same limit of [`maxConcurrency`](/config/maxconcurrency).
 
 Vitest doesn't perform any smart analysis and doesn't create additional workers to run these tests. This means that the performance of your tests will improve only if you rely heavily on asynchronous operations. For example, these tests will still run one after another even though the `concurrent` option is specified. This is because they are synchronous:
 
diff --git a/packages/vitest/src/node/cli/cli-config.ts b/packages/vitest/src/node/cli/cli-config.ts
index 081dd4a5bb68..389fc5b6933b 100644
--- a/packages/vitest/src/node/cli/cli-config.ts
+++ b/packages/vitest/src/node/cli/cli-config.ts
@@ -716,7 +716,7 @@ export const cliOptionsConfig: VitestCLIOptions = {
     },
   },
   maxConcurrency: {
-    description: 'Maximum number of concurrent tests and suite lifecycle hooks in a file (default: `5`)',
+    description: 'Maximum number of concurrent tests and suites during test file execution (default: `5`)',
     argument: '<number>',
   },
   expect: {

From 5b314fdfaae478031ab6056108fc49ad85cf02d6 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 15:04:54 +0900
Subject: [PATCH 10/33] test: fix concurrent

---
 test/cli/test/expect-task.test.ts | 10 ++++++++--
 test/test-utils/index.ts          |  9 +++++----
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/test/cli/test/expect-task.test.ts b/test/cli/test/expect-task.test.ts
index d1dae4edb203..5fcb4851ab11 100644
--- a/test/cli/test/expect-task.test.ts
+++ b/test/cli/test/expect-task.test.ts
@@ -172,15 +172,18 @@ describe('serial', { concurrent: true }, () => {
       name: 'test-bound extend & local extend',
       test: testBoundLocalExtend,
     },
-  ] as const)('works with $name', async ({ options, test }, { expect }) => {
+  ] as const)('works with $name', async ({ options, test }, context) => {
     const { stdout, stderr } = await runInlineTests(
       {
         'basic.test.ts': test,
         'to-match-test.ts': toMatchTest,
       },
       { reporters: ['tap'], ...options },
+      undefined,
+      context,
     )
 
+    const { expect } = context
     expect(stderr).toBe('')
     expect(stdout.replace(/[\d.]+ms/g, '<time>')).toMatchInlineSnapshot(`
       "TAP version 13
@@ -210,15 +213,18 @@ describe('concurrent', { concurrent: true }, () => {
       name: 'global import',
       test: withConcurrency(globalImport),
     },
-  ] as const)('fails with $name', async ({ options, test }, { expect }) => {
+  ] as const)('fails with $name', async ({ options, test }, context) => {
     const { stdout, ctx } = await runInlineTests(
       {
         'basic.test.ts': test,
         'to-match-test.ts': toMatchTest,
       },
       { reporters: ['tap'], ...options },
+      undefined,
+      context,
     )
 
+    const { expect } = context
     expect(
       stdout
         .replace(/[\d.]+m?s/g, '<time>')
diff --git a/test/test-utils/index.ts b/test/test-utils/index.ts
index 9694a00df1b5..ea31a5ef5a05 100644
--- a/test/test-utils/index.ts
+++ b/test/test-utils/index.ts
@@ -1,6 +1,6 @@
 import type { Options } from 'tinyexec'
 import type { UserConfig as ViteUserConfig } from 'vite'
-import type { SerializedConfig, WorkerGlobalState } from 'vitest'
+import type { SerializedConfig, TestContext, WorkerGlobalState } from 'vitest'
 import type { TestProjectConfiguration } from 'vitest/config'
 import type {
   TestCase,
@@ -423,7 +423,7 @@ export default config
   return `export default ${JSON.stringify(content)}`
 }
 
-export function useFS<T extends TestFsStructure>(root: string, structure: T, ensureConfig = true) {
+export function useFS<T extends TestFsStructure>(root: string, structure: T, ensureConfig = true, context?: TestContext) {
   const files = new Set<string>()
   const hasConfig = Object.keys(structure).some(file => file.includes('.config.'))
   if (ensureConfig && !hasConfig) {
@@ -436,7 +436,7 @@ export function useFS<T extends TestFsStructure>(root: string, structure: T, ens
     fs.mkdirSync(dirname(filepath), { recursive: true })
     fs.writeFileSync(filepath, String(content), 'utf-8')
   }
-  onTestFinished(() => {
+  (context?.onTestFinished ?? onTestFinished)(() => {
     if (process.env.VITEST_FS_CLEANUP !== 'false') {
       fs.rmSync(root, { recursive: true, force: true })
     }
@@ -493,9 +493,10 @@ export async function runInlineTests(
   structure: TestFsStructure,
   config?: RunVitestConfig,
   options?: VitestRunnerCLIOptions,
+  context?: TestContext,
 ) {
   const root = resolve(process.cwd(), `vitest-test-${crypto.randomUUID()}`)
-  const fs = useFS(root, structure)
+  const fs = useFS(root, structure, undefined, context)
   const vitest = await runVitest({
     root,
     ...config,

From 1e24af1effd87938605e8d640a7d06487c2592de Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 15:39:31 +0900
Subject: [PATCH 11/33] test: one

---
 test/core/test/concurrent-suite.test.ts | 45 ++++++++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

diff --git a/test/core/test/concurrent-suite.test.ts b/test/core/test/concurrent-suite.test.ts
index e1884689cd06..45200d8c3726 100644
--- a/test/core/test/concurrent-suite.test.ts
+++ b/test/core/test/concurrent-suite.test.ts
@@ -1,5 +1,5 @@
 import { createDefer } from '@vitest/utils/helpers'
-import { afterAll, describe, expect, test } from 'vitest'
+import { afterAll, beforeAll, describe, expect, test } from 'vitest'
 
 describe('basic', () => {
   const defers = [
@@ -181,3 +181,46 @@ function checkParallelSuites() {
     })
   })
 }
+
+describe('suite hook concurrency', () => {
+  const logs: string[] = []
+
+  afterAll(() => {
+    expect(logs).toEqual(['s2-before', 's2-after', 's1-before', 's1-before-2', 's1-after-2', 's1-after'])
+  })
+
+  describe.concurrent('s1', () => {
+    // before/afterAll inside same suite runs sequentially in stack order
+    beforeAll(async () => {
+      await sleep(200)
+      logs.push('s1-before')
+    })
+
+    beforeAll(async () => {
+      logs.push('s1-before-2')
+    })
+
+    afterAll(async () => {
+      logs.push('s1-after')
+    })
+
+    afterAll(async () => {
+      logs.push('s1-after-2')
+    })
+
+    test('s1-t', () => {})
+  })
+
+  describe.concurrent('s2', () => {
+    // before/afterAll in neighboring concurrent suite runs in parallel
+    beforeAll(async () => {
+      logs.push('s2-before')
+    })
+
+    afterAll(async () => {
+      logs.push('s2-after')
+    })
+
+    test('s2-t', () => {})
+  })
+})

From e091de9d968266c860bdc8d5cfebdaebe5f6921c Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 16:16:02 +0900
Subject: [PATCH 12/33] test: integration

---
 test/cli/test/concurrent.test.ts | 186 +++++++++++++++++++++++++++++++
 1 file changed, 186 insertions(+)
 create mode 100644 test/cli/test/concurrent.test.ts

diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
new file mode 100644
index 000000000000..97056408f044
--- /dev/null
+++ b/test/cli/test/concurrent.test.ts
@@ -0,0 +1,186 @@
+import { expect, test } from 'vitest'
+import { runInlineTests } from '../../test-utils'
+
+// 3 tests depend on each other,
+// so they will deadlock when maxConcurrency < 3
+//
+//  [a]  [b]  [c]
+//   * ->
+//        * ->
+//          <- *
+//     <------
+
+const deadlockSource = `
+import { describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+describe.concurrent('wrapper', () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  test('a', async () => {
+    expect(1).toBe(1)
+    defers[0].resolve()
+    await defers[2]
+  })
+
+  test('b', async () => {
+    expect(1).toBe(1)
+    await defers[0]
+    defers[1].resolve()
+    await defers[2]
+  })
+
+  test('c', async () => {
+    expect(1).toBe(1)
+    await defers[1]
+    defers[2].resolve()
+  })
+})
+`
+
+const suiteDeadlockSource = `
+import { describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+describe.concurrent('wrapper', () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  describe('1st suite', () => {
+    test('a', async () => {
+      expect(1).toBe(1)
+      defers[0].resolve()
+      await defers[2]
+    })
+
+    test('b', async () => {
+      expect(1).toBe(1)
+      await defers[0]
+      defers[1].resolve()
+      await defers[2]
+    })
+  })
+
+  describe('2nd suite', () => {
+    test('c', async () => {
+      expect(1).toBe(1)
+      await defers[1]
+      defers[2].resolve()
+    })
+  })
+})
+`
+
+test('deadlocks with insufficient maxConcurrency', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': deadlockSource,
+  }, {
+    maxConcurrency: 2,
+    testTimeout: 1000,
+  })
+
+  // "a" and "b" fill both concurrency slots and wait for `defers[2]`.
+  // "c" is queued until one slot is released by timeout, then it starts,
+  // observes `defers[1]` already resolved by "b", resolves `defers[2]`, and passes.
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "a": [
+            "Test timed out in 1000ms.
+    If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".",
+          ],
+          "b": [
+            "Test timed out in 1000ms.
+    If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".",
+          ],
+          "c": "passed",
+        },
+      },
+    }
+  `)
+})
+
+test('passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': deadlockSource,
+  }, {
+    maxConcurrency: 3,
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "a": "passed",
+          "b": "passed",
+          "c": "passed",
+        },
+      },
+    }
+  `)
+})
+
+test('suite deadlocks with insufficient maxConcurrency', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': suiteDeadlockSource,
+  }, {
+    maxConcurrency: 2,
+    testTimeout: 1000,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "1st suite": {
+            "a": [
+              "Test timed out in 1000ms.
+    If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".",
+            ],
+            "b": [
+              "Test timed out in 1000ms.
+    If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".",
+            ],
+          },
+          "2nd suite": {
+            "c": "passed",
+          },
+        },
+      },
+    }
+  `)
+})
+
+test('suite passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': suiteDeadlockSource,
+  }, {
+    maxConcurrency: 3,
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "1st suite": {
+            "a": "passed",
+            "b": "passed",
+          },
+          "2nd suite": {
+            "c": "passed",
+          },
+        },
+      },
+    }
+  `)
+})

From baa340e726a37f4de2c04d5ecb707c0f5c80a63e Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 16:19:41 +0900
Subject: [PATCH 13/33] test: remove old

---
 .../fails/concurrent-suite-deadlock.test.ts   | 44 -------------------
 .../fails/concurrent-test-deadlock.test.ts    | 40 -----------------
 .../cli/test/__snapshots__/fails.test.ts.snap | 10 -----
 3 files changed, 94 deletions(-)
 delete mode 100644 test/cli/fixtures/fails/concurrent-suite-deadlock.test.ts
 delete mode 100644 test/cli/fixtures/fails/concurrent-test-deadlock.test.ts

diff --git a/test/cli/fixtures/fails/concurrent-suite-deadlock.test.ts b/test/cli/fixtures/fails/concurrent-suite-deadlock.test.ts
deleted file mode 100644
index 7e49e748538b..000000000000
--- a/test/cli/fixtures/fails/concurrent-suite-deadlock.test.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { createDefer } from '@vitest/utils/helpers'
-import { describe, test, vi, expect } from 'vitest'
-
-// 3 tests depend on each other,
-// so they will deadlock when maxConcurrency < 3
-//
-//  [a]  [b]  [c]
-//   * ->
-//        * ->
-//          <- *
-//     <------
-
-vi.setConfig({ maxConcurrency: 2 })
-
-describe('wrapper', { concurrent: true, timeout: 500 }, () => {
-  const defers = [
-    createDefer<void>(),
-    createDefer<void>(),
-    createDefer<void>(),
-  ]
-
-  describe('1st suite', () => {
-    test('a', async () => {
-      expect(1).toBe(1)
-      defers[0].resolve()
-      await defers[2]
-    })
-
-    test('b', async () => {
-      expect(1).toBe(1)
-      await defers[0]
-      defers[1].resolve()
-      await defers[2]
-    })
-  })
-
-  describe('2nd suite', () => {
-    test('c', async () => {
-      expect(1).toBe(1)
-      await defers[1]
-      defers[2].resolve()
-    })
-  })
-})
diff --git a/test/cli/fixtures/fails/concurrent-test-deadlock.test.ts b/test/cli/fixtures/fails/concurrent-test-deadlock.test.ts
deleted file mode 100644
index 851069137ed1..000000000000
--- a/test/cli/fixtures/fails/concurrent-test-deadlock.test.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { describe, expect, test, vi } from 'vitest'
-import { createDefer } from '@vitest/utils/helpers'
-
-// 3 tests depend on each other,
-// so they will deadlock when maxConcurrency < 3
-//
-//  [a]  [b]  [c]
-//   * ->
-//        * ->
-//          <- *
-//     <------
-
-vi.setConfig({ maxConcurrency: 2 })
-
-describe('wrapper', { concurrent: true, timeout: 500 }, () => {
-  const defers = [
-    createDefer<void>(),
-    createDefer<void>(),
-    createDefer<void>(),
-  ]
-
-  test('a', async () => {
-    expect(1).toBe(1)
-    defers[0].resolve()
-    await defers[2]
-  })
-
-  test('b', async () => {
-    expect(1).toBe(1)
-    await defers[0]
-    defers[1].resolve()
-    await defers[2]
-  })
-
-  test('c', async () => {
-    expect(1).toBe(1)
-    await defers[1]
-    defers[2].resolve()
-  })
-})
diff --git a/test/cli/test/__snapshots__/fails.test.ts.snap b/test/cli/test/__snapshots__/fails.test.ts.snap
index 80a8c0ff3a45..f6db738593b8 100644
--- a/test/cli/test/__snapshots__/fails.test.ts.snap
+++ b/test/cli/test/__snapshots__/fails.test.ts.snap
@@ -7,16 +7,6 @@ exports[`should fail async-assertion.test.ts 1`] = `
 AssertionError: expected 'xx' to be 'yy' // Object.is equality"
 `;
 
-exports[`should fail concurrent-suite-deadlock.test.ts 1`] = `
-"Error: Test timed out in 500ms.
-Error: Test timed out in 500ms."
-`;
-
-exports[`should fail concurrent-test-deadlock.test.ts 1`] = `
-"Error: Test timed out in 500ms.
-Error: Test timed out in 500ms."
-`;
-
 exports[`should fail each-timeout.test.ts 1`] = `"Error: Test timed out in 10ms."`;
 
 exports[`should fail empty.test.ts 1`] = `"Error: No test suite found in file <rootDir>/empty.test.ts"`;

From de530f2a414d9806e3ffea3922c3d4839781c322 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 16:31:28 +0900
Subject: [PATCH 14/33] test: add maxConcurrency deadlock coverage for
 concurrent hooks

---
 test/cli/test/concurrent.test.ts | 380 ++++++++++++++++++++++++++++---
 1 file changed, 344 insertions(+), 36 deletions(-)

diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index 97056408f044..1f3d2142ed69 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -42,42 +42,6 @@ describe.concurrent('wrapper', () => {
 })
 `
 
-const suiteDeadlockSource = `
-import { describe, expect, test } from 'vitest'
-import { createDefer } from '@vitest/utils/helpers'
-
-describe.concurrent('wrapper', () => {
-  const defers = [
-    createDefer<void>(),
-    createDefer<void>(),
-    createDefer<void>(),
-  ]
-
-  describe('1st suite', () => {
-    test('a', async () => {
-      expect(1).toBe(1)
-      defers[0].resolve()
-      await defers[2]
-    })
-
-    test('b', async () => {
-      expect(1).toBe(1)
-      await defers[0]
-      defers[1].resolve()
-      await defers[2]
-    })
-  })
-
-  describe('2nd suite', () => {
-    test('c', async () => {
-      expect(1).toBe(1)
-      await defers[1]
-      defers[2].resolve()
-    })
-  })
-})
-`
-
 test('deadlocks with insufficient maxConcurrency', async () => {
   const { errorTree } = await runInlineTests({
     'basic.test.ts': deadlockSource,
@@ -129,6 +93,42 @@ test('passes when maxConcurrency is high enough', async () => {
   `)
 })
 
+const suiteDeadlockSource = `
+import { describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+describe.concurrent('wrapper', () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  describe('1st suite', () => {
+    test('a', async () => {
+      expect(1).toBe(1)
+      defers[0].resolve()
+      await defers[2]
+    })
+
+    test('b', async () => {
+      expect(1).toBe(1)
+      await defers[0]
+      defers[1].resolve()
+      await defers[2]
+    })
+  })
+
+  describe('2nd suite', () => {
+    test('c', async () => {
+      expect(1).toBe(1)
+      await defers[1]
+      defers[2].resolve()
+    })
+  })
+})
+`
+
 test('suite deadlocks with insufficient maxConcurrency', async () => {
   const { errorTree } = await runInlineTests({
     'basic.test.ts': suiteDeadlockSource,
@@ -184,3 +184,311 @@ test('suite passes when maxConcurrency is high enough', async () => {
     }
   `)
 })
+
+const beforeAllNeighboringSuitesSource = `
+import { beforeAll, describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+const defers = [
+  createDefer<void>(),
+  createDefer<void>(),
+]
+
+describe.concurrent('s1', () => {
+  beforeAll(async () => {
+    defers[0].resolve()
+    await defers[1]
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+})
+
+describe.concurrent('s2', () => {
+  beforeAll(async () => {
+    await defers[0]
+    defers[1].resolve()
+  })
+
+  test('b', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('neighboring suite beforeAll deadlocks with insufficient maxConcurrency', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': beforeAllNeighboringSuitesSource,
+  }, {
+    maxConcurrency: 1,
+    hookTimeout: 1000,
+  })
+
+  expect(stderr.match(/Hook timed out in 1000ms\./g)?.length ?? 0).toBeGreaterThan(0)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "s1": {
+          "a": "skipped",
+        },
+        "s2": {
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+test('neighboring suite beforeAll passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': beforeAllNeighboringSuitesSource,
+  }, {
+    maxConcurrency: 2,
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "s1": {
+          "a": "passed",
+        },
+        "s2": {
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+const afterAllNeighboringSuitesSource = `
+import { afterAll, describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+const defers = [
+  createDefer<void>(),
+  createDefer<void>(),
+]
+
+describe.concurrent('s1', () => {
+  afterAll(async () => {
+    defers[0].resolve()
+    await defers[1]
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+})
+
+describe.concurrent('s2', () => {
+  afterAll(async () => {
+    await defers[0]
+    defers[1].resolve()
+  })
+
+  test('b', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('neighboring suite afterAll deadlocks with insufficient maxConcurrency', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': afterAllNeighboringSuitesSource,
+  }, {
+    maxConcurrency: 1,
+    hookTimeout: 1000,
+  })
+
+  expect(stderr.match(/Hook timed out in 1000ms\./g)?.length ?? 0).toBeGreaterThan(0)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "s1": {
+          "a": "passed",
+        },
+        "s2": {
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+test('neighboring suite afterAll passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': afterAllNeighboringSuitesSource,
+  }, {
+    maxConcurrency: 2,
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "s1": {
+          "a": "passed",
+        },
+        "s2": {
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+const beforeEachDeadlockSource = `
+import { beforeEach, describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+describe.concurrent('wrapper', () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  beforeEach(async () => {
+    defers[0].resolve()
+    await defers[2]
+  })
+
+  beforeEach(async () => {
+    await defers[0]
+    defers[1].resolve()
+    await defers[2]
+  })
+
+  beforeEach(async () => {
+    await defers[1]
+    defers[2].resolve()
+  })
+
+  test('t', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('beforeEach deadlocks with insufficient maxConcurrency', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': beforeEachDeadlockSource,
+  }, {
+    maxConcurrency: 2,
+    sequence: { hooks: 'parallel' },
+    hookTimeout: 1000,
+  })
+
+  expect(stderr.match(/Hook timed out in 1000ms\./g)?.length ?? 0).toBeGreaterThan(0)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "t": [
+            "Hook timed out in 1000ms.
+    If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".",
+          ],
+        },
+      },
+    }
+  `)
+})
+
+test('beforeEach passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': beforeEachDeadlockSource,
+  }, {
+    maxConcurrency: 3,
+    sequence: { hooks: 'parallel' },
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "t": "passed",
+        },
+      },
+    }
+  `)
+})
+
+const afterEachDeadlockSource = `
+import { afterEach, describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+describe.concurrent('wrapper', () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  afterEach(async () => {
+    defers[0].resolve()
+    await defers[2]
+  })
+
+  afterEach(async () => {
+    await defers[0]
+    defers[1].resolve()
+    await defers[2]
+  })
+
+  afterEach(async () => {
+    await defers[1]
+    defers[2].resolve()
+  })
+
+  test('t', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('afterEach deadlocks with insufficient maxConcurrency', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': afterEachDeadlockSource,
+  }, {
+    maxConcurrency: 2,
+    sequence: { hooks: 'parallel' },
+    hookTimeout: 1000,
+  })
+
+  expect(stderr.match(/Hook timed out in 1000ms\./g)?.length ?? 0).toBeGreaterThan(0)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "t": [
+            "Hook timed out in 1000ms.
+    If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".",
+          ],
+        },
+      },
+    }
+  `)
+})
+
+test('afterEach passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': afterEachDeadlockSource,
+  }, {
+    maxConcurrency: 3,
+    sequence: { hooks: 'parallel' },
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "t": "passed",
+        },
+      },
+    }
+  `)
+})

From f0d08fd7bc5546ec45ff6ff6b47f76683e7e654d Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 16:44:08 +0900
Subject: [PATCH 15/33] test: add __suite_errors__ to errorTree

---
 test/cli/test/concurrent.test.ts | 20 +++++++++++-------
 test/test-utils/index.ts         | 36 ++++++++++++++++++++++++--------
 2 files changed, 39 insertions(+), 17 deletions(-)

diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index 1f3d2142ed69..b84e92809512 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -218,18 +218,21 @@ describe.concurrent('s2', () => {
 `
 
 test('neighboring suite beforeAll deadlocks with insufficient maxConcurrency', async () => {
-  const { stderr, errorTree } = await runInlineTests({
+  const { errorTree } = await runInlineTests({
     'basic.test.ts': beforeAllNeighboringSuitesSource,
   }, {
     maxConcurrency: 1,
     hookTimeout: 1000,
   })
 
-  expect(stderr.match(/Hook timed out in 1000ms\./g)?.length ?? 0).toBeGreaterThan(0)
   expect(errorTree()).toMatchInlineSnapshot(`
     {
       "basic.test.ts": {
         "s1": {
+          "__suite_errors__": [
+            "Hook timed out in 1000ms.
+    If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".",
+          ],
           "a": "skipped",
         },
         "s2": {
@@ -295,18 +298,21 @@ describe.concurrent('s2', () => {
 `
 
 test('neighboring suite afterAll deadlocks with insufficient maxConcurrency', async () => {
-  const { stderr, errorTree } = await runInlineTests({
+  const { errorTree } = await runInlineTests({
     'basic.test.ts': afterAllNeighboringSuitesSource,
   }, {
     maxConcurrency: 1,
     hookTimeout: 1000,
   })
 
-  expect(stderr.match(/Hook timed out in 1000ms\./g)?.length ?? 0).toBeGreaterThan(0)
   expect(errorTree()).toMatchInlineSnapshot(`
     {
       "basic.test.ts": {
         "s1": {
+          "__suite_errors__": [
+            "Hook timed out in 1000ms.
+    If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".",
+          ],
           "a": "passed",
         },
         "s2": {
@@ -373,7 +379,7 @@ describe.concurrent('wrapper', () => {
 `
 
 test('beforeEach deadlocks with insufficient maxConcurrency', async () => {
-  const { stderr, errorTree } = await runInlineTests({
+  const { errorTree } = await runInlineTests({
     'basic.test.ts': beforeEachDeadlockSource,
   }, {
     maxConcurrency: 2,
@@ -381,7 +387,6 @@ test('beforeEach deadlocks with insufficient maxConcurrency', async () => {
     hookTimeout: 1000,
   })
 
-  expect(stderr.match(/Hook timed out in 1000ms\./g)?.length ?? 0).toBeGreaterThan(0)
   expect(errorTree()).toMatchInlineSnapshot(`
     {
       "basic.test.ts": {
@@ -450,7 +455,7 @@ describe.concurrent('wrapper', () => {
 `
 
 test('afterEach deadlocks with insufficient maxConcurrency', async () => {
-  const { stderr, errorTree } = await runInlineTests({
+  const { errorTree } = await runInlineTests({
     'basic.test.ts': afterEachDeadlockSource,
   }, {
     maxConcurrency: 2,
@@ -458,7 +463,6 @@ test('afterEach deadlocks with insufficient maxConcurrency', async () => {
     hookTimeout: 1000,
   })
 
-  expect(stderr.match(/Hook timed out in 1000ms\./g)?.length ?? 0).toBeGreaterThan(0)
   expect(errorTree()).toMatchInlineSnapshot(`
     {
       "basic.test.ts": {
diff --git a/test/test-utils/index.ts b/test/test-utils/index.ts
index ea31a5ef5a05..167c6dd5ec85 100644
--- a/test/test-utils/index.ts
+++ b/test/test-utils/index.ts
@@ -8,6 +8,7 @@ import type {
   TestCollection,
   TestModule,
   TestSpecification,
+  TestSuite,
   TestUserConfig,
   Vitest,
 } from 'vitest/node'
@@ -555,16 +556,33 @@ export class StableTestFileOrderSorter {
 }
 
 export function buildErrorTree(testModules: TestModule[]) {
-  return buildTestTree(testModules, (testCase) => {
-    const result = testCase.result()
-    if (result.state === 'failed') {
-      return result.errors.map(e => e.message)
-    }
-    return result.state
-  })
+  return buildTestTree(
+    testModules,
+    (testCase) => {
+      const result = testCase.result()
+      if (result.state === 'failed') {
+        return result.errors.map(e => e.message)
+      }
+      return result.state
+    },
+    (testSuite, suiteChildren) => {
+      const errors = testSuite.errors().map(error => error.message)
+      if (errors.length > 0) {
+        return {
+          ...suiteChildren,
+          __suite_errors__: errors,
+        }
+      }
+      return suiteChildren
+    },
+  )
 }
 
-export function buildTestTree(testModules: TestModule[], onTestCase?: (result: TestCase) => unknown) {
+export function buildTestTree(
+  testModules: TestModule[],
+  onTestCase?: (result: TestCase) => unknown,
+  onTestSuite?: (testSuite: TestSuite, suiteChildren: Record<string, any>) => unknown,
+) {
   type TestTree = Record<string, any>
 
   function walkCollection(collection: TestCollection): TestTree {
@@ -574,7 +592,7 @@ export function buildTestTree(testModules: TestModule[], onTestCase?: (result: T
       if (child.type === 'suite') {
         // Recursively walk suite children
         const suiteChildren = walkCollection(child.children)
-        node[child.name] = suiteChildren
+        node[child.name] = onTestSuite ? onTestSuite(child, suiteChildren) : suiteChildren
       }
       else if (child.type === 'test') {
         const result = child.result()

From 0e306b36ff6be791fe6264595e4111216ba9e0a5 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 16:49:59 +0900
Subject: [PATCH 16/33] test: faster timeout

---
 test/cli/test/concurrent.test.ts | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index b84e92809512..28f7944741a4 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -47,7 +47,7 @@ test('deadlocks with insufficient maxConcurrency', async () => {
     'basic.test.ts': deadlockSource,
   }, {
     maxConcurrency: 2,
-    testTimeout: 1000,
+    testTimeout: 500,
   })
 
   // "a" and "b" fill both concurrency slots and wait for `defers[2]`.
@@ -58,11 +58,11 @@ test('deadlocks with insufficient maxConcurrency', async () => {
       "basic.test.ts": {
         "wrapper": {
           "a": [
-            "Test timed out in 1000ms.
+            "Test timed out in 500ms.
     If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".",
           ],
           "b": [
-            "Test timed out in 1000ms.
+            "Test timed out in 500ms.
     If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".",
           ],
           "c": "passed",
@@ -134,7 +134,7 @@ test('suite deadlocks with insufficient maxConcurrency', async () => {
     'basic.test.ts': suiteDeadlockSource,
   }, {
     maxConcurrency: 2,
-    testTimeout: 1000,
+    testTimeout: 500,
   })
 
   expect(errorTree()).toMatchInlineSnapshot(`
@@ -143,11 +143,11 @@ test('suite deadlocks with insufficient maxConcurrency', async () => {
         "wrapper": {
           "1st suite": {
             "a": [
-              "Test timed out in 1000ms.
+              "Test timed out in 500ms.
     If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".",
             ],
             "b": [
-              "Test timed out in 1000ms.
+              "Test timed out in 500ms.
     If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".",
             ],
           },

From 5a30feb59738021ec008cb59e07778800c353052 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 17:05:51 +0900
Subject: [PATCH 17/33] fix(runner): respect maxConcurrency for around hooks

---
 packages/runner/src/run.ts                    | 114 +++---
 .../runner/src/utils/limit-concurrency.ts     |  38 +-
 test/cli/test/concurrent.test.ts              | 328 +++++++++++++++++-
 3 files changed, 422 insertions(+), 58 deletions(-)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index 735537552f73..e67957657999 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -308,7 +308,9 @@ async function callAroundHooks<THook extends Function>(
     const stackTraceError = getAroundHookStackTrace(hook)
 
     let useCalled = false
-    let setupTimeout: { promise: Promise<never>; clear: () => void }
+    let setupPermitHeld = false
+    let teardownPermitHeld = false
+    let setupTimeout: { promise: Promise<never>; clear: () => void } | undefined
     let teardownTimeout: { promise: Promise<never>; clear: () => void } | undefined
 
     // Promise that resolves when use() is called (setup phase complete)
@@ -342,66 +344,98 @@ async function callAroundHooks<THook extends Function>(
       resolveUseCalled()
 
       // Setup phase completed - clear setup timer
-      setupTimeout.clear()
+      setupTimeout?.clear()
+      if (setupPermitHeld) {
+        limitMaxConcurrency.release()
+        setupPermitHeld = false
+      }
 
       // Run inner hooks - don't time this against our teardown timeout
-      await runNextHook(index + 1)
+      let innerError: unknown
+      try {
+        await runNextHook(index + 1)
+      }
+      catch (error) {
+        innerError = error
+      }
+
+      await limitMaxConcurrency.acquire()
+      teardownPermitHeld = true
 
       // Start teardown timer after inner hooks complete - only times this hook's teardown code
       teardownTimeout = createTimeoutPromise(timeout, 'teardown', stackTraceError)
 
       // Signal that use() is returning (teardown phase starting)
       resolveUseReturned()
+
+      if (innerError) {
+        throw innerError
+      }
     }
 
-    // Start setup timeout
-    setupTimeout = createTimeoutPromise(timeout, 'setup', stackTraceError)
+    await limitMaxConcurrency.acquire()
+    setupPermitHeld = true
 
-    // Run the hook in the background
-    ;(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'}.`,
-          )
+    try {
+      // Start setup timeout
+      setupTimeout = createTimeoutPromise(timeout, 'setup', stackTraceError)
+
+      // Run the hook in the background
+      ;(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()
         }
-        resolveHookComplete()
+        catch (error) {
+          rejectHookComplete(error as Error)
+        }
+      })()
+
+      // Wait for either: use() to be called OR hook to complete (error) OR setup timeout
+      try {
+        await Promise.race([
+          useCalledPromise,
+          hookCompletePromise,
+          setupTimeout.promise,
+        ])
       }
-      catch (error) {
-        rejectHookComplete(error as Error)
+      finally {
+        setupTimeout.clear()
       }
-    })()
 
-    // Wait for either: use() to be called OR hook to complete (error) OR setup timeout
-    try {
+      // Wait for use() to return (inner hooks complete) OR hook to complete (error during inner hooks)
       await Promise.race([
-        useCalledPromise,
+        useReturnedPromise,
         hookCompletePromise,
-        setupTimeout.promise,
       ])
-    }
-    finally {
-      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,
-      ])
+      // Now teardownTimeout is guaranteed to be set
+      // Wait for hook to complete (teardown) OR teardown timeout
+      try {
+        await Promise.race([
+          hookCompletePromise,
+          teardownTimeout!.promise,
+        ])
+      }
+      finally {
+        teardownTimeout?.clear()
+      }
     }
     finally {
-      teardownTimeout!.clear()
+      setupTimeout?.clear()
+      teardownTimeout?.clear()
+      if (teardownPermitHeld) {
+        limitMaxConcurrency.release()
+      }
+      else if (setupPermitHeld) {
+        limitMaxConcurrency.release()
+      }
     }
   }
 
diff --git a/packages/runner/src/utils/limit-concurrency.ts b/packages/runner/src/utils/limit-concurrency.ts
index 4f42d5792774..ef2340bea9a5 100644
--- a/packages/runner/src/utils/limit-concurrency.ts
+++ b/packages/runner/src/utils/limit-concurrency.ts
@@ -1,10 +1,16 @@
 // A compact (code-wise, probably not memory-wise) singly linked list node.
 type QueueNode<T> = [value: T, next?: QueueNode<T>]
 
+export interface ConcurrencyLimiter {
+  <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args): Promise<T>
+  acquire: () => Promise<void>
+  release: () => void
+}
+
 /**
  * Return a function for running multiple async operations with limited concurrency.
  */
-export function limitConcurrency(concurrency: number = Infinity): <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T> {
+export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLimiter {
   // The number of currently active + pending tasks.
   let count = 0
 
@@ -14,8 +20,11 @@ export function limitConcurrency(concurrency: number = Infinity): <Args extends
   let head: undefined | QueueNode<() => void>
   let tail: undefined | QueueNode<() => void>
 
-  // A bookkeeping function executed whenever a task has been run to completion.
-  const finish = () => {
+  const release = () => {
+    if (count === 0) {
+      return
+    }
+
     count--
 
     // Check if there are further pending tasks in the queue.
@@ -30,11 +39,7 @@ export function limitConcurrency(concurrency: number = Infinity): <Args extends
     }
   }
 
-  return (func, ...args) => {
-    // Create a promise chain that:
-    //  1. Waits for its turn in the task queue (if necessary).
-    //  2. Runs the task.
-    //  3. Allows the next pending task (if any) to run.
+  const acquire = () => {
     return new Promise<void>((resolve) => {
       if (count++ < concurrency) {
         // No need to queue if fewer than maxConcurrency tasks are running.
@@ -48,10 +53,23 @@ export function limitConcurrency(concurrency: number = Infinity): <Args extends
         // No other pending tasks, initialize the queue with a new tail and head.
         head = tail = [resolve]
       }
-    }).then(() => {
+    })
+  }
+
+  const limit: ConcurrencyLimiter = (func, ...args) => {
+    // Create a promise chain that:
+    //  1. Waits for its turn in the task queue (if necessary).
+    //  2. Runs the task.
+    //  3. Allows the next pending task (if any) to run.
+    return acquire().then(() => {
       // Running func here ensures that even a non-thenable result or an
       // immediately thrown error gets wrapped into a Promise.
       return func(...args)
-    }).finally(finish)
+    }).finally(release)
   }
+
+  limit.acquire = acquire
+  limit.release = release
+
+  return limit
 }
diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index 28f7944741a4..fe5ba69f9c12 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -222,7 +222,7 @@ test('neighboring suite beforeAll deadlocks with insufficient maxConcurrency', a
     'basic.test.ts': beforeAllNeighboringSuitesSource,
   }, {
     maxConcurrency: 1,
-    hookTimeout: 1000,
+    hookTimeout: 500,
   })
 
   expect(errorTree()).toMatchInlineSnapshot(`
@@ -230,7 +230,7 @@ test('neighboring suite beforeAll deadlocks with insufficient maxConcurrency', a
       "basic.test.ts": {
         "s1": {
           "__suite_errors__": [
-            "Hook timed out in 1000ms.
+            "Hook timed out in 500ms.
     If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".",
           ],
           "a": "skipped",
@@ -302,7 +302,7 @@ test('neighboring suite afterAll deadlocks with insufficient maxConcurrency', as
     'basic.test.ts': afterAllNeighboringSuitesSource,
   }, {
     maxConcurrency: 1,
-    hookTimeout: 1000,
+    hookTimeout: 500,
   })
 
   expect(errorTree()).toMatchInlineSnapshot(`
@@ -310,7 +310,7 @@ test('neighboring suite afterAll deadlocks with insufficient maxConcurrency', as
       "basic.test.ts": {
         "s1": {
           "__suite_errors__": [
-            "Hook timed out in 1000ms.
+            "Hook timed out in 500ms.
     If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".",
           ],
           "a": "passed",
@@ -384,7 +384,7 @@ test('beforeEach deadlocks with insufficient maxConcurrency', async () => {
   }, {
     maxConcurrency: 2,
     sequence: { hooks: 'parallel' },
-    hookTimeout: 1000,
+    hookTimeout: 500,
   })
 
   expect(errorTree()).toMatchInlineSnapshot(`
@@ -392,7 +392,7 @@ test('beforeEach deadlocks with insufficient maxConcurrency', async () => {
       "basic.test.ts": {
         "wrapper": {
           "t": [
-            "Hook timed out in 1000ms.
+            "Hook timed out in 500ms.
     If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".",
           ],
         },
@@ -460,7 +460,7 @@ test('afterEach deadlocks with insufficient maxConcurrency', async () => {
   }, {
     maxConcurrency: 2,
     sequence: { hooks: 'parallel' },
-    hookTimeout: 1000,
+    hookTimeout: 500,
   })
 
   expect(errorTree()).toMatchInlineSnapshot(`
@@ -468,7 +468,7 @@ test('afterEach deadlocks with insufficient maxConcurrency', async () => {
       "basic.test.ts": {
         "wrapper": {
           "t": [
-            "Hook timed out in 1000ms.
+            "Hook timed out in 500ms.
     If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".",
           ],
         },
@@ -496,3 +496,315 @@ test('afterEach passes when maxConcurrency is high enough', async () => {
     }
   `)
 })
+
+const aroundAllNeighboringSuitesSource = `
+import { aroundAll, describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+const defers = [
+  createDefer<void>(),
+  createDefer<void>(),
+]
+
+describe.concurrent('s1', () => {
+  aroundAll(async (runSuite) => {
+    defers[0].resolve()
+    await defers[1]
+    await runSuite()
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+})
+
+describe.concurrent('s2', () => {
+  aroundAll(async (runSuite) => {
+    await defers[0]
+    defers[1].resolve()
+    await runSuite()
+  })
+
+  test('b', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('neighboring suite aroundAll deadlocks with insufficient maxConcurrency', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': aroundAllNeighboringSuitesSource,
+  }, {
+    maxConcurrency: 1,
+    hookTimeout: 500,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "s1": {
+          "__suite_errors__": [
+            "The setup phase of \"aroundAll\" hook timed out after 500ms.",
+          ],
+          "a": "passed",
+        },
+        "s2": {
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+test('neighboring suite aroundAll passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': aroundAllNeighboringSuitesSource,
+  }, {
+    maxConcurrency: 2,
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "s1": {
+          "a": "passed",
+        },
+        "s2": {
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+const aroundAllNeighboringSuitesPostSource = `
+import { aroundAll, describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+const defers = [
+  createDefer<void>(),
+  createDefer<void>(),
+]
+
+describe.concurrent('s1', () => {
+  aroundAll(async (runSuite) => {
+    await runSuite()
+    defers[0].resolve()
+    await defers[1]
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+})
+
+describe.concurrent('s2', () => {
+  aroundAll(async (runSuite) => {
+    await runSuite()
+    await defers[0]
+    defers[1].resolve()
+  })
+
+  test('b', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('neighboring suite aroundAll teardown deadlocks with insufficient maxConcurrency', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': aroundAllNeighboringSuitesPostSource,
+  }, {
+    maxConcurrency: 1,
+    hookTimeout: 500,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "s1": {
+          "__suite_errors__": [
+            "The teardown phase of \"aroundAll\" hook timed out after 500ms.",
+          ],
+          "a": "passed",
+        },
+        "s2": {
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+test('neighboring suite aroundAll teardown passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': aroundAllNeighboringSuitesPostSource,
+  }, {
+    maxConcurrency: 2,
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "s1": {
+          "a": "passed",
+        },
+        "s2": {
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+const aroundEachNeighboringTestsSource = `
+import { aroundEach, describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+const defers = [
+  createDefer<void>(),
+  createDefer<void>(),
+]
+
+describe.concurrent('wrapper', () => {
+  aroundEach(async (runTest, context) => {
+    if (context.task.name === 'a') {
+      defers[0].resolve()
+      await defers[1]
+      await runTest()
+      return
+    }
+
+    await defers[0]
+    defers[1].resolve()
+    await runTest()
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+
+  test('b', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('neighboring test aroundEach deadlocks with insufficient maxConcurrency', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': aroundEachNeighboringTestsSource,
+  }, {
+    maxConcurrency: 1,
+    hookTimeout: 500,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "a": [
+            "The setup phase of \"aroundEach\" hook timed out after 500ms.",
+          ],
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+test('neighboring test aroundEach passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': aroundEachNeighboringTestsSource,
+  }, {
+    maxConcurrency: 2,
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "a": "passed",
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+const aroundEachNeighboringTestsPostSource = `
+import { aroundEach, describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+const defers = [
+  createDefer<void>(),
+  createDefer<void>(),
+]
+
+describe.concurrent('wrapper', () => {
+  aroundEach(async (runTest, context) => {
+    await runTest()
+
+    if (context.task.name === 'a') {
+      defers[0].resolve()
+      await defers[1]
+      return
+    }
+
+    await defers[0]
+    defers[1].resolve()
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+
+  test('b', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('neighboring test aroundEach teardown deadlocks with insufficient maxConcurrency', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': aroundEachNeighboringTestsPostSource,
+  }, {
+    maxConcurrency: 1,
+    hookTimeout: 500,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "a": [
+            "The teardown phase of \"aroundEach\" hook timed out after 500ms.",
+          ],
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+test('neighboring test aroundEach teardown passes when maxConcurrency is high enough', async () => {
+  const { stderr, errorTree } = await runInlineTests({
+    'basic.test.ts': aroundEachNeighboringTestsPostSource,
+  }, {
+    maxConcurrency: 2,
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "a": "passed",
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})

From 6abaaa45dea712476d007738f5b5d5ad157f48d2 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 17:10:30 +0900
Subject: [PATCH 18/33] test: update concurrent

---
 test/cli/test/expect-task.test.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/cli/test/expect-task.test.ts b/test/cli/test/expect-task.test.ts
index 5fcb4851ab11..4477d02db044 100644
--- a/test/cli/test/expect-task.test.ts
+++ b/test/cli/test/expect-task.test.ts
@@ -269,15 +269,18 @@ describe('concurrent', { concurrent: true }, () => {
       name: 'test-bound extend & local extend',
       test: withConcurrency(testBoundLocalExtend),
     },
-  ])('works with $name', async ({ test }, { expect }) => {
+  ])('works with $name', async ({ test }, context) => {
     const { stdout } = await runInlineTests(
       {
         'basic.test.ts': test,
         'to-match-test.ts': toMatchTest,
       },
       { reporters: ['tap'] },
+      undefined,
+      context,
     )
 
+    const { expect } = context
     expect(stdout.replace(/[\d.]+m?s/g, '<time>')).toMatchInlineSnapshot(`
       "TAP version 13
       1..1

From fa19b20786ed37610e8227185815529c1499adc6 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 17:43:57 +0900
Subject: [PATCH 19/33] test: more edge cases

---
 test/cli/test/around-each.test.ts |  83 ++++++++++++
 test/cli/test/concurrent.test.ts  | 201 ++++++++++++++++++++++++++++++
 2 files changed, 284 insertions(+)

diff --git a/test/cli/test/around-each.test.ts b/test/cli/test/around-each.test.ts
index 0bfdea07c076..3e916fa8cc3e 100644
--- a/test/cli/test/around-each.test.ts
+++ b/test/cli/test/around-each.test.ts
@@ -1062,6 +1062,47 @@ test('aroundEach hook timeouts are independent of each other', async () => {
   `)
 })
 
+test('aroundEach teardown timeout works when runTest error is caught', async () => {
+  const { errorTree } = await runInlineTests({
+    'caught-inner-error-timeout.test.ts': `
+      import { aroundEach, describe, expect, test } from 'vitest'
+
+      describe('suite', () => {
+        aroundEach(async (runTest) => {
+          try {
+            await runTest()
+          }
+          catch {
+            // swallow inner hook failure, then run teardown work
+          }
+          await new Promise(resolve => setTimeout(resolve, 200))
+        }, 50)
+
+        aroundEach(async (runTest) => {
+          await runTest()
+          throw new Error('inner aroundEach teardown failure')
+        })
+
+        test('test', () => {
+          expect(1).toBe(1)
+        })
+      })
+    `,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "caught-inner-error-timeout.test.ts": {
+        "suite": {
+          "test": [
+            "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
+          ],
+        },
+      },
+    }
+  `)
+})
+
 test('aroundEach with AsyncLocalStorage', async () => {
   const { stdout, stderr, errorTree } = await runInlineTests({
     'async-local-storage.test.ts': `
@@ -1631,6 +1672,48 @@ test('aroundAll receives suite as third argument', async () => {
   `)
 })
 
+test('aroundAll teardown timeout works when runSuite error is caught', async () => {
+  const { errorTree } = await runInlineTests({
+    'caught-inner-suite-error-timeout.test.ts': `
+      import { aroundAll, describe, expect, test } from 'vitest'
+
+      describe('suite', () => {
+        aroundAll(async (runSuite) => {
+          try {
+            await runSuite()
+          }
+          catch {
+            // swallow inner hook failure, then run teardown work
+          }
+          await new Promise(resolve => setTimeout(resolve, 200))
+        }, 50)
+
+        aroundAll(async (runSuite) => {
+          await runSuite()
+          throw new Error('inner aroundAll teardown failure')
+        })
+
+        test('test', () => {
+          expect(1).toBe(1)
+        })
+      })
+    `,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "caught-inner-suite-error-timeout.test.ts": {
+        "suite": {
+          "__suite_errors__": [
+            "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
+          ],
+          "test": "passed",
+        },
+      },
+    }
+  `)
+})
+
 test('aroundAll with server start/stop pattern', async () => {
   const { stdout, stderr, errorTree } = await runInlineTests({
     'server.test.ts': `
diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index fe5ba69f9c12..218def148ab7 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -808,3 +808,204 @@ test('neighboring test aroundEach teardown passes when maxConcurrency is high en
     }
   `)
 })
+
+const aroundEachOuterCatchesInnerErrorSource = `
+import { aroundEach, describe, expect, test } from 'vitest'
+
+describe.concurrent('wrapper', () => {
+  aroundEach(async (runTest) => {
+    let runTestError: unknown
+    try {
+      await runTest()
+    }
+    catch (error) {
+      runTestError = error
+    }
+
+    await Promise.resolve()
+
+    if (runTestError) {
+      throw runTestError
+    }
+  })
+
+  aroundEach(async (runTest, context) => {
+    await runTest()
+    if (context.task.name === 'a') {
+      throw new Error('inner aroundEach teardown failure')
+    }
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+
+  test('b', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('aroundEach continues protocol when outer hook catches runTest error', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': aroundEachOuterCatchesInnerErrorSource,
+  }, {
+    maxConcurrency: 1,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "a": [
+            "inner aroundEach teardown failure",
+          ],
+          "b": "passed",
+        },
+      },
+    }
+  `)
+})
+
+const aroundAllOuterCatchesInnerErrorSource = `
+import { aroundAll, describe, expect, test } from 'vitest'
+
+describe.concurrent('suite', () => {
+  aroundAll(async (runSuite) => {
+    let runSuiteError: unknown
+    try {
+      await runSuite()
+    }
+    catch (error) {
+      runSuiteError = error
+    }
+
+    await Promise.resolve()
+
+    if (runSuiteError) {
+      throw runSuiteError
+    }
+  })
+
+  aroundAll(async (runSuite) => {
+    await runSuite()
+    throw new Error('inner aroundAll teardown failure')
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('aroundAll continues protocol when outer hook catches runSuite error', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': aroundAllOuterCatchesInnerErrorSource,
+  }, {
+    maxConcurrency: 1,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "suite": {
+          "__suite_errors__": [
+            "inner aroundAll teardown failure",
+          ],
+          "a": "passed",
+        },
+      },
+    }
+  `)
+})
+
+const aroundEachCaughtInnerErrorTeardownTimeoutSource = `
+import { aroundEach, describe, expect, test } from 'vitest'
+
+describe.concurrent('wrapper', () => {
+  aroundEach(async (runTest) => {
+    try {
+      await runTest()
+    }
+    catch {
+      // swallow inner failure, then run long teardown logic
+    }
+    await new Promise(resolve => setTimeout(resolve, 200))
+  }, 50)
+
+  aroundEach(async (runTest) => {
+    await runTest()
+    throw new Error('inner aroundEach teardown failure')
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('aroundEach enforces teardown timeout when inner error is caught', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': aroundEachCaughtInnerErrorTeardownTimeoutSource,
+  }, {
+    maxConcurrency: 1,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "wrapper": {
+          "a": [
+            "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
+          ],
+        },
+      },
+    }
+  `)
+})
+
+const aroundAllCaughtInnerErrorTeardownTimeoutSource = `
+import { aroundAll, describe, expect, test } from 'vitest'
+
+describe.concurrent('suite', () => {
+  aroundAll(async (runSuite) => {
+    try {
+      await runSuite()
+    }
+    catch {
+      // swallow inner failure, then run long teardown logic
+    }
+    await new Promise(resolve => setTimeout(resolve, 200))
+  }, 50)
+
+  aroundAll(async (runSuite) => {
+    await runSuite()
+    throw new Error('inner aroundAll teardown failure')
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('aroundAll enforces teardown timeout when inner error is caught', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': aroundAllCaughtInnerErrorTeardownTimeoutSource,
+  }, {
+    maxConcurrency: 1,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "suite": {
+          "__suite_errors__": [
+            "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
+          ],
+          "a": "passed",
+        },
+      },
+    }
+  `)
+})

From a02e84bceb6a54c62cd4ea68a81dc599a3a21d7a Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Fri, 13 Feb 2026 17:51:49 +0900
Subject: [PATCH 20/33] fix(runner): make around run callbacks non-throwing

---
 docs/api/hooks.md                 |  4 ++
 packages/runner/src/run.ts        | 13 ++--
 test/cli/test/around-each.test.ts | 99 ++++++++++++++++++++++++++++++-
 test/cli/test/concurrent.test.ts  |  2 +
 4 files changed, 112 insertions(+), 6 deletions(-)

diff --git a/docs/api/hooks.md b/docs/api/hooks.md
index bae8eaa28b4f..39ef86f7e1ce 100644
--- a/docs/api/hooks.md
+++ b/docs/api/hooks.md
@@ -158,6 +158,8 @@ Register a callback function that wraps around each test within the current suit
 
 The `runTest()` function runs `beforeEach` hooks, the test itself, fixtures accessed in the test, and `afterEach` hooks. Fixtures that are accessed in the `aroundEach` callback are initialized before `runTest()` is called and are torn down after the aroundEach teardown code completes, allowing you to safely use them in both setup and teardown phases.
 
+`runTest()` does not throw when the wrapped test or inner hooks fail. Failures are still reported through Vitest results.
+
 ::: warning
 You **must** call `runTest()` within your callback. If `runTest()` is not called, the test will fail with an error.
 :::
@@ -268,6 +270,8 @@ Register a callback function that wraps around all tests within the current suit
 
 The `runSuite()` function runs all tests in the suite, including `beforeAll`/`afterAll`/`beforeEach`/`afterEach` hooks, `aroundEach` hooks, and fixtures.
 
+`runSuite()` does not throw when wrapped tests or inner hooks fail. Failures are still reported through Vitest results.
+
 ::: warning
 You **must** call `runSuite()` within your callback. If `runSuite()` is not called, the hook will fail with an error and all tests in the suite will be skipped.
 :::
diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index e67957657999..a6191455b9d1 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -241,6 +241,7 @@ interface AroundHooksOptions<THook extends Function> {
   hookName: 'aroundEach' | 'aroundAll'
   callbackName: 'runTest()' | 'runSuite()'
   onTimeout?: (error: Error) => void
+  onInnerError?: (error: unknown) => void
   invokeHook: (hook: THook, use: () => Promise<void>) => Awaitable<unknown>
 }
 
@@ -263,7 +264,7 @@ async function callAroundHooks<THook extends Function>(
   runInner: () => Promise<void>,
   options: AroundHooksOptions<THook>,
 ): Promise<void> {
-  const { hooks, hookName, callbackName, onTimeout, invokeHook } = options
+  const { hooks, hookName, callbackName, onTimeout, onInnerError, invokeHook } = options
 
   if (!hooks.length) {
     await runInner()
@@ -369,7 +370,7 @@ async function callAroundHooks<THook extends Function>(
       resolveUseReturned()
 
       if (innerError) {
-        throw innerError
+        onInnerError?.(innerError)
       }
     }
 
@@ -444,12 +445,14 @@ async function callAroundHooks<THook extends Function>(
 
 async function callAroundAllHooks(
   suite: Suite,
+  runner: VitestRunner,
   runSuiteInner: () => Promise<void>,
 ): Promise<void> {
   await callAroundHooks(runSuiteInner, {
     hooks: getAroundAllHooks(suite),
     hookName: 'aroundAll',
     callbackName: 'runSuite()',
+    onInnerError: error => failTask(suite.result!, error, runner.config.diffOptions),
     invokeHook: (hook, use) => hook(use, suite),
   })
 }
@@ -457,6 +460,7 @@ async function callAroundAllHooks(
 async function callAroundEachHooks(
   suite: Suite,
   test: Test,
+  runner: VitestRunner,
   runTest: (fixtureCheckpoint: number) => Promise<void>,
 ): Promise<void> {
   await callAroundHooks(
@@ -468,6 +472,7 @@ async function callAroundEachHooks(
       hooks: getAroundEachHooks(suite),
       hookName: 'aroundEach',
       callbackName: 'runTest()',
+      onInnerError: error => failTask(test.result!, error, runner.config.diffOptions),
       onTimeout: error => abortContextSignal(test.context, error),
       invokeHook: (hook, use) => hook(use, test.context, suite),
     },
@@ -626,7 +631,7 @@ export async function runTest(test: Test, runner: VitestRunner): Promise<void> {
       // 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) => {
+      await callAroundEachHooks(suite, test, runner, async (fixtureCheckpoint) => {
         try {
           await runner.onBeforeTryTask?.(test, {
             retry: retryCount,
@@ -861,7 +866,7 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
     let suiteRan = false
 
     try {
-      await callAroundAllHooks(suite, async () => {
+      await callAroundAllHooks(suite, runner, async () => {
         suiteRan = true
         try {
           // beforeAll
diff --git a/test/cli/test/around-each.test.ts b/test/cli/test/around-each.test.ts
index 3e916fa8cc3e..d4becc00af45 100644
--- a/test/cli/test/around-each.test.ts
+++ b/test/cli/test/around-each.test.ts
@@ -920,7 +920,8 @@ test('multiple aroundEach hooks with different timeouts', async () => {
 
   expect(extractLogs(stdout)).toMatchInlineSnapshot(`
     ">> outer setup
-    >> inner setup start"
+    >> inner setup start
+    >> outer teardown"
   `)
   expect(stderr).toMatchInlineSnapshot(`
     "
@@ -982,7 +983,8 @@ test('multiple aroundEach hooks where inner teardown times out', async () => {
     ">> outer setup
     >> inner setup
     >> test
-    >> inner teardown start"
+    >> inner teardown start
+    >> outer teardown"
   `)
   expect(stderr).toMatchInlineSnapshot(`
     "
@@ -1095,6 +1097,7 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
       "caught-inner-error-timeout.test.ts": {
         "suite": {
           "test": [
+            "inner aroundEach teardown failure",
             "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
           ],
         },
@@ -1103,6 +1106,51 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
   `)
 })
 
+test('runTest does not throw when inner aroundEach fails', async () => {
+  const { errorTree } = await runInlineTests({
+    'non-throwing-run-test.test.ts': `
+      import { aroundEach, describe, expect, test } from 'vitest'
+
+      describe('suite', () => {
+        aroundEach(async (runTest) => {
+          let caught = false
+          try {
+            await runTest()
+          }
+          catch {
+            caught = true
+          }
+
+          if (caught) {
+            throw new Error('runTest should not throw')
+          }
+        })
+
+        aroundEach(async (runTest) => {
+          await runTest()
+          throw new Error('inner aroundEach teardown failure')
+        })
+
+        test('test', () => {
+          expect(1).toBe(1)
+        })
+      })
+    `,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "non-throwing-run-test.test.ts": {
+        "suite": {
+          "test": [
+            "inner aroundEach teardown failure",
+          ],
+        },
+      },
+    }
+  `)
+})
+
 test('aroundEach with AsyncLocalStorage', async () => {
   const { stdout, stderr, errorTree } = await runInlineTests({
     'async-local-storage.test.ts': `
@@ -1705,6 +1753,7 @@ test('aroundAll teardown timeout works when runSuite error is caught', async ()
       "caught-inner-suite-error-timeout.test.ts": {
         "suite": {
           "__suite_errors__": [
+            "inner aroundAll teardown failure",
             "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
           ],
           "test": "passed",
@@ -1714,6 +1763,52 @@ test('aroundAll teardown timeout works when runSuite error is caught', async ()
   `)
 })
 
+test('runSuite does not throw when inner aroundAll fails', async () => {
+  const { errorTree } = await runInlineTests({
+    'non-throwing-run-suite.test.ts': `
+      import { aroundAll, describe, expect, test } from 'vitest'
+
+      describe('suite', () => {
+        aroundAll(async (runSuite) => {
+          let caught = false
+          try {
+            await runSuite()
+          }
+          catch {
+            caught = true
+          }
+
+          if (caught) {
+            throw new Error('runSuite should not throw')
+          }
+        })
+
+        aroundAll(async (runSuite) => {
+          await runSuite()
+          throw new Error('inner aroundAll teardown failure')
+        })
+
+        test('test', () => {
+          expect(1).toBe(1)
+        })
+      })
+    `,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "non-throwing-run-suite.test.ts": {
+        "suite": {
+          "__suite_errors__": [
+            "inner aroundAll teardown failure",
+          ],
+          "test": "passed",
+        },
+      },
+    }
+  `)
+})
+
 test('aroundAll with server start/stop pattern', async () => {
   const { stdout, stderr, errorTree } = await runInlineTests({
     'server.test.ts': `
diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index 218def148ab7..9669ef2d3d63 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -956,6 +956,7 @@ test('aroundEach enforces teardown timeout when inner error is caught', async ()
       "basic.test.ts": {
         "wrapper": {
           "a": [
+            "inner aroundEach teardown failure",
             "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
           ],
         },
@@ -1001,6 +1002,7 @@ test('aroundAll enforces teardown timeout when inner error is caught', async ()
       "basic.test.ts": {
         "suite": {
           "__suite_errors__": [
+            "inner aroundAll teardown failure",
             "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
           ],
           "a": "passed",

From a5a0f2d2f787bbf649ec00c38562e10a1781fbd7 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Sat, 14 Feb 2026 11:21:44 +0900
Subject: [PATCH 21/33] Revert "fix(runner): make around run callbacks
 non-throwing"

This reverts commit a02e84bceb6a54c62cd4ea68a81dc599a3a21d7a.
---
 docs/api/hooks.md                 |  4 --
 packages/runner/src/run.ts        | 13 ++--
 test/cli/test/around-each.test.ts | 99 +------------------------------
 test/cli/test/concurrent.test.ts  |  2 -
 4 files changed, 6 insertions(+), 112 deletions(-)

diff --git a/docs/api/hooks.md b/docs/api/hooks.md
index 39ef86f7e1ce..bae8eaa28b4f 100644
--- a/docs/api/hooks.md
+++ b/docs/api/hooks.md
@@ -158,8 +158,6 @@ Register a callback function that wraps around each test within the current suit
 
 The `runTest()` function runs `beforeEach` hooks, the test itself, fixtures accessed in the test, and `afterEach` hooks. Fixtures that are accessed in the `aroundEach` callback are initialized before `runTest()` is called and are torn down after the aroundEach teardown code completes, allowing you to safely use them in both setup and teardown phases.
 
-`runTest()` does not throw when the wrapped test or inner hooks fail. Failures are still reported through Vitest results.
-
 ::: warning
 You **must** call `runTest()` within your callback. If `runTest()` is not called, the test will fail with an error.
 :::
@@ -270,8 +268,6 @@ Register a callback function that wraps around all tests within the current suit
 
 The `runSuite()` function runs all tests in the suite, including `beforeAll`/`afterAll`/`beforeEach`/`afterEach` hooks, `aroundEach` hooks, and fixtures.
 
-`runSuite()` does not throw when wrapped tests or inner hooks fail. Failures are still reported through Vitest results.
-
 ::: warning
 You **must** call `runSuite()` within your callback. If `runSuite()` is not called, the hook will fail with an error and all tests in the suite will be skipped.
 :::
diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index a6191455b9d1..e67957657999 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -241,7 +241,6 @@ interface AroundHooksOptions<THook extends Function> {
   hookName: 'aroundEach' | 'aroundAll'
   callbackName: 'runTest()' | 'runSuite()'
   onTimeout?: (error: Error) => void
-  onInnerError?: (error: unknown) => void
   invokeHook: (hook: THook, use: () => Promise<void>) => Awaitable<unknown>
 }
 
@@ -264,7 +263,7 @@ async function callAroundHooks<THook extends Function>(
   runInner: () => Promise<void>,
   options: AroundHooksOptions<THook>,
 ): Promise<void> {
-  const { hooks, hookName, callbackName, onTimeout, onInnerError, invokeHook } = options
+  const { hooks, hookName, callbackName, onTimeout, invokeHook } = options
 
   if (!hooks.length) {
     await runInner()
@@ -370,7 +369,7 @@ async function callAroundHooks<THook extends Function>(
       resolveUseReturned()
 
       if (innerError) {
-        onInnerError?.(innerError)
+        throw innerError
       }
     }
 
@@ -445,14 +444,12 @@ async function callAroundHooks<THook extends Function>(
 
 async function callAroundAllHooks(
   suite: Suite,
-  runner: VitestRunner,
   runSuiteInner: () => Promise<void>,
 ): Promise<void> {
   await callAroundHooks(runSuiteInner, {
     hooks: getAroundAllHooks(suite),
     hookName: 'aroundAll',
     callbackName: 'runSuite()',
-    onInnerError: error => failTask(suite.result!, error, runner.config.diffOptions),
     invokeHook: (hook, use) => hook(use, suite),
   })
 }
@@ -460,7 +457,6 @@ async function callAroundAllHooks(
 async function callAroundEachHooks(
   suite: Suite,
   test: Test,
-  runner: VitestRunner,
   runTest: (fixtureCheckpoint: number) => Promise<void>,
 ): Promise<void> {
   await callAroundHooks(
@@ -472,7 +468,6 @@ async function callAroundEachHooks(
       hooks: getAroundEachHooks(suite),
       hookName: 'aroundEach',
       callbackName: 'runTest()',
-      onInnerError: error => failTask(test.result!, error, runner.config.diffOptions),
       onTimeout: error => abortContextSignal(test.context, error),
       invokeHook: (hook, use) => hook(use, test.context, suite),
     },
@@ -631,7 +626,7 @@ export async function runTest(test: Test, runner: VitestRunner): Promise<void> {
       // 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, runner, async (fixtureCheckpoint) => {
+      await callAroundEachHooks(suite, test, async (fixtureCheckpoint) => {
         try {
           await runner.onBeforeTryTask?.(test, {
             retry: retryCount,
@@ -866,7 +861,7 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
     let suiteRan = false
 
     try {
-      await callAroundAllHooks(suite, runner, async () => {
+      await callAroundAllHooks(suite, async () => {
         suiteRan = true
         try {
           // beforeAll
diff --git a/test/cli/test/around-each.test.ts b/test/cli/test/around-each.test.ts
index d4becc00af45..3e916fa8cc3e 100644
--- a/test/cli/test/around-each.test.ts
+++ b/test/cli/test/around-each.test.ts
@@ -920,8 +920,7 @@ test('multiple aroundEach hooks with different timeouts', async () => {
 
   expect(extractLogs(stdout)).toMatchInlineSnapshot(`
     ">> outer setup
-    >> inner setup start
-    >> outer teardown"
+    >> inner setup start"
   `)
   expect(stderr).toMatchInlineSnapshot(`
     "
@@ -983,8 +982,7 @@ test('multiple aroundEach hooks where inner teardown times out', async () => {
     ">> outer setup
     >> inner setup
     >> test
-    >> inner teardown start
-    >> outer teardown"
+    >> inner teardown start"
   `)
   expect(stderr).toMatchInlineSnapshot(`
     "
@@ -1097,7 +1095,6 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
       "caught-inner-error-timeout.test.ts": {
         "suite": {
           "test": [
-            "inner aroundEach teardown failure",
             "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
           ],
         },
@@ -1106,51 +1103,6 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
   `)
 })
 
-test('runTest does not throw when inner aroundEach fails', async () => {
-  const { errorTree } = await runInlineTests({
-    'non-throwing-run-test.test.ts': `
-      import { aroundEach, describe, expect, test } from 'vitest'
-
-      describe('suite', () => {
-        aroundEach(async (runTest) => {
-          let caught = false
-          try {
-            await runTest()
-          }
-          catch {
-            caught = true
-          }
-
-          if (caught) {
-            throw new Error('runTest should not throw')
-          }
-        })
-
-        aroundEach(async (runTest) => {
-          await runTest()
-          throw new Error('inner aroundEach teardown failure')
-        })
-
-        test('test', () => {
-          expect(1).toBe(1)
-        })
-      })
-    `,
-  })
-
-  expect(errorTree()).toMatchInlineSnapshot(`
-    {
-      "non-throwing-run-test.test.ts": {
-        "suite": {
-          "test": [
-            "inner aroundEach teardown failure",
-          ],
-        },
-      },
-    }
-  `)
-})
-
 test('aroundEach with AsyncLocalStorage', async () => {
   const { stdout, stderr, errorTree } = await runInlineTests({
     'async-local-storage.test.ts': `
@@ -1753,7 +1705,6 @@ test('aroundAll teardown timeout works when runSuite error is caught', async ()
       "caught-inner-suite-error-timeout.test.ts": {
         "suite": {
           "__suite_errors__": [
-            "inner aroundAll teardown failure",
             "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
           ],
           "test": "passed",
@@ -1763,52 +1714,6 @@ test('aroundAll teardown timeout works when runSuite error is caught', async ()
   `)
 })
 
-test('runSuite does not throw when inner aroundAll fails', async () => {
-  const { errorTree } = await runInlineTests({
-    'non-throwing-run-suite.test.ts': `
-      import { aroundAll, describe, expect, test } from 'vitest'
-
-      describe('suite', () => {
-        aroundAll(async (runSuite) => {
-          let caught = false
-          try {
-            await runSuite()
-          }
-          catch {
-            caught = true
-          }
-
-          if (caught) {
-            throw new Error('runSuite should not throw')
-          }
-        })
-
-        aroundAll(async (runSuite) => {
-          await runSuite()
-          throw new Error('inner aroundAll teardown failure')
-        })
-
-        test('test', () => {
-          expect(1).toBe(1)
-        })
-      })
-    `,
-  })
-
-  expect(errorTree()).toMatchInlineSnapshot(`
-    {
-      "non-throwing-run-suite.test.ts": {
-        "suite": {
-          "__suite_errors__": [
-            "inner aroundAll teardown failure",
-          ],
-          "test": "passed",
-        },
-      },
-    }
-  `)
-})
-
 test('aroundAll with server start/stop pattern', async () => {
   const { stdout, stderr, errorTree } = await runInlineTests({
     'server.test.ts': `
diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index 9669ef2d3d63..218def148ab7 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -956,7 +956,6 @@ test('aroundEach enforces teardown timeout when inner error is caught', async ()
       "basic.test.ts": {
         "wrapper": {
           "a": [
-            "inner aroundEach teardown failure",
             "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
           ],
         },
@@ -1002,7 +1001,6 @@ test('aroundAll enforces teardown timeout when inner error is caught', async ()
       "basic.test.ts": {
         "suite": {
           "__suite_errors__": [
-            "inner aroundAll teardown failure",
             "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
           ],
           "a": "passed",

From fbe6b3262f34c46c1deace27d5b4f71e8f15ffd5 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Sat, 14 Feb 2026 12:28:40 +0900
Subject: [PATCH 22/33] refactor: simplify acquire/release

---
 packages/runner/src/run.ts                    | 31 +++++++------------
 .../runner/src/utils/limit-concurrency.ts     | 15 ++++++---
 test/cli/test/concurrent.test.ts              |  4 +--
 3 files changed, 23 insertions(+), 27 deletions(-)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index e67957657999..d6cff6b8d63f 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -308,10 +308,10 @@ async function callAroundHooks<THook extends Function>(
     const stackTraceError = getAroundHookStackTrace(hook)
 
     let useCalled = false
-    let setupPermitHeld = false
-    let teardownPermitHeld = false
     let setupTimeout: { promise: Promise<never>; clear: () => void } | undefined
     let teardownTimeout: { promise: Promise<never>; clear: () => void } | undefined
+    let setupLimitConcurrencyRelease: (() => void) | undefined
+    let teardownLimitConcurrencyRelease: (() => void) | undefined
 
     // Promise that resolves when use() is called (setup phase complete)
     let resolveUseCalled!: () => void
@@ -345,10 +345,7 @@ async function callAroundHooks<THook extends Function>(
 
       // Setup phase completed - clear setup timer
       setupTimeout?.clear()
-      if (setupPermitHeld) {
-        limitMaxConcurrency.release()
-        setupPermitHeld = false
-      }
+      setupLimitConcurrencyRelease?.()
 
       // Run inner hooks - don't time this against our teardown timeout
       let innerError: unknown
@@ -359,8 +356,7 @@ async function callAroundHooks<THook extends Function>(
         innerError = error
       }
 
-      await limitMaxConcurrency.acquire()
-      teardownPermitHeld = true
+      teardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire()
 
       // Start teardown timer after inner hooks complete - only times this hook's teardown code
       teardownTimeout = createTimeoutPromise(timeout, 'teardown', stackTraceError)
@@ -373,8 +369,7 @@ async function callAroundHooks<THook extends Function>(
       }
     }
 
-    await limitMaxConcurrency.acquire()
-    setupPermitHeld = true
+    setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire()
 
     try {
       // Start setup timeout
@@ -395,6 +390,9 @@ async function callAroundHooks<THook extends Function>(
         catch (error) {
           rejectHookComplete(error as Error)
         }
+        finally {
+          teardownLimitConcurrencyRelease?.()
+        }
       })()
 
       // Wait for either: use() to be called OR hook to complete (error) OR setup timeout
@@ -406,6 +404,7 @@ async function callAroundHooks<THook extends Function>(
         ])
       }
       finally {
+        setupLimitConcurrencyRelease?.()
         setupTimeout.clear()
       }
 
@@ -424,19 +423,11 @@ async function callAroundHooks<THook extends Function>(
         ])
       }
       finally {
+        teardownLimitConcurrencyRelease?.()
         teardownTimeout?.clear()
       }
     }
-    finally {
-      setupTimeout?.clear()
-      teardownTimeout?.clear()
-      if (teardownPermitHeld) {
-        limitMaxConcurrency.release()
-      }
-      else if (setupPermitHeld) {
-        limitMaxConcurrency.release()
-      }
-    }
+    finally {}
   }
 
   await runNextHook(0)
diff --git a/packages/runner/src/utils/limit-concurrency.ts b/packages/runner/src/utils/limit-concurrency.ts
index ef2340bea9a5..0ec35480d4f7 100644
--- a/packages/runner/src/utils/limit-concurrency.ts
+++ b/packages/runner/src/utils/limit-concurrency.ts
@@ -3,8 +3,7 @@ type QueueNode<T> = [value: T, next?: QueueNode<T>]
 
 export interface ConcurrencyLimiter {
   <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args): Promise<T>
-  acquire: () => Promise<void>
-  release: () => void
+  acquire: () => Promise<() => void>
 }
 
 /**
@@ -39,8 +38,8 @@ export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLim
     }
   }
 
-  const acquire = () => {
-    return new Promise<void>((resolve) => {
+  const acquire = async () => {
+    await new Promise<void>((resolve) => {
       if (count++ < concurrency) {
         // No need to queue if fewer than maxConcurrency tasks are running.
         resolve()
@@ -54,6 +53,13 @@ export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLim
         head = tail = [resolve]
       }
     })
+    let released = false
+    return () => {
+      if (!released) {
+        released = true
+        release()
+      }
+    }
   }
 
   const limit: ConcurrencyLimiter = (func, ...args) => {
@@ -69,7 +75,6 @@ export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLim
   }
 
   limit.acquire = acquire
-  limit.release = release
 
   return limit
 }
diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index 218def148ab7..5e6923ed3da0 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -544,9 +544,9 @@ test('neighboring suite aroundAll deadlocks with insufficient maxConcurrency', a
       "basic.test.ts": {
         "s1": {
           "__suite_errors__": [
-            "The setup phase of \"aroundAll\" hook timed out after 500ms.",
+            "The setup phase of "aroundAll" hook timed out after 500ms.",
           ],
-          "a": "passed",
+          "a": "skipped",
         },
         "s2": {
           "b": "passed",

From 34bf2df7b0a5289650f4c3c9e77126e833b79e15 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Sat, 14 Feb 2026 12:30:02 +0900
Subject: [PATCH 23/33] chore: lint

---
 packages/runner/src/run.ts | 89 ++++++++++++++++++--------------------
 1 file changed, 43 insertions(+), 46 deletions(-)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index d6cff6b8d63f..40a509dab093 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -371,63 +371,60 @@ async function callAroundHooks<THook extends Function>(
 
     setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire()
 
-    try {
-      // Start setup timeout
-      setupTimeout = createTimeoutPromise(timeout, 'setup', stackTraceError)
-
-      // Run the hook in the background
-      ;(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 as Error)
-        }
-        finally {
-          teardownLimitConcurrencyRelease?.()
-        }
-      })()
+    // Start setup timeout
+    setupTimeout = createTimeoutPromise(timeout, 'setup', stackTraceError)
 
-      // Wait for either: use() to be called OR hook to complete (error) OR setup timeout
+    // Run the hook in the background
+    ;(async () => {
       try {
-        await Promise.race([
-          useCalledPromise,
-          hookCompletePromise,
-          setupTimeout.promise,
-        ])
+        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 as Error)
       }
       finally {
-        setupLimitConcurrencyRelease?.()
-        setupTimeout.clear()
+        teardownLimitConcurrencyRelease?.()
       }
+    })()
 
-      // Wait for use() to return (inner hooks complete) OR hook to complete (error during inner hooks)
+    // Wait for either: use() to be called OR hook to complete (error) OR setup timeout
+    try {
       await Promise.race([
-        useReturnedPromise,
+        useCalledPromise,
         hookCompletePromise,
+        setupTimeout.promise,
       ])
+    }
+    finally {
+      setupLimitConcurrencyRelease?.()
+      setupTimeout.clear()
+    }
 
-      // 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()
-      }
+    // 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()
     }
-    finally {}
   }
 
   await runNextHook(0)

From a9717bc006dc56c6909de63248c4f67c1ce9b168 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Sat, 14 Feb 2026 12:31:32 +0900
Subject: [PATCH 24/33] fix: release more

---
 packages/runner/src/run.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index 40a509dab093..66cdc4835a0e 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -390,6 +390,7 @@ async function callAroundHooks<THook extends Function>(
         rejectHookComplete(error as Error)
       }
       finally {
+        setupLimitConcurrencyRelease?.()
         teardownLimitConcurrencyRelease?.()
       }
     })()

From c12ffc0335f871a0720723654febd219350a80e8 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Sat, 14 Feb 2026 12:46:33 +0900
Subject: [PATCH 25/33] test: more

---
 test/cli/test/concurrent.test.ts | 63 ++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index 5e6923ed3da0..5dd2f0833cd5 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -659,6 +659,69 @@ test('neighboring suite aroundAll teardown passes when maxConcurrency is high en
   `)
 })
 
+const aroundAllSetupTimeoutLateTeardownAcquireSource = `
+import { aroundAll, describe, expect, test } from 'vitest'
+import { createDefer } from '@vitest/utils/helpers'
+
+const unblockS1Setup = createDefer<void>()
+const allowS2TestFinish = createDefer<void>()
+const blockForever = createDefer<void>()
+
+describe.concurrent('s1', () => {
+  aroundAll(async (runSuite) => {
+    await unblockS1Setup
+    await runSuite()
+    allowS2TestFinish.resolve()
+    await blockForever
+  })
+
+  test('a', () => {
+    expect(1).toBe(1)
+  })
+})
+
+describe.concurrent('s2', () => {
+  aroundAll(async (runSuite) => {
+    unblockS1Setup.resolve()
+    await runSuite()
+  })
+
+  test('b', async () => {
+    await allowS2TestFinish
+    expect(1).toBe(1)
+  })
+})
+`
+
+test('neighboring suite aroundAll does not hang when setup times out before late teardown acquire', async () => {
+  const { errorTree } = await runInlineTests({
+    'basic.test.ts': aroundAllSetupTimeoutLateTeardownAcquireSource,
+  }, {
+    maxConcurrency: 1,
+    hookTimeout: 500,
+    testTimeout: 500,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "basic.test.ts": {
+        "s1": {
+          "__suite_errors__": [
+            "The setup phase of "aroundAll" hook timed out after 500ms.",
+          ],
+          "a": "passed",
+        },
+        "s2": {
+          "b": [
+            "Test timed out in 500ms.
+    If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".",
+          ],
+        },
+      },
+    }
+  `)
+})
+
 const aroundEachNeighboringTestsSource = `
 import { aroundEach, describe, expect, test } from 'vitest'
 import { createDefer } from '@vitest/utils/helpers'

From d0a1adf958573abc10f431ef25c262de509aec07 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Mon, 16 Feb 2026 14:27:11 +0900
Subject: [PATCH 26/33] fix: preserve nested around hook failures and add
 regressions

---
 packages/runner/src/run.ts        |  36 ++-
 test/cli/test/around-each.test.ts | 481 +++++++++++++++++++++++++++++-
 2 files changed, 497 insertions(+), 20 deletions(-)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index 5f0cd7c7bb2e..43f98d0cb88c 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -267,6 +267,11 @@ async function callAroundHooks<THook extends Function>(
     return
   }
 
+  const deferredErrors: unknown[] = []
+  const captureDeferredError = (error: unknown) => {
+    deferredErrors.push(error)
+  }
+
   const createTimeoutPromise = (
     timeout: number,
     phase: 'setup' | 'teardown',
@@ -352,23 +357,13 @@ async function callAroundHooks<THook extends Function>(
       setupTimeout.clear()
 
       // Run inner hooks - don't time this against our teardown timeout
-      let nextError: { value: unknown } | undefined
-      try {
-        await runNextHook(index + 1)
-      }
-      catch (value) {
-        nextError = { value }
-      }
+      await runNextHook(index + 1).catch(captureDeferredError)
 
       // Start teardown timer after inner hooks complete - only times this hook's teardown code
       teardownTimeout = createTimeoutPromise(timeout, 'teardown', stackTraceError)
 
       // Signal that use() is returning (teardown phase starting)
       resolveUseReturned()
-
-      if (nextError) {
-        throw nextError.value
-      }
     }
 
     // Start setup timeout
@@ -422,7 +417,24 @@ async function callAroundHooks<THook extends Function>(
     }
   }
 
-  await runNextHook(0)
+  let topLevelError: unknown
+  try {
+    await runNextHook(0)
+  }
+  catch (error) {
+    topLevelError = error
+  }
+
+  if (topLevelError !== undefined) {
+    deferredErrors.unshift(topLevelError)
+  }
+
+  if (deferredErrors.length === 1) {
+    throw deferredErrors[0]
+  }
+  if (deferredErrors.length > 1) {
+    throw new AggregateError(deferredErrors, `Multiple errors occurred in nested ${hookName} hooks`)
+  }
 }
 
 async function callAroundAllHooks(
diff --git a/test/cli/test/around-each.test.ts b/test/cli/test/around-each.test.ts
index 0c52e77e4902..e577a2fe7065 100644
--- a/test/cli/test/around-each.test.ts
+++ b/test/cli/test/around-each.test.ts
@@ -920,7 +920,8 @@ test('multiple aroundEach hooks with different timeouts', async () => {
 
   expect(extractLogs(stdout)).toMatchInlineSnapshot(`
     ">> outer setup
-    >> inner setup start"
+    >> inner setup start
+    >> outer teardown"
   `)
   expect(stderr).toMatchInlineSnapshot(`
     "
@@ -982,7 +983,8 @@ test('multiple aroundEach hooks where inner teardown times out', async () => {
     ">> outer setup
     >> inner setup
     >> test
-    >> inner teardown start"
+    >> inner teardown start
+    >> outer teardown"
   `)
   expect(stderr).toMatchInlineSnapshot(`
     "
@@ -1893,7 +1895,7 @@ test('tests are skipped when aroundAll setup fails', async () => {
   `)
 })
 
-test('aroundEach teardown timeout works when runTest error is caught', async () => {
+test('aroundEach teardown timeout works when inner fails', async () => {
   const { stderr, errorTree } = await runInlineTests({
     'caught-inner-error-timeout.test.ts': `
       import { aroundEach, afterAll, describe, expect, test } from 'vitest'
@@ -1901,7 +1903,7 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
       let errorCaught = false
 
       afterAll(() => {
-        expect(errorCaught).toBe(true)
+        expect(errorCaught).toBe(false)
       })
 
       describe('suite', () => {
@@ -1942,7 +1944,19 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
          12|           try {
          13|             await runTest()
 
-    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/2]⎯
+
+     FAIL  caught-inner-error-timeout.test.ts > suite > test
+    Error: inner aroundEach teardown failure
+     ❯ caught-inner-error-timeout.test.ts:24:17
+         22|         aroundEach(async (runTest) => {
+         23|           await runTest()
+         24|           throw new Error('inner aroundEach teardown failure')
+           |                 ^
+         25|         })
+         26|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/2]⎯
 
     "
   `)
@@ -1952,6 +1966,7 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
         "suite": {
           "test": [
             "The teardown phase of "aroundEach" hook timed out after 50ms.",
+            "inner aroundEach teardown failure",
           ],
         },
       },
@@ -1959,7 +1974,7 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
   `)
 })
 
-test('aroundAll teardown timeout works when runTest error is caught', async () => {
+test('aroundAll teardown timeout works when inner fails', async () => {
   const { stderr, errorTree } = await runInlineTests({
     'caught-inner-error-timeout.test.ts': `
       import { aroundAll, afterAll, describe, expect, test } from 'vitest'
@@ -1967,7 +1982,7 @@ test('aroundAll teardown timeout works when runTest error is caught', async () =
       let errorCaught = false
 
       afterAll(() => {
-        expect(errorCaught).toBe(true)
+        expect(errorCaught).toBe(false)
       })
 
       describe('suite', () => {
@@ -2008,7 +2023,19 @@ test('aroundAll teardown timeout works when runTest error is caught', async () =
          12|           try {
          13|             await runTest()
 
-    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/2]⎯
+
+     FAIL  caught-inner-error-timeout.test.ts > suite
+    Error: inner aroundAll teardown failure
+     ❯ caught-inner-error-timeout.test.ts:24:17
+         22|         aroundAll(async (runTest) => {
+         23|           await runTest()
+         24|           throw new Error('inner aroundAll teardown failure')
+           |                 ^
+         25|         })
+         26|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/2]⎯
 
     "
   `)
@@ -2160,3 +2187,441 @@ test('aroundAll aborts late runSuite after setup timeout', async () => {
     }
   `)
 })
+
+test('nested aroundEach setup error is not propagated to outer runTest catch', async () => {
+  const { stdout, stderr, errorTree } = await runInlineTests({
+    'nested-around-each-setup-error.test.ts': `
+      import { aroundEach, test } from 'vitest'
+
+      aroundEach(async (runTest) => {
+        console.log('>> outer setup')
+        try {
+          await runTest()
+        }
+        catch (error) {
+          console.log('>> outer caught', String(error))
+        }
+        console.log('>> outer teardown')
+      })
+
+      aroundEach(async (_runTest) => {
+        console.log('>> inner setup')
+        throw new Error('inner aroundEach setup error')
+      })
+
+      test('repro', () => {
+        console.log('>> test body')
+      })
+    `,
+  })
+
+  expect(stderr).toMatchInlineSnapshot(`
+    "
+    ⎯⎯⎯⎯⎯⎯⎯ Failed Tests 1 ⎯⎯⎯⎯⎯⎯⎯
+
+     FAIL  nested-around-each-setup-error.test.ts > repro
+    Error: inner aroundEach setup error
+     ❯ nested-around-each-setup-error.test.ts:17:15
+         15|       aroundEach(async (_runTest) => {
+         16|         console.log('>> inner setup')
+         17|         throw new Error('inner aroundEach setup error')
+           |               ^
+         18|       })
+         19|
+     ❯ nested-around-each-setup-error.test.ts:7:17
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
+
+    "
+  `)
+  expect(extractLogs(stdout)).toMatchInlineSnapshot(`
+    ">> outer setup
+    >> inner setup
+    >> outer teardown"
+  `)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "nested-around-each-setup-error.test.ts": {
+        "repro": [
+          "inner aroundEach setup error",
+        ],
+      },
+    }
+  `)
+})
+
+test('nested aroundEach teardown error is not propagated to outer runTest catch', async () => {
+  const { stdout, stderr, errorTree } = await runInlineTests({
+    'nested-around-each-teardown-error.test.ts': `
+      import { aroundEach, test } from 'vitest'
+
+      aroundEach(async (runTest) => {
+        console.log('>> outer setup')
+        try {
+          await runTest()
+        }
+        catch (error) {
+          console.log('>> outer caught', String(error))
+        }
+        console.log('>> outer teardown')
+      })
+
+      aroundEach(async (runTest) => {
+        console.log('>> inner setup')
+        await runTest()
+        console.log('>> inner teardown')
+        throw new Error('inner aroundEach teardown error')
+      })
+
+      test('repro', () => {
+        console.log('>> test body')
+      })
+    `,
+  })
+
+  expect(stderr).toMatchInlineSnapshot(`
+    "
+    ⎯⎯⎯⎯⎯⎯⎯ Failed Tests 1 ⎯⎯⎯⎯⎯⎯⎯
+
+     FAIL  nested-around-each-teardown-error.test.ts > repro
+    Error: inner aroundEach teardown error
+     ❯ nested-around-each-teardown-error.test.ts:19:15
+         17|         await runTest()
+         18|         console.log('>> inner teardown')
+         19|         throw new Error('inner aroundEach teardown error')
+           |               ^
+         20|       })
+         21|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
+
+    "
+  `)
+  expect(extractLogs(stdout)).toMatchInlineSnapshot(`
+    ">> outer setup
+    >> inner setup
+    >> test body
+    >> inner teardown
+    >> outer teardown"
+  `)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "nested-around-each-teardown-error.test.ts": {
+        "repro": [
+          "inner aroundEach teardown error",
+        ],
+      },
+    }
+  `)
+})
+
+test('nested aroundAll setup error is not propagated to outer runSuite catch', async () => {
+  const { stdout, stderr, errorTree } = await runInlineTests({
+    'nested-around-all-setup-error.test.ts': `
+      import { aroundAll, test } from 'vitest'
+
+      aroundAll(async (runSuite) => {
+        console.log('>> outer setup')
+        try {
+          await runSuite()
+        }
+        catch (error) {
+          console.log('>> outer caught', String(error))
+        }
+        console.log('>> outer teardown')
+      })
+
+      aroundAll(async (_runSuite) => {
+        console.log('>> inner setup')
+        throw new Error('inner aroundAll setup error')
+      })
+
+      test('repro', () => {
+        console.log('>> test body')
+      })
+    `,
+  })
+
+  expect(stderr).toMatchInlineSnapshot(`
+    "
+    ⎯⎯⎯⎯⎯⎯ Failed Suites 1 ⎯⎯⎯⎯⎯⎯⎯
+
+     FAIL  nested-around-all-setup-error.test.ts [ nested-around-all-setup-error.test.ts ]
+    Error: inner aroundAll setup error
+     ❯ nested-around-all-setup-error.test.ts:17:15
+         15|       aroundAll(async (_runSuite) => {
+         16|         console.log('>> inner setup')
+         17|         throw new Error('inner aroundAll setup error')
+           |               ^
+         18|       })
+         19|
+     ❯ nested-around-all-setup-error.test.ts:7:17
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
+
+    "
+  `)
+  expect(extractLogs(stdout)).toMatchInlineSnapshot(`
+    ">> outer setup
+    >> inner setup
+    >> outer teardown"
+  `)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "nested-around-all-setup-error.test.ts": {
+        "repro": "skipped",
+      },
+    }
+  `)
+})
+
+test('nested aroundAll teardown error is not propagated to outer runSuite catch', async () => {
+  const { stdout, stderr, errorTree } = await runInlineTests({
+    'nested-around-all-teardown-error.test.ts': `
+      import { aroundAll, test } from 'vitest'
+
+      aroundAll(async (runSuite) => {
+        console.log('>> outer setup')
+        try {
+          await runSuite()
+        }
+        catch (error) {
+          console.log('>> outer caught', String(error))
+        }
+        console.log('>> outer teardown')
+      })
+
+      aroundAll(async (runSuite) => {
+        console.log('>> inner setup')
+        await runSuite()
+        console.log('>> inner teardown')
+        throw new Error('inner aroundAll teardown error')
+      })
+
+      test('repro', () => {
+        console.log('>> test body')
+      })
+    `,
+  })
+
+  expect(stderr).toMatchInlineSnapshot(`
+    "
+    ⎯⎯⎯⎯⎯⎯ Failed Suites 1 ⎯⎯⎯⎯⎯⎯⎯
+
+     FAIL  nested-around-all-teardown-error.test.ts [ nested-around-all-teardown-error.test.ts ]
+    Error: inner aroundAll teardown error
+     ❯ nested-around-all-teardown-error.test.ts:19:15
+         17|         await runSuite()
+         18|         console.log('>> inner teardown')
+         19|         throw new Error('inner aroundAll teardown error')
+           |               ^
+         20|       })
+         21|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
+
+    "
+  `)
+  expect(extractLogs(stdout)).toMatchInlineSnapshot(`
+    ">> outer setup
+    >> inner setup
+    >> test body
+    >> inner teardown
+    >> outer teardown"
+  `)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "nested-around-all-teardown-error.test.ts": {
+        "repro": "passed",
+      },
+    }
+  `)
+})
+
+test('three nested aroundEach teardown errors are all reported', async () => {
+  const { stdout, stderr, errorTree } = await runInlineTests({
+    'triple-around-each-teardown-errors.test.ts': `
+      import { aroundEach, test } from 'vitest'
+
+      aroundEach(async (runTest) => {
+        console.log('>> outer setup')
+        await runTest()
+        console.log('>> outer teardown')
+        throw new Error('outer aroundEach teardown error')
+      })
+
+      aroundEach(async (runTest) => {
+        console.log('>> middle setup')
+        await runTest()
+        console.log('>> middle teardown')
+        throw new Error('middle aroundEach teardown error')
+      })
+
+      aroundEach(async (runTest) => {
+        console.log('>> inner setup')
+        await runTest()
+        console.log('>> inner teardown')
+        throw new Error('inner aroundEach teardown error')
+      })
+
+      test('repro', () => {
+        console.log('>> test body')
+      })
+    `,
+  })
+
+  expect(stderr).toMatchInlineSnapshot(`
+    "
+    ⎯⎯⎯⎯⎯⎯⎯ Failed Tests 1 ⎯⎯⎯⎯⎯⎯⎯
+
+     FAIL  triple-around-each-teardown-errors.test.ts > repro
+    Error: outer aroundEach teardown error
+     ❯ triple-around-each-teardown-errors.test.ts:8:15
+          6|         await runTest()
+          7|         console.log('>> outer teardown')
+          8|         throw new Error('outer aroundEach teardown error')
+           |               ^
+          9|       })
+         10|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/3]⎯
+
+     FAIL  triple-around-each-teardown-errors.test.ts > repro
+    Error: inner aroundEach teardown error
+     ❯ triple-around-each-teardown-errors.test.ts:22:15
+         20|         await runTest()
+         21|         console.log('>> inner teardown')
+         22|         throw new Error('inner aroundEach teardown error')
+           |               ^
+         23|       })
+         24|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/3]⎯
+
+     FAIL  triple-around-each-teardown-errors.test.ts > repro
+    Error: middle aroundEach teardown error
+     ❯ triple-around-each-teardown-errors.test.ts:15:15
+         13|         await runTest()
+         14|         console.log('>> middle teardown')
+         15|         throw new Error('middle aroundEach teardown error')
+           |               ^
+         16|       })
+         17|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/3]⎯
+
+    "
+  `)
+  expect(extractLogs(stdout)).toMatchInlineSnapshot(`
+    ">> outer setup
+    >> middle setup
+    >> inner setup
+    >> test body
+    >> inner teardown
+    >> middle teardown
+    >> outer teardown"
+  `)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "triple-around-each-teardown-errors.test.ts": {
+        "repro": [
+          "outer aroundEach teardown error",
+          "inner aroundEach teardown error",
+          "middle aroundEach teardown error",
+        ],
+      },
+    }
+  `)
+})
+
+test('three nested aroundAll teardown errors are all reported', async () => {
+  const { stdout, stderr, errorTree } = await runInlineTests({
+    'triple-around-all-teardown-errors.test.ts': `
+      import { aroundAll, test } from 'vitest'
+
+      aroundAll(async (runSuite) => {
+        console.log('>> outer setup')
+        await runSuite()
+        console.log('>> outer teardown')
+        throw new Error('outer aroundAll teardown error')
+      })
+
+      aroundAll(async (runSuite) => {
+        console.log('>> middle setup')
+        await runSuite()
+        console.log('>> middle teardown')
+        throw new Error('middle aroundAll teardown error')
+      })
+
+      aroundAll(async (runSuite) => {
+        console.log('>> inner setup')
+        await runSuite()
+        console.log('>> inner teardown')
+        throw new Error('inner aroundAll teardown error')
+      })
+
+      test('repro', () => {
+        console.log('>> test body')
+      })
+    `,
+  })
+
+  expect(stderr).toMatchInlineSnapshot(`
+    "
+    ⎯⎯⎯⎯⎯⎯ Failed Suites 1 ⎯⎯⎯⎯⎯⎯⎯
+
+     FAIL  triple-around-all-teardown-errors.test.ts [ triple-around-all-teardown-errors.test.ts ]
+    Error: outer aroundAll teardown error
+     ❯ triple-around-all-teardown-errors.test.ts:8:15
+          6|         await runSuite()
+          7|         console.log('>> outer teardown')
+          8|         throw new Error('outer aroundAll teardown error')
+           |               ^
+          9|       })
+         10|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/3]⎯
+
+     FAIL  triple-around-all-teardown-errors.test.ts [ triple-around-all-teardown-errors.test.ts ]
+    Error: inner aroundAll teardown error
+     ❯ triple-around-all-teardown-errors.test.ts:22:15
+         20|         await runSuite()
+         21|         console.log('>> inner teardown')
+         22|         throw new Error('inner aroundAll teardown error')
+           |               ^
+         23|       })
+         24|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/3]⎯
+
+     FAIL  triple-around-all-teardown-errors.test.ts [ triple-around-all-teardown-errors.test.ts ]
+    Error: middle aroundAll teardown error
+     ❯ triple-around-all-teardown-errors.test.ts:15:15
+         13|         await runSuite()
+         14|         console.log('>> middle teardown')
+         15|         throw new Error('middle aroundAll teardown error')
+           |               ^
+         16|       })
+         17|
+
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/3]⎯
+
+    "
+  `)
+  expect(extractLogs(stdout)).toMatchInlineSnapshot(`
+    ">> outer setup
+    >> middle setup
+    >> inner setup
+    >> test body
+    >> inner teardown
+    >> middle teardown
+    >> outer teardown"
+  `)
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "triple-around-all-teardown-errors.test.ts": {
+        "repro": "passed",
+      },
+    }
+  `)
+})

From 00d1ec412aa8c80cacd6636d1474f1c58d5967fb Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Mon, 16 Feb 2026 15:44:26 +0900
Subject: [PATCH 27/33] fix: fix errors order

---
 packages/runner/src/run.ts        |  26 ++------
 test/cli/test/around-each.test.ts | 104 +++++++++++++++---------------
 2 files changed, 57 insertions(+), 73 deletions(-)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index 43f98d0cb88c..57688d9ad971 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -267,10 +267,7 @@ async function callAroundHooks<THook extends Function>(
     return
   }
 
-  const deferredErrors: unknown[] = []
-  const captureDeferredError = (error: unknown) => {
-    deferredErrors.push(error)
-  }
+  const hookErrors: unknown[] = []
 
   const createTimeoutPromise = (
     timeout: number,
@@ -357,7 +354,7 @@ async function callAroundHooks<THook extends Function>(
       setupTimeout.clear()
 
       // Run inner hooks - don't time this against our teardown timeout
-      await runNextHook(index + 1).catch(captureDeferredError)
+      await runNextHook(index + 1).catch(e => hookErrors.push(e))
 
       // Start teardown timer after inner hooks complete - only times this hook's teardown code
       teardownTimeout = createTimeoutPromise(timeout, 'teardown', stackTraceError)
@@ -417,23 +414,10 @@ async function callAroundHooks<THook extends Function>(
     }
   }
 
-  let topLevelError: unknown
-  try {
-    await runNextHook(0)
-  }
-  catch (error) {
-    topLevelError = error
-  }
+  await runNextHook(0).catch(e => hookErrors.push(e))
 
-  if (topLevelError !== undefined) {
-    deferredErrors.unshift(topLevelError)
-  }
-
-  if (deferredErrors.length === 1) {
-    throw deferredErrors[0]
-  }
-  if (deferredErrors.length > 1) {
-    throw new AggregateError(deferredErrors, `Multiple errors occurred in nested ${hookName} hooks`)
+  if (hookErrors.length > 0) {
+    throw hookErrors
   }
 }
 
diff --git a/test/cli/test/around-each.test.ts b/test/cli/test/around-each.test.ts
index e577a2fe7065..e57d8e4748eb 100644
--- a/test/cli/test/around-each.test.ts
+++ b/test/cli/test/around-each.test.ts
@@ -1934,18 +1934,6 @@ test('aroundEach teardown timeout works when inner fails', async () => {
     "
     ⎯⎯⎯⎯⎯⎯⎯ Failed Tests 1 ⎯⎯⎯⎯⎯⎯⎯
 
-     FAIL  caught-inner-error-timeout.test.ts > suite > test
-    AroundHookTeardownError: The teardown phase of "aroundEach" hook timed out after 50ms.
-     ❯ caught-inner-error-timeout.test.ts:11:9
-          9|
-         10|       describe('suite', () => {
-         11|         aroundEach(async (runTest) => {
-           |         ^
-         12|           try {
-         13|             await runTest()
-
-    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/2]⎯
-
      FAIL  caught-inner-error-timeout.test.ts > suite > test
     Error: inner aroundEach teardown failure
      ❯ caught-inner-error-timeout.test.ts:24:17
@@ -1956,6 +1944,18 @@ test('aroundEach teardown timeout works when inner fails', async () => {
          25|         })
          26|
 
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/2]⎯
+
+     FAIL  caught-inner-error-timeout.test.ts > suite > test
+    AroundHookTeardownError: The teardown phase of "aroundEach" hook timed out after 50ms.
+     ❯ caught-inner-error-timeout.test.ts:11:9
+          9|
+         10|       describe('suite', () => {
+         11|         aroundEach(async (runTest) => {
+           |         ^
+         12|           try {
+         13|             await runTest()
+
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/2]⎯
 
     "
@@ -1965,8 +1965,8 @@ test('aroundEach teardown timeout works when inner fails', async () => {
       "caught-inner-error-timeout.test.ts": {
         "suite": {
           "test": [
-            "The teardown phase of "aroundEach" hook timed out after 50ms.",
             "inner aroundEach teardown failure",
+            "The teardown phase of "aroundEach" hook timed out after 50ms.",
           ],
         },
       },
@@ -2013,18 +2013,6 @@ test('aroundAll teardown timeout works when inner fails', async () => {
     "
     ⎯⎯⎯⎯⎯⎯ Failed Suites 1 ⎯⎯⎯⎯⎯⎯⎯
 
-     FAIL  caught-inner-error-timeout.test.ts > suite
-    AroundHookTeardownError: The teardown phase of "aroundAll" hook timed out after 50ms.
-     ❯ caught-inner-error-timeout.test.ts:11:9
-          9|
-         10|       describe('suite', () => {
-         11|         aroundAll(async (runTest) => {
-           |         ^
-         12|           try {
-         13|             await runTest()
-
-    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/2]⎯
-
      FAIL  caught-inner-error-timeout.test.ts > suite
     Error: inner aroundAll teardown failure
      ❯ caught-inner-error-timeout.test.ts:24:17
@@ -2035,6 +2023,18 @@ test('aroundAll teardown timeout works when inner fails', async () => {
          25|         })
          26|
 
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/2]⎯
+
+     FAIL  caught-inner-error-timeout.test.ts > suite
+    AroundHookTeardownError: The teardown phase of "aroundAll" hook timed out after 50ms.
+     ❯ caught-inner-error-timeout.test.ts:11:9
+          9|
+         10|       describe('suite', () => {
+         11|         aroundAll(async (runTest) => {
+           |         ^
+         12|           try {
+         13|             await runTest()
+
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/2]⎯
 
     "
@@ -2474,18 +2474,6 @@ test('three nested aroundEach teardown errors are all reported', async () => {
     "
     ⎯⎯⎯⎯⎯⎯⎯ Failed Tests 1 ⎯⎯⎯⎯⎯⎯⎯
 
-     FAIL  triple-around-each-teardown-errors.test.ts > repro
-    Error: outer aroundEach teardown error
-     ❯ triple-around-each-teardown-errors.test.ts:8:15
-          6|         await runTest()
-          7|         console.log('>> outer teardown')
-          8|         throw new Error('outer aroundEach teardown error')
-           |               ^
-          9|       })
-         10|
-
-    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/3]⎯
-
      FAIL  triple-around-each-teardown-errors.test.ts > repro
     Error: inner aroundEach teardown error
      ❯ triple-around-each-teardown-errors.test.ts:22:15
@@ -2496,7 +2484,7 @@ test('three nested aroundEach teardown errors are all reported', async () => {
          23|       })
          24|
 
-    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/3]⎯
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/3]⎯
 
      FAIL  triple-around-each-teardown-errors.test.ts > repro
     Error: middle aroundEach teardown error
@@ -2508,6 +2496,18 @@ test('three nested aroundEach teardown errors are all reported', async () => {
          16|       })
          17|
 
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/3]⎯
+
+     FAIL  triple-around-each-teardown-errors.test.ts > repro
+    Error: outer aroundEach teardown error
+     ❯ triple-around-each-teardown-errors.test.ts:8:15
+          6|         await runTest()
+          7|         console.log('>> outer teardown')
+          8|         throw new Error('outer aroundEach teardown error')
+           |               ^
+          9|       })
+         10|
+
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/3]⎯
 
     "
@@ -2525,9 +2525,9 @@ test('three nested aroundEach teardown errors are all reported', async () => {
     {
       "triple-around-each-teardown-errors.test.ts": {
         "repro": [
-          "outer aroundEach teardown error",
           "inner aroundEach teardown error",
           "middle aroundEach teardown error",
+          "outer aroundEach teardown error",
         ],
       },
     }
@@ -2570,18 +2570,6 @@ test('three nested aroundAll teardown errors are all reported', async () => {
     "
     ⎯⎯⎯⎯⎯⎯ Failed Suites 1 ⎯⎯⎯⎯⎯⎯⎯
 
-     FAIL  triple-around-all-teardown-errors.test.ts [ triple-around-all-teardown-errors.test.ts ]
-    Error: outer aroundAll teardown error
-     ❯ triple-around-all-teardown-errors.test.ts:8:15
-          6|         await runSuite()
-          7|         console.log('>> outer teardown')
-          8|         throw new Error('outer aroundAll teardown error')
-           |               ^
-          9|       })
-         10|
-
-    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/3]⎯
-
      FAIL  triple-around-all-teardown-errors.test.ts [ triple-around-all-teardown-errors.test.ts ]
     Error: inner aroundAll teardown error
      ❯ triple-around-all-teardown-errors.test.ts:22:15
@@ -2592,7 +2580,7 @@ test('three nested aroundAll teardown errors are all reported', async () => {
          23|       })
          24|
 
-    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/3]⎯
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/3]⎯
 
      FAIL  triple-around-all-teardown-errors.test.ts [ triple-around-all-teardown-errors.test.ts ]
     Error: middle aroundAll teardown error
@@ -2604,6 +2592,18 @@ test('three nested aroundAll teardown errors are all reported', async () => {
          16|       })
          17|
 
+    ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/3]⎯
+
+     FAIL  triple-around-all-teardown-errors.test.ts [ triple-around-all-teardown-errors.test.ts ]
+    Error: outer aroundAll teardown error
+     ❯ triple-around-all-teardown-errors.test.ts:8:15
+          6|         await runSuite()
+          7|         console.log('>> outer teardown')
+          8|         throw new Error('outer aroundAll teardown error')
+           |               ^
+          9|       })
+         10|
+
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/3]⎯
 
     "

From 02b8277411ca7e8a63ed6ffdc85fc831c8a00357 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Mon, 16 Feb 2026 16:29:21 +0900
Subject: [PATCH 28/33] test: update

---
 test/cli/test/around-each.test.ts | 17 +++++++++++++----
 test/cli/test/concurrent.test.ts  |  8 +++++---
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/test/cli/test/around-each.test.ts b/test/cli/test/around-each.test.ts
index 4644a12e650e..247b64066fce 100644
--- a/test/cli/test/around-each.test.ts
+++ b/test/cli/test/around-each.test.ts
@@ -1097,7 +1097,8 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
       "caught-inner-error-timeout.test.ts": {
         "suite": {
           "test": [
-            "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
+            "inner aroundEach teardown failure",
+            "The teardown phase of "aroundEach" hook timed out after 50ms.",
           ],
         },
       },
@@ -1707,7 +1708,8 @@ test('aroundAll teardown timeout works when runSuite error is caught', async ()
       "caught-inner-suite-error-timeout.test.ts": {
         "suite": {
           "__suite_errors__": [
-            "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
+            "inner aroundAll teardown failure",
+            "The teardown phase of "aroundAll" hook timed out after 50ms.",
           ],
           "test": "passed",
         },
@@ -2126,6 +2128,10 @@ test('aroundAll teardown timeout works when inner fails', async () => {
     {
       "caught-inner-error-timeout.test.ts": {
         "suite": {
+          "__suite_errors__": [
+            "inner aroundAll teardown failure",
+            "The teardown phase of "aroundAll" hook timed out after 50ms.",
+          ],
           "test": "passed",
         },
       },
@@ -2264,6 +2270,9 @@ test('aroundAll aborts late runSuite after setup timeout', async () => {
     {
       "late-run-suite-after-timeout.test.ts": {
         "timed out suite": {
+          "__suite_errors__": [
+            "The setup phase of "aroundAll" hook timed out after 10ms.",
+          ],
           "basic": "skipped",
         },
       },
@@ -2311,7 +2320,7 @@ test('nested aroundEach setup error is not propagated to outer runTest catch', a
            |               ^
          18|       })
          19|
-     ❯ nested-around-each-setup-error.test.ts:7:17
+     ❯ nested-around-each-setup-error.test.ts:7:11
 
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
 
@@ -2438,7 +2447,7 @@ test('nested aroundAll setup error is not propagated to outer runSuite catch', a
            |               ^
          18|       })
          19|
-     ❯ nested-around-all-setup-error.test.ts:7:17
+     ❯ nested-around-all-setup-error.test.ts:7:11
 
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
 
diff --git a/test/cli/test/concurrent.test.ts b/test/cli/test/concurrent.test.ts
index 5dd2f0833cd5..80601067a554 100644
--- a/test/cli/test/concurrent.test.ts
+++ b/test/cli/test/concurrent.test.ts
@@ -709,7 +709,7 @@ test('neighboring suite aroundAll does not hang when setup times out before late
           "__suite_errors__": [
             "The setup phase of "aroundAll" hook timed out after 500ms.",
           ],
-          "a": "passed",
+          "a": "skipped",
         },
         "s2": {
           "b": [
@@ -1019,7 +1019,8 @@ test('aroundEach enforces teardown timeout when inner error is caught', async ()
       "basic.test.ts": {
         "wrapper": {
           "a": [
-            "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
+            "inner aroundEach teardown failure",
+            "The teardown phase of "aroundEach" hook timed out after 50ms.",
           ],
         },
       },
@@ -1064,7 +1065,8 @@ test('aroundAll enforces teardown timeout when inner error is caught', async ()
       "basic.test.ts": {
         "suite": {
           "__suite_errors__": [
-            "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
+            "inner aroundAll teardown failure",
+            "The teardown phase of "aroundAll" hook timed out after 50ms.",
           ],
           "a": "passed",
         },

From e53955c04d3c1318d5219d8e28929d07ff052734 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Mon, 16 Feb 2026 17:04:44 +0900
Subject: [PATCH 29/33] perf: reduce microtask

---
 packages/runner/src/run.ts                    | 10 ++-
 .../runner/src/utils/limit-concurrency.ts     | 68 ++++++++++++-------
 test/cli/test/around-each.test.ts             |  4 +-
 3 files changed, 53 insertions(+), 29 deletions(-)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index f096aa75bc4d..736459245de2 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -362,7 +362,10 @@ async function callAroundHooks<THook extends Function>(
       // Run inner hooks - don't time this against our teardown timeout
       await runNextHook(index + 1).catch(e => hookErrors.push(e))
 
-      teardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire()
+      const teardownAcquire = limitMaxConcurrency.acquire()
+      teardownLimitConcurrencyRelease = teardownAcquire instanceof Promise
+        ? await teardownAcquire
+        : teardownAcquire
 
       // Start teardown timer after inner hooks complete - only times this hook's teardown code
       teardownTimeout = createTimeoutPromise(timeout, 'teardown', stackTraceError)
@@ -371,7 +374,10 @@ async function callAroundHooks<THook extends Function>(
       resolveUseReturned()
     }
 
-    setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire()
+    const setupAcquire = limitMaxConcurrency.acquire()
+    setupLimitConcurrencyRelease = setupAcquire instanceof Promise
+      ? await setupAcquire
+      : setupAcquire
 
     // Start setup timeout
     setupTimeout = createTimeoutPromise(timeout, 'setup', stackTraceError)
diff --git a/packages/runner/src/utils/limit-concurrency.ts b/packages/runner/src/utils/limit-concurrency.ts
index 0ec35480d4f7..600988e1cbc0 100644
--- a/packages/runner/src/utils/limit-concurrency.ts
+++ b/packages/runner/src/utils/limit-concurrency.ts
@@ -3,7 +3,7 @@ type QueueNode<T> = [value: T, next?: QueueNode<T>]
 
 export interface ConcurrencyLimiter {
   <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args): Promise<T>
-  acquire: () => Promise<() => void>
+  acquire: () => (() => void) | Promise<() => void>
 }
 
 /**
@@ -38,40 +38,58 @@ export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLim
     }
   }
 
-  const acquire = async () => {
-    await new Promise<void>((resolve) => {
-      if (count++ < concurrency) {
-        // No need to queue if fewer than maxConcurrency tasks are running.
-        resolve()
+  const acquire = () => {
+    let released = false
+    const releaseIfNeeded = () => {
+      if (!released) {
+        released = true
+        release()
       }
-      else if (tail) {
+    }
+
+    if (count++ < concurrency) {
+      return releaseIfNeeded
+    }
+
+    return new Promise<() => void>((resolve) => {
+      if (tail) {
         // There are pending tasks, so append to the queue.
-        tail = tail[1] = [resolve]
+        tail = tail[1] = [() => resolve(releaseIfNeeded)]
       }
       else {
         // No other pending tasks, initialize the queue with a new tail and head.
-        head = tail = [resolve]
+        head = tail = [() => resolve(releaseIfNeeded)]
       }
     })
-    let released = false
-    return () => {
-      if (!released) {
-        released = true
-        release()
+  }
+
+  const limit: ConcurrencyLimiter = <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => {
+    const runWithRelease = (releaseIfNeeded: () => void): Promise<T> => {
+      let result: PromiseLike<T> | T
+
+      try {
+        result = func(...args)
+      }
+      catch (error) {
+        releaseIfNeeded()
+        return Promise.reject(error)
+      }
+
+      if (typeof result === 'object' && result != null && typeof (result as PromiseLike<T>).then === 'function') {
+        return Promise.resolve(result).finally(releaseIfNeeded)
       }
+
+      releaseIfNeeded()
+      return Promise.resolve(result)
+    }
+
+    const acquired = acquire()
+
+    if (typeof acquired === 'function') {
+      return runWithRelease(acquired)
     }
-  }
 
-  const limit: ConcurrencyLimiter = (func, ...args) => {
-    // Create a promise chain that:
-    //  1. Waits for its turn in the task queue (if necessary).
-    //  2. Runs the task.
-    //  3. Allows the next pending task (if any) to run.
-    return acquire().then(() => {
-      // Running func here ensures that even a non-thenable result or an
-      // immediately thrown error gets wrapped into a Promise.
-      return func(...args)
-    }).finally(release)
+    return acquired.then(runWithRelease)
   }
 
   limit.acquire = acquire
diff --git a/test/cli/test/around-each.test.ts b/test/cli/test/around-each.test.ts
index 247b64066fce..7540a77cd97b 100644
--- a/test/cli/test/around-each.test.ts
+++ b/test/cli/test/around-each.test.ts
@@ -2320,7 +2320,7 @@ test('nested aroundEach setup error is not propagated to outer runTest catch', a
            |               ^
          18|       })
          19|
-     ❯ nested-around-each-setup-error.test.ts:7:11
+     ❯ nested-around-each-setup-error.test.ts:7:17
 
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
 
@@ -2447,7 +2447,7 @@ test('nested aroundAll setup error is not propagated to outer runSuite catch', a
            |               ^
          18|       })
          19|
-     ❯ nested-around-all-setup-error.test.ts:7:11
+     ❯ nested-around-all-setup-error.test.ts:7:17
 
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
 

From afb82072d65673da17a3b5db10805a579b0b263a Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Mon, 16 Feb 2026 17:37:02 +0900
Subject: [PATCH 30/33] refactor: limitConcurrency

---
 packages/runner/src/run.ts                    | 10 +--
 .../runner/src/utils/limit-concurrency.ts     | 68 ++++++++-----------
 test/cli/test/around-each.test.ts             |  4 +-
 3 files changed, 34 insertions(+), 48 deletions(-)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index 736459245de2..f096aa75bc4d 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -362,10 +362,7 @@ async function callAroundHooks<THook extends Function>(
       // Run inner hooks - don't time this against our teardown timeout
       await runNextHook(index + 1).catch(e => hookErrors.push(e))
 
-      const teardownAcquire = limitMaxConcurrency.acquire()
-      teardownLimitConcurrencyRelease = teardownAcquire instanceof Promise
-        ? await teardownAcquire
-        : teardownAcquire
+      teardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire()
 
       // Start teardown timer after inner hooks complete - only times this hook's teardown code
       teardownTimeout = createTimeoutPromise(timeout, 'teardown', stackTraceError)
@@ -374,10 +371,7 @@ async function callAroundHooks<THook extends Function>(
       resolveUseReturned()
     }
 
-    const setupAcquire = limitMaxConcurrency.acquire()
-    setupLimitConcurrencyRelease = setupAcquire instanceof Promise
-      ? await setupAcquire
-      : setupAcquire
+    setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire()
 
     // Start setup timeout
     setupTimeout = createTimeoutPromise(timeout, 'setup', stackTraceError)
diff --git a/packages/runner/src/utils/limit-concurrency.ts b/packages/runner/src/utils/limit-concurrency.ts
index 600988e1cbc0..b6dee1d4e58f 100644
--- a/packages/runner/src/utils/limit-concurrency.ts
+++ b/packages/runner/src/utils/limit-concurrency.ts
@@ -1,11 +1,12 @@
 // A compact (code-wise, probably not memory-wise) singly linked list node.
 type QueueNode<T> = [value: T, next?: QueueNode<T>]
 
-export interface ConcurrencyLimiter {
-  <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args): Promise<T>
+export interface ConcurrencyLimiter extends RunWithLimit {
   acquire: () => (() => void) | Promise<() => void>
 }
 
+type RunWithLimit = <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>
+
 /**
  * Return a function for running multiple async operations with limited concurrency.
  */
@@ -19,11 +20,8 @@ export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLim
   let head: undefined | QueueNode<() => void>
   let tail: undefined | QueueNode<() => void>
 
-  const release = () => {
-    if (count === 0) {
-      return
-    }
-
+  // A bookkeeping function executed whenever a task has been run to completion.
+  const finish = () => {
     count--
 
     // Check if there are further pending tasks in the queue.
@@ -40,59 +38,53 @@ export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLim
 
   const acquire = () => {
     let released = false
-    const releaseIfNeeded = () => {
+    const release = () => {
       if (!released) {
         released = true
-        release()
+        finish()
       }
     }
 
     if (count++ < concurrency) {
-      return releaseIfNeeded
+      return release
     }
 
     return new Promise<() => void>((resolve) => {
       if (tail) {
         // There are pending tasks, so append to the queue.
-        tail = tail[1] = [() => resolve(releaseIfNeeded)]
+        tail = tail[1] = [() => resolve(release)]
       }
       else {
         // No other pending tasks, initialize the queue with a new tail and head.
-        head = tail = [() => resolve(releaseIfNeeded)]
+        head = tail = [() => resolve(release)]
       }
     })
   }
 
-  const limit: ConcurrencyLimiter = <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => {
-    const runWithRelease = (releaseIfNeeded: () => void): Promise<T> => {
-      let result: PromiseLike<T> | T
-
-      try {
-        result = func(...args)
-      }
-      catch (error) {
-        releaseIfNeeded()
-        return Promise.reject(error)
-      }
-
-      if (typeof result === 'object' && result != null && typeof (result as PromiseLike<T>).then === 'function') {
-        return Promise.resolve(result).finally(releaseIfNeeded)
-      }
-
-      releaseIfNeeded()
-      return Promise.resolve(result)
-    }
-
-    const acquired = acquire()
+  const runWithLimit: RunWithLimit = (func, ...args) => {
+    const release = acquire()
 
-    if (typeof acquired === 'function') {
-      return runWithRelease(acquired)
+    if (release instanceof Promise) {
+      return release.then(() => func(...args)).finally(finish)
     }
 
-    return acquired.then(runWithRelease)
+    return promiseTry(func, ...args).finally(finish)
   }
 
-  limit.acquire = acquire
+  return Object.assign(runWithLimit, { acquire })
+}
 
-  return limit
+// Promise.try ponyfill
+function promiseTry<TArgs extends unknown[], T>(
+  fn: (...args: TArgs) => T | PromiseLike<T>,
+  ...args: TArgs
+): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    try {
+      resolve(fn(...args))
+    }
+    catch (error) {
+      reject(error)
+    }
+  })
 }
diff --git a/test/cli/test/around-each.test.ts b/test/cli/test/around-each.test.ts
index 7540a77cd97b..247b64066fce 100644
--- a/test/cli/test/around-each.test.ts
+++ b/test/cli/test/around-each.test.ts
@@ -2320,7 +2320,7 @@ test('nested aroundEach setup error is not propagated to outer runTest catch', a
            |               ^
          18|       })
          19|
-     ❯ nested-around-each-setup-error.test.ts:7:17
+     ❯ nested-around-each-setup-error.test.ts:7:11
 
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
 
@@ -2447,7 +2447,7 @@ test('nested aroundAll setup error is not propagated to outer runSuite catch', a
            |               ^
          18|       })
          19|
-     ❯ nested-around-all-setup-error.test.ts:7:17
+     ❯ nested-around-all-setup-error.test.ts:7:11
 
     ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯
 

From 3895d7e475afe7d201a96fafaee5c67a05078c50 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Mon, 16 Feb 2026 18:02:45 +0900
Subject: [PATCH 31/33] perf: reduce microtask

---
 .../runner/src/utils/limit-concurrency.ts     | 35 ++++++++-----------
 1 file changed, 15 insertions(+), 20 deletions(-)

diff --git a/packages/runner/src/utils/limit-concurrency.ts b/packages/runner/src/utils/limit-concurrency.ts
index b6dee1d4e58f..18d0ce0c6db2 100644
--- a/packages/runner/src/utils/limit-concurrency.ts
+++ b/packages/runner/src/utils/limit-concurrency.ts
@@ -62,29 +62,24 @@ export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLim
   }
 
   const runWithLimit: RunWithLimit = (func, ...args) => {
-    const release = acquire()
-
-    if (release instanceof Promise) {
-      return release.then(() => func(...args)).finally(finish)
+    function run(release: () => void) {
+      try {
+        const result = func(...args)
+        if (result instanceof Promise) {
+          return result.finally(release)
+        }
+        release()
+        return Promise.resolve(result)
+      }
+      catch (error) {
+        release()
+        return Promise.reject(error)
+      }
     }
 
-    return promiseTry(func, ...args).finally(finish)
+    const release = acquire()
+    return release instanceof Promise ? release.then(run) : run(release)
   }
 
   return Object.assign(runWithLimit, { acquire })
 }
-
-// Promise.try ponyfill
-function promiseTry<TArgs extends unknown[], T>(
-  fn: (...args: TArgs) => T | PromiseLike<T>,
-  ...args: TArgs
-): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    try {
-      resolve(fn(...args))
-    }
-    catch (error) {
-      reject(error)
-    }
-  })
-}

From 6f7d4de25f0146c14c997d6aa788c122a80b88e5 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Mon, 16 Feb 2026 18:10:38 +0900
Subject: [PATCH 32/33] chore: naming

---
 packages/runner/src/run.ts                     | 3 ++-
 packages/runner/src/utils/limit-concurrency.ts | 8 ++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index f096aa75bc4d..db1d5ae3f892 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -18,6 +18,7 @@ import type {
   TestContext,
   WriteableTestContext,
 } from './types/tasks'
+import type { ConcurrencyLimiter } from './utils/limit-concurrency'
 import { processError } from '@vitest/utils/error' // TODO: load dynamically
 import { shuffle } from '@vitest/utils/helpers'
 import { getSafeTimers } from '@vitest/utils/timers'
@@ -35,7 +36,7 @@ import { hasFailed, hasTests } from './utils/tasks'
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now
 const unixNow = Date.now
 const { clearTimeout, setTimeout } = getSafeTimers()
-let limitMaxConcurrency: ReturnType<typeof limitConcurrency>
+let limitMaxConcurrency: ConcurrencyLimiter
 
 /**
  * Normalizes retry configuration to extract individual values.
diff --git a/packages/runner/src/utils/limit-concurrency.ts b/packages/runner/src/utils/limit-concurrency.ts
index 18d0ce0c6db2..d8ae7f2c2865 100644
--- a/packages/runner/src/utils/limit-concurrency.ts
+++ b/packages/runner/src/utils/limit-concurrency.ts
@@ -1,11 +1,11 @@
 // A compact (code-wise, probably not memory-wise) singly linked list node.
 type QueueNode<T> = [value: T, next?: QueueNode<T>]
 
-export interface ConcurrencyLimiter extends RunWithLimit {
+export interface ConcurrencyLimiter extends ConcurrencyLimiterFn {
   acquire: () => (() => void) | Promise<() => void>
 }
 
-type RunWithLimit = <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>
+type ConcurrencyLimiterFn = <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>
 
 /**
  * Return a function for running multiple async operations with limited concurrency.
@@ -61,7 +61,7 @@ export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLim
     })
   }
 
-  const runWithLimit: RunWithLimit = (func, ...args) => {
+  const limiterFn: ConcurrencyLimiterFn = (func, ...args) => {
     function run(release: () => void) {
       try {
         const result = func(...args)
@@ -81,5 +81,5 @@ export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLim
     return release instanceof Promise ? release.then(run) : run(release)
   }
 
-  return Object.assign(runWithLimit, { acquire })
+  return Object.assign(limiterFn, { acquire })
 }

From 1fbdd6c9ce799592e853fbdd3c4210e807c57047 Mon Sep 17 00:00:00 2001
From: Hiroshi Ogawa <hi.ogawa.zz@gmail.com>
Date: Tue, 17 Feb 2026 10:42:36 +0900
Subject: [PATCH 33/33] test: destructure { task }

---
 test/cli/test/expect-task.test.ts | 15 ++++++---------
 test/test-utils/index.ts          |  8 ++++----
 2 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/test/cli/test/expect-task.test.ts b/test/cli/test/expect-task.test.ts
index 4477d02db044..a017bfc5a133 100644
--- a/test/cli/test/expect-task.test.ts
+++ b/test/cli/test/expect-task.test.ts
@@ -172,7 +172,7 @@ describe('serial', { concurrent: true }, () => {
       name: 'test-bound extend & local extend',
       test: testBoundLocalExtend,
     },
-  ] as const)('works with $name', async ({ options, test }, context) => {
+  ] as const)('works with $name', async ({ options, test }, { task, expect }) => {
     const { stdout, stderr } = await runInlineTests(
       {
         'basic.test.ts': test,
@@ -180,10 +180,9 @@ describe('serial', { concurrent: true }, () => {
       },
       { reporters: ['tap'], ...options },
       undefined,
-      context,
+      task,
     )
 
-    const { expect } = context
     expect(stderr).toBe('')
     expect(stdout.replace(/[\d.]+ms/g, '<time>')).toMatchInlineSnapshot(`
       "TAP version 13
@@ -213,7 +212,7 @@ describe('concurrent', { concurrent: true }, () => {
       name: 'global import',
       test: withConcurrency(globalImport),
     },
-  ] as const)('fails with $name', async ({ options, test }, context) => {
+  ] as const)('fails with $name', async ({ options, test }, { task, expect }) => {
     const { stdout, ctx } = await runInlineTests(
       {
         'basic.test.ts': test,
@@ -221,10 +220,9 @@ describe('concurrent', { concurrent: true }, () => {
       },
       { reporters: ['tap'], ...options },
       undefined,
-      context,
+      task,
     )
 
-    const { expect } = context
     expect(
       stdout
         .replace(/[\d.]+m?s/g, '<time>')
@@ -269,7 +267,7 @@ describe('concurrent', { concurrent: true }, () => {
       name: 'test-bound extend & local extend',
       test: withConcurrency(testBoundLocalExtend),
     },
-  ])('works with $name', async ({ test }, context) => {
+  ])('works with $name', async ({ test }, { task, expect }) => {
     const { stdout } = await runInlineTests(
       {
         'basic.test.ts': test,
@@ -277,10 +275,9 @@ describe('concurrent', { concurrent: true }, () => {
       },
       { reporters: ['tap'] },
       undefined,
-      context,
+      task,
     )
 
-    const { expect } = context
     expect(stdout.replace(/[\d.]+m?s/g, '<time>')).toMatchInlineSnapshot(`
       "TAP version 13
       1..1
diff --git a/test/test-utils/index.ts b/test/test-utils/index.ts
index 167c6dd5ec85..5b2d3a1828b2 100644
--- a/test/test-utils/index.ts
+++ b/test/test-utils/index.ts
@@ -424,7 +424,7 @@ export default config
   return `export default ${JSON.stringify(content)}`
 }
 
-export function useFS<T extends TestFsStructure>(root: string, structure: T, ensureConfig = true, context?: TestContext) {
+export function useFS<T extends TestFsStructure>(root: string, structure: T, ensureConfig = true, task?: TestContext['task']) {
   const files = new Set<string>()
   const hasConfig = Object.keys(structure).some(file => file.includes('.config.'))
   if (ensureConfig && !hasConfig) {
@@ -437,7 +437,7 @@ export function useFS<T extends TestFsStructure>(root: string, structure: T, ens
     fs.mkdirSync(dirname(filepath), { recursive: true })
     fs.writeFileSync(filepath, String(content), 'utf-8')
   }
-  (context?.onTestFinished ?? onTestFinished)(() => {
+  (task?.context.onTestFinished ?? onTestFinished)(() => {
     if (process.env.VITEST_FS_CLEANUP !== 'false') {
       fs.rmSync(root, { recursive: true, force: true })
     }
@@ -494,10 +494,10 @@ export async function runInlineTests(
   structure: TestFsStructure,
   config?: RunVitestConfig,
   options?: VitestRunnerCLIOptions,
-  context?: TestContext,
+  task?: TestContext['task'],
 ) {
   const root = resolve(process.cwd(), `vitest-test-${crypto.randomUUID()}`)
-  const fs = useFS(root, structure, undefined, context)
+  const fs = useFS(root, structure, undefined, task)
   const vitest = await runVitest({
     root,
     ...config,