From 5eaec14b3ade6e6390c60911c90dff9b3ecdc2ed Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Wed, 19 Mar 2025 16:44:56 +0100
Subject: [PATCH 01/30] feat(vitest): allow per-file and per-worker fixtures

---
 docs/guide/test-context.md | 40 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/docs/guide/test-context.md b/docs/guide/test-context.md
index 7cf515db0a8d..ecf73084e35c 100644
--- a/docs/guide/test-context.md
+++ b/docs/guide/test-context.md
@@ -306,6 +306,46 @@ describe('another type of schema', () => {
 })
 ```
 
+#### Per-Scope Context <Version>?</Version>
+
+You can define context that will be initiated once per file or a worker. It is initiated the same way as a regular fixture with an objects parameter:
+
+```ts
+import { test as baseTest } from 'vitest'
+
+export const test = baseTest.extend({
+  perFile: [
+    ({}, { use }) => use([]),
+    { scope: 'file' },
+  ],
+  perWorker: [
+    ({}, { use }) => use([]),
+    { scope: 'worker' },
+  ],
+})
+```
+
+The value is initialised the first time any test has accessed it, unless the fixture options have `auto: true` - in this case the value is initialised before any test has run.
+
+```ts
+const test = baseTest.extend({
+  perFile: [
+    ({}, { use }) => use([]),
+    {
+      scope: 'file',
+      // always run this hook before any test
+      auto: true
+    },
+  ],
+})
+```
+
+The `worker` scope will run the fixture once per worker. The amount of running workers depends on a lot of factors. By default, every file runs in a separate worker, so `file` and `worker` scopes work the same way.
+
+But if you disable [isolation](/config/#isolate), then the amount of workers is limited by the [`maxWorkers`](/config/#maxworkers) or [`poolOptions`](/config/#pooloptions) configuration.
+
+Note that specifying `scope: 'worker'` when running tests in `vmThreads` or `vmForks` will work the same was as `scope: 'file'`. This limitation exists because every test file has its own VM context, so if Vitest would initiate it once, then one context could leak to another and create a lot of reference errors (instances of the same class would reference different constructors, for example).
+
 #### TypeScript
 
 To provide fixture types for all your custom contexts, you can pass the fixtures type as a generic.

From 5f468a36f11a565f5b16b7e97859992b7835d8dc Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Wed, 19 Mar 2025 16:47:50 +0100
Subject: [PATCH 02/30] chore: better grammar

---
 docs/guide/test-context.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/guide/test-context.md b/docs/guide/test-context.md
index ecf73084e35c..5419d0975e1d 100644
--- a/docs/guide/test-context.md
+++ b/docs/guide/test-context.md
@@ -340,11 +340,11 @@ const test = baseTest.extend({
 })
 ```
 
-The `worker` scope will run the fixture once per worker. The amount of running workers depends on a lot of factors. By default, every file runs in a separate worker, so `file` and `worker` scopes work the same way.
+The `worker` scope will run the fixture once per worker. The number of running workers depends on various factors. By default, every file runs in a separate worker, so `file` and `worker` scopes work the same way.
 
-But if you disable [isolation](/config/#isolate), then the amount of workers is limited by the [`maxWorkers`](/config/#maxworkers) or [`poolOptions`](/config/#pooloptions) configuration.
+However, if you disable [isolation](/config/#isolate), then the number of workers is limited by the [`maxWorkers`](/config/#maxworkers) or [`poolOptions`](/config/#pooloptions) configuration.
 
-Note that specifying `scope: 'worker'` when running tests in `vmThreads` or `vmForks` will work the same was as `scope: 'file'`. This limitation exists because every test file has its own VM context, so if Vitest would initiate it once, then one context could leak to another and create a lot of reference errors (instances of the same class would reference different constructors, for example).
+Note that specifying `scope: 'worker'` when running tests in `vmThreads` or `vmForks` will work the same way as `scope: 'file'`. This limitation exists because every test file has its own VM context, so if Vitest were to initiate it once, one context could leak to another and create many reference inconsistencies (instances of the same class would reference different constructors, for example).
 
 #### TypeScript
 

From 3b6ad921a3c4dac58991693e4c00404b4105bafa Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Thu, 3 Apr 2025 17:02:01 +0200
Subject: [PATCH 03/30] feat: draft implementation

---
 packages/runner/src/collect.ts       | 30 +++++++++++-
 packages/runner/src/fixture.ts       | 72 ++++++++++++++++++++++++----
 packages/runner/src/run.ts           |  3 ++
 packages/runner/src/types/tasks.ts   | 11 +++++
 packages/runner/src/utils/collect.ts |  1 +
 5 files changed, 106 insertions(+), 11 deletions(-)

diff --git a/packages/runner/src/collect.ts b/packages/runner/src/collect.ts
index 8e2a2a8d1cdd..146bc7c5d8e1 100644
--- a/packages/runner/src/collect.ts
+++ b/packages/runner/src/collect.ts
@@ -1,9 +1,10 @@
+import type { FixtureItem } from './fixture'
 import type { FileSpecification, VitestRunner } from './types/runner'
-import type { File, SuiteHooks } from './types/tasks'
+import type { File, SuiteHooks, Task } from './types/tasks'
 import { toArray } from '@vitest/utils'
 import { processError } from '@vitest/utils/error'
 import { collectorContext } from './context'
-import { getHooks, setHooks } from './map'
+import { getHooks, getTestFixture, setHooks, setTestFixture } from './map'
 import { runSetupFiles } from './setup'
 import {
   clearCollectorContext,
@@ -104,11 +105,36 @@ export async function collectTests(
     }
 
     files.push(file)
+
+    // TODO: any
+    setTestFixture(file.context as any, getFileFixtires(file))
   }
 
   return files
 }
 
+function getFileFixtires(file: File): FixtureItem[] {
+  const fixtures = new Set<FixtureItem>()
+  function traverse(children: Task[]) {
+    for (const child of children) {
+      if (child.type === 'test') {
+        const childFixtures = getTestFixture(child.context) || []
+        for (const fixture of childFixtures) {
+          // TODO: what if overriden?
+          if (fixture.scope === 'file' && !fixtures.has(fixture)) {
+            fixtures.add(fixture)
+          }
+        }
+      }
+      else {
+        traverse(child.tasks)
+      }
+    }
+  }
+  traverse(file.tasks)
+  return Array.from(fixtures)
+}
+
 function mergeHooks(baseHooks: SuiteHooks, hooks: SuiteHooks): SuiteHooks {
   for (const _key in hooks) {
     const key = _key as keyof SuiteHooks
diff --git a/packages/runner/src/fixture.ts b/packages/runner/src/fixture.ts
index 32afc6aad088..0b61e297638e 100644
--- a/packages/runner/src/fixture.ts
+++ b/packages/runner/src/fixture.ts
@@ -45,7 +45,7 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
   context: T,
   inject: (key: string) => unknown,
 ): T {
-  const fixtureOptionKeys = ['auto', 'injected']
+  const fixtureOptionKeys = ['auto', 'injected', 'scope']
   const fixtureArray: FixtureItem[] = Object.entries(fixtures).map(
     ([prop, value]) => {
       const fixtureItem = { value } as FixtureItem
@@ -94,11 +94,11 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
 
 const fixtureValueMaps = new Map<TestContext, Map<FixtureItem, any>>()
 const cleanupFnArrayMap = new Map<
-  TestContext,
+  object,
   Array<() => void | Promise<void>>
 >()
 
-export async function callFixtureCleanup(context: TestContext): Promise<void> {
+export async function callFixtureCleanup(context: object): Promise<void> {
   const cleanupFnArray = cleanupFnArrayMap.get(context) ?? []
   for (const cleanup of cleanupFnArray.reverse()) {
     await cleanup()
@@ -153,14 +153,19 @@ export function withFixtures(fn: Function, testContext?: TestContext) {
           continue
         }
 
-        const resolvedValue = fixture.isFn
-          ? await resolveFixtureFunction(fixture.value, context, cleanupFnArray)
-          : fixture.value
+        const resolvedValue = await resolveFixtureValue(
+          fixture,
+          context!,
+          cleanupFnArray,
+        )
         context![fixture.prop] = resolvedValue
         fixtureValueMap.set(fixture, resolvedValue)
-        cleanupFnArray.unshift(() => {
-          fixtureValueMap.delete(fixture)
-        })
+
+        if (!fixture.scope || fixture.scope === 'test') {
+          cleanupFnArray.unshift(() => {
+            fixtureValueMap.delete(fixture)
+          })
+        }
       }
     }
 
@@ -168,6 +173,55 @@ export function withFixtures(fn: Function, testContext?: TestContext) {
   }
 }
 
+const fileFixturePromise = new WeakMap<FixtureItem, Promise<unknown>>()
+
+function resolveFixtureValue(
+  fixture: FixtureItem,
+  context: TestContext & { [key: string]: any },
+  cleanupFnArray: (() => void | Promise<void>)[],
+) {
+  if (!fixture.isFn) {
+    return fixture.value
+  }
+
+  if (!fixture.scope || fixture.scope === 'test') {
+    return resolveFixtureFunction(
+      fixture.value,
+      context,
+      cleanupFnArray,
+    )
+  }
+
+  const fileContext = context.task.file.context
+
+  if (fixture.prop in fileContext) {
+    return fileContext[fixture.prop]
+  }
+
+  // in case the test runs in parallel
+  if (fileFixturePromise.has(fixture)) {
+    return fileFixturePromise.get(fixture)!
+  }
+
+  if (!cleanupFnArrayMap.has(fileContext)) {
+    cleanupFnArrayMap.set(fileContext, [])
+  }
+  const cleanupFnFileArray = cleanupFnArrayMap.get(fileContext)!
+
+  const promise = resolveFixtureFunction(
+    fixture.value,
+    fileContext,
+    cleanupFnFileArray,
+  ).then((value) => {
+    fileContext[fixture.prop] = value
+    fileFixturePromise.delete(fixture)
+    return value
+  })
+
+  fileFixturePromise.set(fixture, promise)
+  return promise
+}
+
 async function resolveFixtureFunction(
   fixtureFn: (
     context: unknown,
diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index e8828ceedca9..ab481f5aa97d 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -487,6 +487,9 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
     try {
       await callSuiteHook(suite, suite, 'afterAll', runner, [suite])
       await callCleanupHooks(beforeAllCleanups)
+      if (suite.file === suite) {
+        await callFixtureCleanup((suite as File).context)
+      }
     }
     catch (e) {
       failTask(suite.result, e, runner.config.diffOptions)
diff --git a/packages/runner/src/types/tasks.ts b/packages/runner/src/types/tasks.ts
index 79298dee7e2e..63d37d8948db 100644
--- a/packages/runner/src/types/tasks.ts
+++ b/packages/runner/src/types/tasks.ts
@@ -239,6 +239,8 @@ export interface File extends Suite {
    * @internal
    */
   local?: boolean
+  /** @internal */
+  context: Record<string, unknown>
 }
 
 export interface Test<ExtraContext = object> extends TaskPopulated {
@@ -479,12 +481,21 @@ export type { TestAPI as CustomAPI }
 export interface FixtureOptions {
   /**
    * Whether to automatically set up current fixture, even though it's not being used in tests.
+   * @default false
    */
   auto?: boolean
   /**
    * Indicated if the injected value from the config should be preferred over the fixture value
    */
   injected?: boolean
+  /**
+   * When should the fixture be set up.
+   * - **test**: fixture will be set up before ever test
+   * - **worker**: fixture will be set up once per worker
+   * - **file**: fixture will be set up once per file
+   * @default 'test'
+   */
+  scope?: 'test' | 'worker' | 'file'
 }
 
 export type Use<T> = (value: T) => Promise<void>
diff --git a/packages/runner/src/utils/collect.ts b/packages/runner/src/utils/collect.ts
index fb1a9544e0b5..b7eec84d6ba0 100644
--- a/packages/runner/src/utils/collect.ts
+++ b/packages/runner/src/utils/collect.ts
@@ -192,6 +192,7 @@ export function createFileTask(
     projectName,
     file: undefined!,
     pool,
+    context: Object.create(null),
   }
   file.file = file
   return file

From 988c4091fa7fe7bbe82d3f6ae82e6f9e7c83cd55 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Thu, 3 Apr 2025 17:05:18 +0200
Subject: [PATCH 04/30] chore: undo

---
 packages/runner/src/collect.ts | 30 ++----------------------------
 1 file changed, 2 insertions(+), 28 deletions(-)

diff --git a/packages/runner/src/collect.ts b/packages/runner/src/collect.ts
index 146bc7c5d8e1..8e2a2a8d1cdd 100644
--- a/packages/runner/src/collect.ts
+++ b/packages/runner/src/collect.ts
@@ -1,10 +1,9 @@
-import type { FixtureItem } from './fixture'
 import type { FileSpecification, VitestRunner } from './types/runner'
-import type { File, SuiteHooks, Task } from './types/tasks'
+import type { File, SuiteHooks } from './types/tasks'
 import { toArray } from '@vitest/utils'
 import { processError } from '@vitest/utils/error'
 import { collectorContext } from './context'
-import { getHooks, getTestFixture, setHooks, setTestFixture } from './map'
+import { getHooks, setHooks } from './map'
 import { runSetupFiles } from './setup'
 import {
   clearCollectorContext,
@@ -105,36 +104,11 @@ export async function collectTests(
     }
 
     files.push(file)
-
-    // TODO: any
-    setTestFixture(file.context as any, getFileFixtires(file))
   }
 
   return files
 }
 
-function getFileFixtires(file: File): FixtureItem[] {
-  const fixtures = new Set<FixtureItem>()
-  function traverse(children: Task[]) {
-    for (const child of children) {
-      if (child.type === 'test') {
-        const childFixtures = getTestFixture(child.context) || []
-        for (const fixture of childFixtures) {
-          // TODO: what if overriden?
-          if (fixture.scope === 'file' && !fixtures.has(fixture)) {
-            fixtures.add(fixture)
-          }
-        }
-      }
-      else {
-        traverse(child.tasks)
-      }
-    }
-  }
-  traverse(file.tasks)
-  return Array.from(fixtures)
-}
-
 function mergeHooks(baseHooks: SuiteHooks, hooks: SuiteHooks): SuiteHooks {
   for (const _key in hooks) {
     const key = _key as keyof SuiteHooks

From 9df74d435dfe9c98c2df12d744a10ded6300096d Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Thu, 3 Apr 2025 17:24:49 +0200
Subject: [PATCH 05/30] chore: validation

---
 packages/runner/src/fixture.ts | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/packages/runner/src/fixture.ts b/packages/runner/src/fixture.ts
index 0b61e297638e..013a35410c54 100644
--- a/packages/runner/src/fixture.ts
+++ b/packages/runner/src/fixture.ts
@@ -5,6 +5,7 @@ import { getTestFixture } from './map'
 export interface FixtureItem extends FixtureOptions {
   prop: string
   value: any
+  scope: 'test' | 'file' | 'worker'
   /**
    * Indicates whether the fixture is a function
    */
@@ -64,6 +65,7 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
           : userValue
       }
 
+      fixtureItem.scope = fixtureItem.scope || 'test'
       fixtureItem.prop = prop
       fixtureItem.isFn = typeof fixtureItem.value === 'function'
       return fixtureItem
@@ -86,6 +88,13 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
           ({ prop }) => prop !== fixture.prop && usedProps.includes(prop),
         )
       }
+      if (fixture.scope !== 'test') {
+        fixture.deps?.forEach((dep) => {
+          if (dep.isFn && dep.scope !== fixture.scope) {
+            throw new Error(`cannot use ${dep.scope} fixture "${dep.prop}" inside ${fixture.scope} fixture "${fixture.prop}"`)
+          }
+        })
+      }
     }
   })
 
@@ -180,7 +189,10 @@ function resolveFixtureValue(
   context: TestContext & { [key: string]: any },
   cleanupFnArray: (() => void | Promise<void>)[],
 ) {
+  const fileContext = context.task.file.context
+
   if (!fixture.isFn) {
+    fileContext[fixture.prop] ??= fixture.value
     return fixture.value
   }
 
@@ -192,8 +204,6 @@ function resolveFixtureValue(
     )
   }
 
-  const fileContext = context.task.file.context
-
   if (fixture.prop in fileContext) {
     return fileContext[fixture.prop]
   }

From a5f972340d3bca150f4b509c259b1b0203f82b04 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Fri, 4 Apr 2025 11:31:04 +0200
Subject: [PATCH 06/30] fix: validate worker/file scopes

---
 packages/runner/src/fixture.ts | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/packages/runner/src/fixture.ts b/packages/runner/src/fixture.ts
index 013a35410c54..ef704920cfc6 100644
--- a/packages/runner/src/fixture.ts
+++ b/packages/runner/src/fixture.ts
@@ -88,11 +88,23 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
           ({ prop }) => prop !== fixture.prop && usedProps.includes(prop),
         )
       }
+      // test can access anything, so we ignore it
       if (fixture.scope !== 'test') {
         fixture.deps?.forEach((dep) => {
-          if (dep.isFn && dep.scope !== fixture.scope) {
-            throw new Error(`cannot use ${dep.scope} fixture "${dep.prop}" inside ${fixture.scope} fixture "${fixture.prop}"`)
+          if (!dep.isFn) {
+            // non fn fixtures are always resolved an available to anyone
+            return
           }
+          // worker scope can only import from worker scope
+          if (fixture.scope === 'worker' && dep.scope === 'worker') {
+            return
+          }
+          // file scope an import from file and worker scopes
+          if (fixture.scope === 'file' && dep.scope !== 'test') {
+            return
+          }
+
+          throw new SyntaxError(`cannot use ${dep.scope} fixture "${dep.prop}" inside ${fixture.scope} fixture "${fixture.prop}"`)
         })
       }
     }

From 9ee54f3e0ed01692e8d02ca375baf2632fe26fae Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Mon, 7 Apr 2025 15:08:41 +0200
Subject: [PATCH 07/30] chore: draft worker context

---
 packages/runner/src/fixture.ts              | 53 ++++++++++++++-------
 packages/runner/src/hooks.ts                |  6 ++-
 packages/runner/src/suite.ts                |  2 +-
 packages/runner/src/types/runner.ts         | 17 ++++---
 packages/vitest/src/runtime/runners/test.ts | 13 +++--
 packages/vitest/src/types/global.ts         |  2 +
 6 files changed, 64 insertions(+), 29 deletions(-)

diff --git a/packages/runner/src/fixture.ts b/packages/runner/src/fixture.ts
index ef704920cfc6..d3c4ad994ef4 100644
--- a/packages/runner/src/fixture.ts
+++ b/packages/runner/src/fixture.ts
@@ -1,3 +1,4 @@
+import type { VitestRunner } from './types'
 import type { FixtureOptions, TestContext } from './types/tasks'
 import { createDefer, isObject } from '@vitest/utils'
 import { getTestFixture } from './map'
@@ -104,7 +105,7 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
             return
           }
 
-          throw new SyntaxError(`cannot use ${dep.scope} fixture "${dep.prop}" inside ${fixture.scope} fixture "${fixture.prop}"`)
+          throw new SyntaxError(`cannot use the ${dep.scope} fixture "${dep.prop}" inside the ${fixture.scope} fixture "${fixture.prop}"`)
         })
       }
     }
@@ -127,7 +128,7 @@ export async function callFixtureCleanup(context: object): Promise<void> {
   cleanupFnArrayMap.delete(context)
 }
 
-export function withFixtures(fn: Function, testContext?: TestContext) {
+export function withFixtures(runner: VitestRunner, fn: Function, testContext?: TestContext) {
   return (hookContext?: TestContext): any => {
     const context: (TestContext & { [key: string]: any }) | undefined
       = hookContext || testContext
@@ -175,6 +176,7 @@ export function withFixtures(fn: Function, testContext?: TestContext) {
         }
 
         const resolvedValue = await resolveFixtureValue(
+          runner,
           fixture,
           context!,
           cleanupFnArray,
@@ -182,7 +184,7 @@ export function withFixtures(fn: Function, testContext?: TestContext) {
         context![fixture.prop] = resolvedValue
         fixtureValueMap.set(fixture, resolvedValue)
 
-        if (!fixture.scope || fixture.scope === 'test') {
+        if (fixture.scope === 'test') {
           cleanupFnArray.unshift(() => {
             fixtureValueMap.delete(fixture)
           })
@@ -194,21 +196,26 @@ export function withFixtures(fn: Function, testContext?: TestContext) {
   }
 }
 
-const fileFixturePromise = new WeakMap<FixtureItem, Promise<unknown>>()
+const globalFixturePromise = new WeakMap<FixtureItem, Promise<unknown>>()
 
 function resolveFixtureValue(
+  runner: VitestRunner,
   fixture: FixtureItem,
   context: TestContext & { [key: string]: any },
   cleanupFnArray: (() => void | Promise<void>)[],
 ) {
   const fileContext = context.task.file.context
+  const workerContext = runner.getWorkerContext?.()
 
   if (!fixture.isFn) {
     fileContext[fixture.prop] ??= fixture.value
+    if (workerContext) {
+      workerContext[fixture.prop] ??= fixture.value
+    }
     return fixture.value
   }
 
-  if (!fixture.scope || fixture.scope === 'test') {
+  if (fixture.scope === 'test') {
     return resolveFixtureFunction(
       fixture.value,
       context,
@@ -216,31 +223,43 @@ function resolveFixtureValue(
     )
   }
 
-  if (fixture.prop in fileContext) {
-    return fileContext[fixture.prop]
+  // in case the test runs in parallel
+  if (globalFixturePromise.has(fixture)) {
+    return globalFixturePromise.get(fixture)!
   }
 
-  // in case the test runs in parallel
-  if (fileFixturePromise.has(fixture)) {
-    return fileFixturePromise.get(fixture)!
+  let fixtureContext: Record<string, unknown>
+
+  if (fixture.scope === 'worker') {
+    if (!workerContext) {
+      throw new TypeError('[@vitets/runner] The worker context is not available by the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.')
+    }
+    fixtureContext = workerContext
+  }
+  else {
+    fixtureContext = fileContext
+  }
+
+  if (fixture.prop in fixtureContext) {
+    return fixtureContext[fixture.prop]
   }
 
-  if (!cleanupFnArrayMap.has(fileContext)) {
-    cleanupFnArrayMap.set(fileContext, [])
+  if (!cleanupFnArrayMap.has(fixtureContext)) {
+    cleanupFnArrayMap.set(fixtureContext, [])
   }
-  const cleanupFnFileArray = cleanupFnArrayMap.get(fileContext)!
+  const cleanupFnFileArray = cleanupFnArrayMap.get(fixtureContext)!
 
   const promise = resolveFixtureFunction(
     fixture.value,
-    fileContext,
+    fixtureContext,
     cleanupFnFileArray,
   ).then((value) => {
-    fileContext[fixture.prop] = value
-    fileFixturePromise.delete(fixture)
+    fixtureContext[fixture.prop] = value
+    globalFixturePromise.delete(fixture)
     return value
   })
 
-  fileFixturePromise.set(fixture, promise)
+  globalFixturePromise.set(fixture, promise)
   return promise
 }
 
diff --git a/packages/runner/src/hooks.ts b/packages/runner/src/hooks.ts
index 9740240906fc..59de863c2e80 100644
--- a/packages/runner/src/hooks.ts
+++ b/packages/runner/src/hooks.ts
@@ -128,11 +128,12 @@ export function beforeEach<ExtraContext = object>(
 ): void {
   assertTypes(fn, '"beforeEach" callback', ['function'])
   const stackTraceError = new Error('STACK_TRACE_ERROR')
+  const runner = getRunner()
   return getCurrentSuite<ExtraContext>().on(
     'beforeEach',
     Object.assign(
       withTimeout(
-        withFixtures(fn),
+        withFixtures(runner, fn),
         timeout ?? getDefaultHookTimeout(),
         true,
         stackTraceError,
@@ -167,10 +168,11 @@ export function afterEach<ExtraContext = object>(
   timeout?: number,
 ): void {
   assertTypes(fn, '"afterEach" callback', ['function'])
+  const runner = getRunner()
   return getCurrentSuite<ExtraContext>().on(
     'afterEach',
     withTimeout(
-      withFixtures(fn),
+      withFixtures(runner, fn),
       timeout ?? getDefaultHookTimeout(),
       true,
       new Error('STACK_TRACE_ERROR'),
diff --git a/packages/runner/src/suite.ts b/packages/runner/src/suite.ts
index 2b53016623f0..c09ed8950f39 100644
--- a/packages/runner/src/suite.ts
+++ b/packages/runner/src/suite.ts
@@ -346,7 +346,7 @@ function createSuiteCollector(
       setFn(
         task,
         withTimeout(
-          withAwaitAsyncAssertions(withFixtures(handler, context), task),
+          withAwaitAsyncAssertions(withFixtures(runner, handler, context), task),
           timeout,
         ),
       )
diff --git a/packages/runner/src/types/runner.ts b/packages/runner/src/types/runner.ts
index 81bd8d73b094..e98befa64268 100644
--- a/packages/runner/src/types/runner.ts
+++ b/packages/runner/src/types/runner.ts
@@ -4,7 +4,6 @@ import type {
   SequenceHooks,
   SequenceSetupFiles,
   Suite,
-  Task,
   TaskEventPack,
   TaskResultPack,
   Test,
@@ -82,12 +81,12 @@ export interface VitestRunner {
   /**
    * Called before running a single test. Doesn't have "result" yet.
    */
-  onBeforeRunTask?: (test: Task) => unknown
+  onBeforeRunTask?: (test: Test) => unknown
   /**
    * Called before actually running the test function. Already has "result" with "state" and "startTime".
    */
   onBeforeTryTask?: (
-    test: Task,
+    test: Test,
     options: { retry: number; repeats: number }
   ) => unknown
   /**
@@ -97,12 +96,12 @@ export interface VitestRunner {
   /**
    * Called after result and state are set.
    */
-  onAfterRunTask?: (test: Task) => unknown
+  onAfterRunTask?: (test: Test) => unknown
   /**
    * Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
    */
   onAfterTryTask?: (
-    test: Task,
+    test: Test,
     options: { retry: number; repeats: number }
   ) => unknown
 
@@ -124,7 +123,7 @@ export interface VitestRunner {
    * If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
    * "before" and "after" hooks will not be ignored.
    */
-  runTask?: (test: Task) => Promise<void>
+  runTask?: (test: Test) => Promise<void>
 
   /**
    * Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
@@ -163,6 +162,12 @@ export interface VitestRunner {
    */
   pool?: string
 
+  /**
+   * Return the worker context for fixutres specified with `scope: 'worker'`
+   */
+  getWorkerContext?: () => Record<string, unknown>
+  onCleanupWorkerContext?: (cleanup: () => unknown) => void
+
   /** @private */
   _currentTaskStartTime?: number
   /** @private */
diff --git a/packages/vitest/src/runtime/runners/test.ts b/packages/vitest/src/runtime/runners/test.ts
index d48adec04017..fdd4b6e6af9d 100644
--- a/packages/vitest/src/runtime/runners/test.ts
+++ b/packages/vitest/src/runtime/runners/test.ts
@@ -4,6 +4,7 @@ import type {
   File,
   Suite,
   Task,
+  Test,
   TestContext,
   VitestRunner,
   VitestRunnerImportSource,
@@ -19,6 +20,9 @@ import { vi } from '../../integrations/vi'
 import { rpc } from '../rpc'
 import { getWorkerState } from '../utils'
 
+// worker context is shared between all tests
+const workerContext = Object.create(null)
+
 export class VitestTestRunner implements VitestRunner {
   private snapshotClient = getSnapshotClient()
   private workerState = getWorkerState()
@@ -47,6 +51,10 @@ export class VitestTestRunner implements VitestRunner {
     this.workerState.current = undefined
   }
 
+  getWorkerContext(): Record<string, unknown> {
+    return workerContext
+  }
+
   async onAfterRunSuite(suite: Suite): Promise<void> {
     if (this.config.logHeapUsage && typeof process !== 'undefined') {
       suite.result!.heap = process.memoryUsage().heapUsed
@@ -132,7 +140,7 @@ export class VitestTestRunner implements VitestRunner {
     )
   }
 
-  onAfterTryTask(test: Task): void {
+  onAfterTryTask(test: Test): void {
     const {
       assertionCalls,
       expectedAssertionsNumber,
@@ -140,8 +148,7 @@ export class VitestTestRunner implements VitestRunner {
       isExpectingAssertions,
       isExpectingAssertionsError,
     }
-      // @ts-expect-error _local is untyped
-      = 'context' in test && test.context._local
+      = test.context._local
         ? test.context.expect.getState()
         : getState((globalThis as any)[GLOBAL_EXPECT])
     if (
diff --git a/packages/vitest/src/types/global.ts b/packages/vitest/src/types/global.ts
index 1b039f61e0fa..91dfa6440960 100644
--- a/packages/vitest/src/types/global.ts
+++ b/packages/vitest/src/types/global.ts
@@ -107,6 +107,8 @@ declare module '@vitest/expect' {
 declare module '@vitest/runner' {
   interface TestContext {
     expect: ExpectStatic
+    /** @internal */
+    _local: boolean
   }
 
   interface TaskMeta {

From 3f5912b7582a8963b2bbcc290754df8c6a006953 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Mon, 5 May 2025 19:48:59 +0200
Subject: [PATCH 08/30] chore: types

---
 .../components/views/ViewReport.spec.ts       |  3 +
 packages/vitest/src/typecheck/collect.ts      |  1 +
 .../fixtures/custom-pool/pool/custom-pool.ts  | 24 ++-----
 test/reporters/src/data.ts                    | 68 ++++++++-----------
 test/reporters/tests/junit.test.ts            | 14 +---
 5 files changed, 41 insertions(+), 69 deletions(-)

diff --git a/packages/ui/client/components/views/ViewReport.spec.ts b/packages/ui/client/components/views/ViewReport.spec.ts
index 8c8c55b05d87..1137b6aa13be 100644
--- a/packages/ui/client/components/views/ViewReport.spec.ts
+++ b/packages/ui/client/components/views/ViewReport.spec.ts
@@ -56,6 +56,7 @@ const fileWithTextStacks: File = {
   tasks: [],
   projectName: '',
   file: null!,
+  context: {},
 }
 fileWithTextStacks.file = fileWithTextStacks
 
@@ -113,6 +114,7 @@ describe('ViewReport', () => {
       tasks: [],
       projectName: '',
       file: null!,
+      context: {},
     }
     file.file = file
     const container = render(ViewReport, {
@@ -171,6 +173,7 @@ describe('ViewReport', () => {
       tasks: [],
       projectName: '',
       file: null!,
+      context: {},
     }
     file.file = file
     const container = render(ViewReport, {
diff --git a/packages/vitest/src/typecheck/collect.ts b/packages/vitest/src/typecheck/collect.ts
index 533d8ae50c4b..5946f332c6ac 100644
--- a/packages/vitest/src/typecheck/collect.ts
+++ b/packages/vitest/src/typecheck/collect.ts
@@ -67,6 +67,7 @@ export async function collectTests(
     projectName,
     meta: { typecheck: true },
     file: null!,
+    context: {},
   }
   file.file = file
   const definitions: LocalCallDefinition[] = []
diff --git a/test/cli/fixtures/custom-pool/pool/custom-pool.ts b/test/cli/fixtures/custom-pool/pool/custom-pool.ts
index 391a4e4ac689..294f2ab714a7 100644
--- a/test/cli/fixtures/custom-pool/pool/custom-pool.ts
+++ b/test/cli/fixtures/custom-pool/pool/custom-pool.ts
@@ -7,8 +7,7 @@ import type {
   RunnerTask
 } from 'vitest'
 import type { ProcessPool, Vitest } from 'vitest/node'
-import { createMethodsRPC } from 'vitest/node'
-import { generateFileHash } from '@vitest/runner/utils'
+import { createFileTask, generateFileHash } from '@vitest/runner/utils'
 import { normalize, relative } from 'pathe'
 
 export default (vitest: Vitest): ProcessPool => {
@@ -24,22 +23,11 @@ export default (vitest: Vitest): ProcessPool => {
       for (const [project, file] of specs) {
         vitest.state.clearFiles(project)
         vitest.logger.console.warn('[pool] running tests for', project.name, 'in', normalize(file).toLowerCase().replace(normalize(process.cwd()).toLowerCase(), ''))
-        const path = relative(project.config.root, file)
-        const taskFile: RunnerTestFile = {
-          id: generateFileHash(path, project.config.name),
-          name: path,
-          mode: 'run',
-          meta: {},
-          projectName: project.name,
-          filepath: file,
-          type: 'suite',
-          tasks: [],
-          result: {
-            state: 'pass',
-          },
-          file: null!,
-        }
-        taskFile.file = taskFile
+        const taskFile = createFileTask(
+          file,
+          project.config.root,
+          project.name,
+        )
         const taskTest: RunnerTestCase = {
           type: 'test',
           name: 'custom test',
diff --git a/test/reporters/src/data.ts b/test/reporters/src/data.ts
index b946f56fe464..7b80dd2aa676 100644
--- a/test/reporters/src/data.ts
+++ b/test/reporters/src/data.ts
@@ -1,21 +1,19 @@
-import type { ErrorWithDiff, File, Suite, Task } from 'vitest'
+import type { ErrorWithDiff, Suite, Task } from 'vitest'
+import { createFileTask } from '@vitest/runner/utils'
 
-const file: File = {
-  id: '1223128da3',
-  name: 'test/core/test/basic.test.ts',
-  type: 'suite',
-  meta: {},
-  mode: 'run',
-  filepath: '/vitest/test/core/test/basic.test.ts',
-  result: { state: 'fail', duration: 145.99284195899963 },
-  tasks: [],
-  projectName: '',
-  file: null!,
+const file = createFileTask(
+  '/vitest/test/core/test/basic.test.ts',
+  '/vitest/test/core/test',
+  '',
+)
+file.mode = 'run'
+file.result = {
+  state: 'fail',
+  duration: 145.99284195899963,
 }
-file.file = file
 
 const suite: Suite = {
-  id: '1223128da3_0',
+  id: `${file.id}_0`,
   type: 'suite',
   name: 'suite',
   mode: 'run',
@@ -25,23 +23,15 @@ const suite: Suite = {
   tasks: [],
 }
 
-const passedFile: File = {
-  id: '1223128da3',
-  name: 'basic.test.ts',
-  type: 'suite',
-  suite,
-  meta: {},
-  mode: 'run',
-  filepath: '/vitest/test/core/test/basic.test.ts',
-  result: { state: 'pass', duration: 145.99284195899963 },
-  tasks: [
-  ],
-  projectName: '',
-  file: null!,
-}
-passedFile.file = passedFile
+const passedFile = createFileTask(
+  '/vitest/test/core/test/basic.test.ts',
+  '/vitest/test/core/test',
+  '',
+)
+passedFile.mode = 'run'
+passedFile.result = { state: 'pass', duration: 145.99284195899963 }
 passedFile.tasks.push({
-  id: '1223128da3_0_0',
+  id: `${file.id}_1`,
   type: 'test',
   name: 'Math.sqrt()',
   mode: 'run',
@@ -79,7 +69,7 @@ error.stack = 'AssertionError: expected 2.23606797749979 to equal 2\n'
 
 const tasks: Task[] = [
   {
-    id: '1223128da3_0_0',
+    id: `${suite.id}_0`,
     type: 'test',
     name: 'Math.sqrt()',
     mode: 'run',
@@ -100,7 +90,7 @@ const tasks: Task[] = [
     context: null as any,
   },
   {
-    id: '1223128da3_0_1',
+    id: `${suite.id}_1`,
     type: 'test',
     name: 'JSON',
     mode: 'run',
@@ -113,7 +103,7 @@ const tasks: Task[] = [
     context: null as any,
   },
   {
-    id: '1223128da3_0_3',
+    id: `${suite.id}_3`,
     type: 'test',
     name: 'async with timeout',
     mode: 'skip',
@@ -126,7 +116,7 @@ const tasks: Task[] = [
     context: null as any,
   },
   {
-    id: '1223128da3_0_4',
+    id: `${suite.id}_4`,
     type: 'test',
     name: 'timeout',
     mode: 'run',
@@ -139,7 +129,7 @@ const tasks: Task[] = [
     context: null as any,
   },
   {
-    id: '1223128da3_0_5',
+    id: `${suite.id}_5`,
     type: 'test',
     name: 'callback setup success ',
     mode: 'run',
@@ -152,7 +142,7 @@ const tasks: Task[] = [
     context: null as any,
   },
   {
-    id: '1223128da3_0_6',
+    id: `${suite.id}_6`,
     type: 'test',
     name: 'callback test success ',
     mode: 'run',
@@ -165,7 +155,7 @@ const tasks: Task[] = [
     context: null as any,
   },
   {
-    id: '1223128da3_0_7',
+    id: `${suite.id}_7`,
     type: 'test',
     name: 'callback setup success done(false)',
     mode: 'run',
@@ -178,7 +168,7 @@ const tasks: Task[] = [
     context: null as any,
   },
   {
-    id: '1223128da3_0_8',
+    id: `${suite.id}_8`,
     type: 'test',
     name: 'callback test success done(false)',
     mode: 'run',
@@ -199,7 +189,7 @@ const tasks: Task[] = [
     ],
   },
   {
-    id: '1223128da3_0_9',
+    id: `${suite.id}_9`,
     type: 'test',
     name: 'todo test',
     mode: 'todo',
diff --git a/test/reporters/tests/junit.test.ts b/test/reporters/tests/junit.test.ts
index dd5310b055fe..0729187ef958 100644
--- a/test/reporters/tests/junit.test.ts
+++ b/test/reporters/tests/junit.test.ts
@@ -1,4 +1,5 @@
 import type { File, Suite, Task, TaskResult } from 'vitest'
+import { createFileTask } from '@vitest/runner/utils'
 import { resolve } from 'pathe'
 import { expect, test } from 'vitest'
 import { getDuration } from '../../../packages/vitest/src/node/reporters/junit'
@@ -8,18 +9,7 @@ const root = resolve(__dirname, '../fixtures')
 
 test('calc the duration used by junit', () => {
   const result: TaskResult = { state: 'pass', duration: 0 }
-  const file: File = {
-    id: '1',
-    filepath: 'test.ts',
-    file: null!,
-    projectName: '',
-    type: 'suite',
-    tasks: [],
-    name: 'test.ts',
-    mode: 'run',
-    meta: {},
-  }
-  file.file = file
+  const file: File = createFileTask('/test.ts', '/', 'test')
   const suite: Suite = {
     id: '1_0',
     type: 'suite',

From 5fb4a2d95f1ef4bc577f9ac8d65dda758815174b Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Tue, 6 May 2025 15:22:24 +0200
Subject: [PATCH 09/30] test: fix custom pool

---
 packages/browser/src/client/tester/runner.ts      | 4 ++--
 test/cli/fixtures/custom-pool/pool/custom-pool.ts | 5 ++++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/packages/browser/src/client/tester/runner.ts b/packages/browser/src/client/tester/runner.ts
index a877aad7789f..2741ad41a84d 100644
--- a/packages/browser/src/client/tester/runner.ts
+++ b/packages/browser/src/client/tester/runner.ts
@@ -1,4 +1,4 @@
-import type { CancelReason, File, Suite, Task, TaskEventPack, TaskResultPack, VitestRunner } from '@vitest/runner'
+import type { CancelReason, File, Suite, Task, TaskEventPack, TaskResultPack, Test, VitestRunner } from '@vitest/runner'
 import type { SerializedConfig, TestExecutionMethod, WorkerGlobalState } from 'vitest'
 import type { VitestExecutor } from 'vitest/execute'
 import type { VitestBrowserClientMocker } from './mocker'
@@ -54,7 +54,7 @@ export function createBrowserRunner(
       await super.onBeforeTryTask?.(...args)
     }
 
-    onAfterRunTask = async (task: Task) => {
+    onAfterRunTask = async (task: Test) => {
       await super.onAfterRunTask?.(task)
 
       if (this.config.bail && task.result?.state === 'fail') {
diff --git a/test/cli/fixtures/custom-pool/pool/custom-pool.ts b/test/cli/fixtures/custom-pool/pool/custom-pool.ts
index 294f2ab714a7..d68efaa98af5 100644
--- a/test/cli/fixtures/custom-pool/pool/custom-pool.ts
+++ b/test/cli/fixtures/custom-pool/pool/custom-pool.ts
@@ -27,11 +27,14 @@ export default (vitest: Vitest): ProcessPool => {
           file,
           project.config.root,
           project.name,
+          'custom'
         )
+        taskFile.mode = 'run'
+        taskFile.result = { state: 'pass' }
         const taskTest: RunnerTestCase = {
           type: 'test',
           name: 'custom test',
-          id: 'custom-test',
+          id: `${taskFile.id}_0`,
           context: {} as any,
           suite: taskFile,
           mode: 'run',

From fda4b2e4a1c7f9f26144cb46573ddb48ed635c94 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Tue, 6 May 2025 15:39:00 +0200
Subject: [PATCH 10/30] refactor: move context to weakmap

---
 packages/runner/src/context.ts                    | 15 +++++++++++++++
 packages/runner/src/fixture.ts                    |  5 +++--
 packages/runner/src/run.ts                        |  5 +++--
 packages/runner/src/types/tasks.ts                |  2 --
 packages/runner/src/utils/collect.ts              |  3 ++-
 .../ui/client/components/views/ViewReport.spec.ts |  3 ---
 packages/vitest/src/typecheck/collect.ts          |  1 -
 7 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/packages/runner/src/context.ts b/packages/runner/src/context.ts
index 781050945ff1..5661d37ae93d 100644
--- a/packages/runner/src/context.ts
+++ b/packages/runner/src/context.ts
@@ -1,6 +1,7 @@
 import type { Awaitable } from '@vitest/utils'
 import type { VitestRunner } from './types/runner'
 import type {
+  File,
   RuntimeContext,
   SuiteCollector,
   Test,
@@ -194,3 +195,17 @@ function makeTimeoutError(isHook: boolean, timeout: number, stackTraceError?: Er
   }
   return error
 }
+
+const fileContexts = new WeakMap<File, Record<string, unknown>>()
+
+export function getFileContext(file: File): Record<string, unknown> {
+  const context = fileContexts.get(file)
+  if (!context) {
+    throw new Error(`Cannot find file context for ${file.name}`)
+  }
+  return context
+}
+
+export function setFileContext(file: File, context: Record<string, unknown>): void {
+  fileContexts.set(file, context)
+}
diff --git a/packages/runner/src/fixture.ts b/packages/runner/src/fixture.ts
index d9ade056ac83..8a59e1e15be4 100644
--- a/packages/runner/src/fixture.ts
+++ b/packages/runner/src/fixture.ts
@@ -1,6 +1,7 @@
 import type { VitestRunner } from './types'
 import type { FixtureOptions, TestContext } from './types/tasks'
 import { createDefer, isObject } from '@vitest/utils'
+import { getFileContext } from './context'
 import { getTestFixture } from './map'
 
 export interface FixtureItem extends FixtureOptions {
@@ -204,7 +205,7 @@ function resolveFixtureValue(
   context: TestContext & { [key: string]: any },
   cleanupFnArray: (() => void | Promise<void>)[],
 ) {
-  const fileContext = context.task.file.context
+  const fileContext = getFileContext(context.task.file)
   const workerContext = runner.getWorkerContext?.()
 
   if (!fixture.isFn) {
@@ -232,7 +233,7 @@ function resolveFixtureValue(
 
   if (fixture.scope === 'worker') {
     if (!workerContext) {
-      throw new TypeError('[@vitets/runner] The worker context is not available by the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.')
+      throw new TypeError('[@vitets/runner] The worker context is not available in the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.')
     }
     fixtureContext = workerContext
   }
diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index 12139e25f64d..602c620debb5 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -20,7 +20,7 @@ import type {
 import { shuffle } from '@vitest/utils'
 import { processError } from '@vitest/utils/error'
 import { collectTests } from './collect'
-import { abortContextSignal } from './context'
+import { abortContextSignal, getFileContext } from './context'
 import { PendingError, TestRunAbortError } from './errors'
 import { callFixtureCleanup } from './fixture'
 import { getBeforeHookCleanupCallback } from './hooks'
@@ -538,7 +538,8 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
       await callSuiteHook(suite, suite, 'afterAll', runner, [suite])
       await callCleanupHooks(runner, beforeAllCleanups)
       if (suite.file === suite) {
-        await callFixtureCleanup((suite as File).context)
+        const context = getFileContext(suite as File)
+        await callFixtureCleanup(context)
       }
     }
     catch (e) {
diff --git a/packages/runner/src/types/tasks.ts b/packages/runner/src/types/tasks.ts
index 1cc4ddff3971..14b164743243 100644
--- a/packages/runner/src/types/tasks.ts
+++ b/packages/runner/src/types/tasks.ts
@@ -239,8 +239,6 @@ export interface File extends Suite {
    * @internal
    */
   local?: boolean
-  /** @internal */
-  context: Record<string, unknown>
 }
 
 export interface Test<ExtraContext = object> extends TaskPopulated {
diff --git a/packages/runner/src/utils/collect.ts b/packages/runner/src/utils/collect.ts
index b7eec84d6ba0..3f7231a3a7f4 100644
--- a/packages/runner/src/utils/collect.ts
+++ b/packages/runner/src/utils/collect.ts
@@ -1,6 +1,7 @@
 import type { File, Suite, TaskBase } from '../types/tasks'
 import { processError } from '@vitest/utils/error'
 import { relative } from 'pathe'
+import { setFileContext } from '../context'
 
 /**
  * If any tasks been marked as `only`, mark all other tasks as `skip`.
@@ -192,9 +193,9 @@ export function createFileTask(
     projectName,
     file: undefined!,
     pool,
-    context: Object.create(null),
   }
   file.file = file
+  setFileContext(file, Object.create(null))
   return file
 }
 
diff --git a/packages/ui/client/components/views/ViewReport.spec.ts b/packages/ui/client/components/views/ViewReport.spec.ts
index 1137b6aa13be..8c8c55b05d87 100644
--- a/packages/ui/client/components/views/ViewReport.spec.ts
+++ b/packages/ui/client/components/views/ViewReport.spec.ts
@@ -56,7 +56,6 @@ const fileWithTextStacks: File = {
   tasks: [],
   projectName: '',
   file: null!,
-  context: {},
 }
 fileWithTextStacks.file = fileWithTextStacks
 
@@ -114,7 +113,6 @@ describe('ViewReport', () => {
       tasks: [],
       projectName: '',
       file: null!,
-      context: {},
     }
     file.file = file
     const container = render(ViewReport, {
@@ -173,7 +171,6 @@ describe('ViewReport', () => {
       tasks: [],
       projectName: '',
       file: null!,
-      context: {},
     }
     file.file = file
     const container = render(ViewReport, {
diff --git a/packages/vitest/src/typecheck/collect.ts b/packages/vitest/src/typecheck/collect.ts
index 5946f332c6ac..533d8ae50c4b 100644
--- a/packages/vitest/src/typecheck/collect.ts
+++ b/packages/vitest/src/typecheck/collect.ts
@@ -67,7 +67,6 @@ export async function collectTests(
     projectName,
     meta: { typecheck: true },
     file: null!,
-    context: {},
   }
   file.file = file
   const definitions: LocalCallDefinition[] = []

From 792ba8686d887581f4130147a1e44068794f295b Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Tue, 6 May 2025 16:52:28 +0200
Subject: [PATCH 11/30] chore: fix reporter output

---
 .../__snapshots__/reporters.spec.ts.snap      | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/test/reporters/tests/__snapshots__/reporters.spec.ts.snap b/test/reporters/tests/__snapshots__/reporters.spec.ts.snap
index c9965e6e9073..998fc0c125a8 100644
--- a/test/reporters/tests/__snapshots__/reporters.spec.ts.snap
+++ b/test/reporters/tests/__snapshots__/reporters.spec.ts.snap
@@ -993,7 +993,7 @@ exports[`json reporter with outputFile object in non-existing directory 2`] = `
 exports[`tap reporter 1`] = `
 "TAP version 13
 1..1
-not ok 1 - test/core/test/basic.test.ts # time=145.99ms {
+not ok 1 - basic.test.ts # time=145.99ms {
     1..1
     ok 1 - suite # time=1.90ms {
         1..9
@@ -1022,7 +1022,7 @@ not ok 1 - test/core/test/basic.test.ts # time=145.99ms {
 exports[`tap-flat reporter 1`] = `
 "TAP version 13
 1..9
-not ok 1 - test/core/test/basic.test.ts > suite > Math.sqrt() # time=1.44ms
+not ok 1 - basic.test.ts > suite > Math.sqrt() # time=1.44ms
     ---
     error:
         name: "AssertionError"
@@ -1031,13 +1031,13 @@ not ok 1 - test/core/test/basic.test.ts > suite > Math.sqrt() # time=1.44ms
     actual: "2.23606797749979"
     expected: "2"
     ...
-ok 2 - test/core/test/basic.test.ts > suite > JSON # time=1.02ms
-ok 3 - test/core/test/basic.test.ts > suite > async with timeout # SKIP
-ok 4 - test/core/test/basic.test.ts > suite > timeout # time=100.51ms
-ok 5 - test/core/test/basic.test.ts > suite > callback setup success  # time=20.18ms
-ok 6 - test/core/test/basic.test.ts > suite > callback test success  # time=0.33ms
-ok 7 - test/core/test/basic.test.ts > suite > callback setup success done(false) # time=19.74ms
-ok 8 - test/core/test/basic.test.ts > suite > callback test success done(false) # time=0.19ms
-ok 9 - test/core/test/basic.test.ts > suite > todo test # TODO
+ok 2 - basic.test.ts > suite > JSON # time=1.02ms
+ok 3 - basic.test.ts > suite > async with timeout # SKIP
+ok 4 - basic.test.ts > suite > timeout # time=100.51ms
+ok 5 - basic.test.ts > suite > callback setup success  # time=20.18ms
+ok 6 - basic.test.ts > suite > callback test success  # time=0.33ms
+ok 7 - basic.test.ts > suite > callback setup success done(false) # time=19.74ms
+ok 8 - basic.test.ts > suite > callback test success done(false) # time=0.19ms
+ok 9 - basic.test.ts > suite > todo test # TODO
 "
 `;

From 87829928556a0e5f1d7247022d3b48ea30d65120 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Wed, 7 May 2025 14:01:29 +0200
Subject: [PATCH 12/30] test: add initial tests

---
 packages/runner/src/types/tasks.ts    |   4 +-
 test/cli/test/scoped-fixtures.test.ts | 452 ++++++++++++++++++++++++++
 test/cli/vitest.config.ts             |   1 +
 test/test-utils/index.ts              |  37 ++-
 test/test-utils/typed-object.ts       |  31 ++
 5 files changed, 517 insertions(+), 8 deletions(-)
 create mode 100644 test/cli/test/scoped-fixtures.test.ts
 create mode 100644 test/test-utils/typed-object.ts

diff --git a/packages/runner/src/types/tasks.ts b/packages/runner/src/types/tasks.ts
index 14b164743243..9e9f71506772 100644
--- a/packages/runner/src/types/tasks.ts
+++ b/packages/runner/src/types/tasks.ts
@@ -488,9 +488,11 @@ export interface FixtureOptions {
   injected?: boolean
   /**
    * When should the fixture be set up.
-   * - **test**: fixture will be set up before ever test
+   * - **test**: fixture will be set up before every test
    * - **worker**: fixture will be set up once per worker
    * - **file**: fixture will be set up once per file
+   *
+   * **Warning:** The `vmThreads` and `vmForks` pools initiate worker fixtures once per test file.
    * @default 'test'
    */
   scope?: 'test' | 'worker' | 'file'
diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
new file mode 100644
index 000000000000..0a798701e2dd
--- /dev/null
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -0,0 +1,452 @@
+/// <reference types="vitest/globals" />
+
+import type { TestAPI } from 'vitest'
+import type { ViteUserConfig } from 'vitest/config'
+import type { TestFsStructure } from '../../test-utils'
+import { runInlineTests } from '../../test-utils'
+
+declare module 'vitest' {
+  interface TestContext {
+    file: string
+  }
+}
+
+test('test fixture cannot import from file fixture', async () => {
+  const { stderr } = await runInlineTests({
+    'basic.test.ts': () => {
+      const extendedTest = it.extend<{
+        file: string
+        local: string
+      }>({
+        local: ({}, use) => use('local'),
+        file: [
+          ({ local }, use) => use(local),
+          { scope: 'file' },
+        ],
+      })
+
+      extendedTest('not working', ({ file: _file }) => {})
+    },
+    'vitest.config.js': { test: { globals: true } },
+  })
+  expect(stderr).toContain('cannot use the test fixture "local" inside the file fixture "file"')
+})
+
+test('can import file fixture inside the local fixture', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(
+    ({ log }) => it.extend<{
+      file: string
+      local: string
+    }>({
+      local: async ({ file }, use) => {
+        log('init local')
+        await use(file)
+        log('teardown local')
+      },
+      file: [
+        async ({}, use) => {
+          log('init file')
+          await use('file')
+          log('teardown file')
+        },
+        { scope: 'file' },
+      ],
+    }),
+    {
+      'basic.test.ts': ({ extendedTest }) => {
+        extendedTest('test1', ({ local: _local }) => {})
+      },
+    },
+  )
+
+  expect(stderr).toBe('')
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init file | test1
+    >> fixture | init local | test1
+    >> fixture | teardown local | test1
+    >> fixture | teardown file | test1"
+  `)
+  expect(tests).toMatchInlineSnapshot(`" ✓ basic.test.ts > test1 <time>"`)
+})
+
+test.skip('can import worker fixture inside the local fixture', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(
+    ({ log }) => it.extend<{
+      worker: string
+      local: string
+    }>({
+      local: async ({ worker }, use) => {
+        log('init local')
+        await use(worker)
+        log('teardown local')
+      },
+      worker: [
+        async ({}, use) => {
+          log('init worker')
+          await use('worker')
+          log('teardown worker')
+        },
+        { scope: 'worker' },
+      ],
+    }),
+    {
+      'basic.test.ts': ({ extendedTest }) => {
+        extendedTest('test1', ({ local }) => {
+          expect(local).toBe('worker')
+        })
+      },
+    },
+  )
+
+  expect(stderr).toBe('')
+  // TODO: worker teardown is not called
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init worker | test1
+    >> fixture | init local | test1
+    >> fixture | teardown local | test1"
+  `)
+  expect(tests).toMatchInlineSnapshot(`" ✓ basic.test.ts > test1 <time>"`)
+})
+
+test('test fixture cannot import from worker fixture', async () => {
+  const { stderr } = await runInlineTests({
+    'basic.test.ts': () => {
+      const extendedTest = it.extend<{
+        worker: string
+        local: string
+      }>({
+        local: ({}, use) => use('local'),
+        worker: [
+          ({ local }, use) => use(local),
+          { scope: 'worker' },
+        ],
+      })
+
+      extendedTest('not working', ({ worker: _worker }) => {})
+    },
+    'vitest.config.js': { test: { globals: true } },
+  })
+  expect(stderr).toContain('cannot use the test fixture "local" inside the worker fixture "worker"')
+})
+
+test.skip('auto worker fixture is initialised always before the first test', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
+    worker: [
+      async ({}, use) => {
+        log('init file')
+        await use('worker')
+        log('teardown file')
+      },
+      { scope: 'worker', auto: true },
+    ],
+  }), {
+    'basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({}) => {})
+      extendedTest('test2', ({}) => {})
+      extendedTest('test3', ({ worker: _worker }) => {})
+      extendedTest('test4', ({}) => {})
+    },
+  })
+
+  expect(stderr).toBe('')
+  // TODO: teardown is not called
+  expect(fixtures).toMatchInlineSnapshot(`">> fixture | init file | test1"`)
+  expect(tests).toMatchInlineSnapshot(`
+    " ✓ basic.test.ts > test1 <time>
+     ✓ basic.test.ts > test2 <time>
+     ✓ basic.test.ts > test3 <time>
+     ✓ basic.test.ts > test4 <time>"
+  `)
+})
+
+test('worker fixture can import a static value from test fixture', async () => {
+  const { stderr, stdout } = await runInlineTests({
+    'basic.test.ts': () => {
+      const extendedTest = it.extend<{
+        worker: string
+        local: string
+      }>({
+        local: 'local',
+        worker: [
+          ({ local }, use) => use(local),
+          { scope: 'worker' },
+        ],
+      })
+
+      extendedTest('working', ({ worker, local }) => {
+        expect(worker).toBe(local)
+        expect(worker).toBe('local')
+      })
+    },
+    'vitest.config.js': { test: { globals: true } },
+  })
+  expect(stdout).toContain('basic.test.ts')
+  expect(stderr).toBe('')
+})
+
+test('file fixture can import a static value from test fixture', async () => {
+  const { stderr, stdout } = await runInlineTests({
+    'basic.test.ts': () => {
+      const extendedTest = it.extend<{
+        file: string
+        local: string
+      }>({
+        local: 'local',
+        file: [
+          ({ local }, use) => use(local),
+          { scope: 'file' },
+        ],
+      })
+
+      extendedTest('working', ({ file, local }) => {
+        expect(file).toBe(local)
+        expect(file).toBe('local')
+      })
+    },
+    'vitest.config.js': { test: { globals: true } },
+  })
+  expect(stdout).toContain('basic.test.ts')
+  expect(stderr).toBe('')
+})
+
+test.skip('worker fixtures are available in beforeEach and afterEach', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
+    worker: [
+      async ({}, use) => {
+        log('init worker')
+        await use('worker')
+        log('teardown worker')
+      },
+      { scope: 'worker' },
+    ],
+  }), {
+    'basic.test.ts': ({ extendedTest }) => {
+      beforeEach(({ file }) => {
+        console.log('>> fixture | beforeEach |', file)
+      })
+      afterEach(({ file }) => {
+        console.log('>> fixture | afterEach |', file)
+      })
+      extendedTest('test1', ({}) => {})
+      extendedTest('test2', ({}) => {})
+    },
+  })
+
+  expect(stderr).toBe('')
+  // TODO: teardown is not called
+  expect(fixtures).toMatchInlineSnapshot()
+  expect(tests).toMatchInlineSnapshot(`
+    " ✓ basic.test.ts > test1 <time>
+     ✓ basic.test.ts > test2 <time>"
+  `)
+})
+
+test('file fixtures are available in beforeEach and afterEach', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
+    file: string
+  }>({
+    file: [
+      async ({}, use) => {
+        log('init file')
+        await use('file')
+        log('teardown file')
+      },
+      { scope: 'file' },
+    ],
+  }), {
+    'basic.test.ts': ({ extendedTest }) => {
+      beforeEach(({ file }) => {
+        console.log('>> fixture | beforeEach |', file)
+      })
+      afterEach(({ file }) => {
+        console.log('>> fixture | afterEach |', file)
+      })
+      extendedTest('test1', ({}) => {})
+      extendedTest('test2', ({}) => {})
+    },
+  })
+
+  expect(stderr).toBe('')
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init file | test1
+    >> fixture | beforeEach | file
+    >> fixture | afterEach | file
+    >> fixture | beforeEach | file
+    >> fixture | afterEach | file
+    >> fixture | teardown file | test2"
+  `)
+  expect(tests).toMatchInlineSnapshot(`
+    " ✓ basic.test.ts > test1 <time>
+     ✓ basic.test.ts > test2 <time>"
+  `)
+})
+
+test('auto file fixture is initialised always before the first test', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
+    file: string
+  }>({
+    file: [
+      async ({}, use) => {
+        log('init file')
+        await use('file')
+        log('teardown file')
+      },
+      { scope: 'file', auto: true },
+    ],
+  }), {
+    'basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({}) => {})
+      extendedTest('test2', ({}) => {})
+      extendedTest('test3', ({ file: _file }) => {})
+      extendedTest('test4', ({}) => {})
+    },
+  })
+
+  expect(stderr).toBe('')
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init file | test1
+    >> fixture | teardown file | test4"
+  `)
+  expect(tests).toMatchInlineSnapshot(`
+    " ✓ basic.test.ts > test1 <time>
+     ✓ basic.test.ts > test2 <time>
+     ✓ basic.test.ts > test3 <time>
+     ✓ basic.test.ts > test4 <time>"
+  `)
+})
+
+test.for([
+  true,
+  false,
+])('file fixture is provided as a factory and is initialised once in all suites, teardown is called once per file (isolate %s)', async (isolate) => {
+  const { stderr, fixtures, tests } = await runFixtureTests<{ file: string }>(({ log }) => it.extend<{ file: string }>({
+    file: [
+      async ({}, use) => {
+        log('init file')
+        await use('file')
+        log('teardown file')
+      },
+      { scope: 'file' },
+    ],
+  }), {
+    'basic.test.js': ({ extendedTest }) => {
+      extendedTest('[first] test 1', ({ file }) => {
+        expect(file).toBe('file')
+      })
+
+      extendedTest('test 2', ({ file }) => {
+        expect(file).toBe('file')
+      })
+
+      extendedTest('test 3', ({ file }) => {
+        expect(file).toBe('file')
+      })
+
+      describe('suite 1', () => {
+        extendedTest('test 1 1', ({ file }) => {
+          expect(file).toBe('file')
+        })
+
+        extendedTest('test 1 2', ({ file }) => {
+          expect(file).toBe('file')
+        })
+
+        describe('suite 2', () => {
+          extendedTest('[first] test 1 2 1', ({ file }) => {
+            expect(file).toBe('file')
+          })
+        })
+      })
+    },
+
+    'second.test.js': ({ extendedTest }: { extendedTest: TestAPI<{ file: string }> }) => {
+      // doesn't access "file", not initialised
+      extendedTest('[second] test 0', ({}) => {})
+      // accesses "file" for the first time, initialised
+      extendedTest('[second] test 1', ({ file: _file }) => {})
+      extendedTest('[second] test 2', ({ file: _file }) => {})
+
+      describe('suite 1', () => {
+        extendedTest('[second] test 1', ({ file: _file }) => {})
+      })
+    },
+
+    'third.test.js': ({ extendedTest }: { extendedTest: TestAPI<{ file: string }> }) => {
+      // doesn't access "file" at all
+      extendedTest('[third] test 0', ({}) => {})
+    },
+
+    'vitest.config.js': {
+      test: {
+        globals: true,
+        isolate,
+        maxWorkers: 1,
+      },
+    },
+  })
+
+  expect(stderr).toBe('')
+
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init file | [first] test 1
+    >> fixture | teardown file | suite 1 > suite 2 > [first] test 1 2 1
+    >> fixture | init file | [second] test 1
+    >> fixture | teardown file | suite 1 > [second] test 1"
+  `)
+
+  expect(tests).toMatchInlineSnapshot(`
+    " ✓ basic.test.js > [first] test 1 <time>
+     ✓ basic.test.js > test 2 <time>
+     ✓ basic.test.js > test 3 <time>
+     ✓ basic.test.js > suite 1 > test 1 1 <time>
+     ✓ basic.test.js > suite 1 > test 1 2 <time>
+     ✓ basic.test.js > suite 1 > suite 2 > [first] test 1 2 1 <time>
+     ✓ second.test.js > [second] test 0 <time>
+     ✓ second.test.js > [second] test 1 <time>
+     ✓ second.test.js > [second] test 2 <time>
+     ✓ second.test.js > suite 1 > [second] test 1 <time>
+     ✓ third.test.js > [third] test 0 <time>"
+  `)
+})
+
+async function runFixtureTests<T>(
+  extendedTest: ({ log }: { log: typeof console.log }) => TestAPI<T>,
+  fs: Record<string, ((context: { extendedTest: TestAPI<T> }) => unknown) | ViteUserConfig>,
+) {
+  const { stderr, stdout } = await runInlineTests({
+    'test.js': `
+    export const extendedTest = (${extendedTest.toString()})({ log: (...args) => console.log('>> fixture |', ...args, '| ' + expect.getState().currentTestName) })
+    `,
+    'vitest.config.js': { test: { globals: true } },
+    ...Object.entries(fs).reduce((acc, [key, value]) => {
+      if (typeof value === 'object' && !Array.isArray(value)) {
+        acc[key] = value
+      }
+      if (typeof value === 'function') {
+        acc[key] = [value, { imports: { './test.js': ['extendedTest'] } }]
+      }
+      return acc
+    }, {} as TestFsStructure),
+  })
+
+  return {
+    stderr,
+    fixtures: getFixtureLogs(stdout),
+    tests: getSuccessTests(stdout),
+  }
+}
+
+function getSuccessTests(stdout: string) {
+  return stdout
+    .split('\n')
+    .filter(f => f.startsWith(' ✓ '))
+    .map(f => f.replace(/\dms/, '<time>'))
+    .join('\n')
+}
+
+function getFixtureLogs(stdout: string) {
+  return stdout
+    .split('\n')
+    .filter(f => f.startsWith('>> fixture |'))
+    .join('\n')
+}
diff --git a/test/cli/vitest.config.ts b/test/cli/vitest.config.ts
index 181d8e31ea81..0f74fd2bd40a 100644
--- a/test/cli/vitest.config.ts
+++ b/test/cli/vitest.config.ts
@@ -5,6 +5,7 @@ export default defineConfig({
     include: ['test/**.test.ts'],
     reporters: ['verbose'],
     testTimeout: 60_000,
+    globals: true,
     poolOptions: {
       forks: {
         singleFork: true,
diff --git a/test/test-utils/index.ts b/test/test-utils/index.ts
index ecc080ce3102..d45b12f97ace 100644
--- a/test/test-utils/index.ts
+++ b/test/test-utils/index.ts
@@ -271,20 +271,43 @@ export function resolvePath(baseUrl: string, path: string) {
   return resolve(dirname(filename), path)
 }
 
-export type TestFsStructure = Record<string, string | ViteUserConfig | WorkspaceProjectConfiguration[]>
+export type TestFsStructure = Record<
+  string,
+  | string
+  | ViteUserConfig
+  | WorkspaceProjectConfiguration[]
+  | ((...args: any[]) => unknown)
+  | [(...args: any[]) => unknown, { exports?: string[]; imports?: Record<string, string[]> }]
+>
+
+function getGeneratedFileContent(content: TestFsStructure[string]) {
+  if (typeof content === 'string') {
+    return content
+  }
+  if (typeof content === 'function') {
+    return `await (${content})()`
+  }
+  if (Array.isArray(content) && typeof content[1] === 'object' && ('exports' in content[1] || 'imports' in content[1])) {
+    const imports = Object.entries(content[1].imports || [])
+    return `
+${imports.map(([path, is]) => `import { ${is.join(', ')} } from '${path}'`)}
+const results = await (${content[0]})({ ${imports.flatMap(([_, is]) => is).join(', ')} })
+${(content[1].exports || []).map(e => `export const ${e} = results["${e}"]`)}
+    `
+  }
+  return `export default ${JSON.stringify(content)}`
+}
 
-export function useFS(root: string, structure: TestFsStructure) {
+export function useFS<T extends TestFsStructure>(root: string, structure: T) {
   const files = new Set<string>()
   const hasConfig = Object.keys(structure).some(file => file.includes('.config.'))
   if (!hasConfig) {
-    structure['./vitest.config.js'] = {}
+    ;(structure as any)['./vitest.config.js'] = {}
   }
   for (const file in structure) {
     const filepath = resolve(root, file)
     files.add(filepath)
-    const content = typeof structure[file] === 'string'
-      ? structure[file]
-      : `export default ${JSON.stringify(structure[file])}`
+    const content = getGeneratedFileContent(structure[file])
     fs.mkdirSync(dirname(filepath), { recursive: true })
     fs.writeFileSync(filepath, String(content), 'utf-8')
   }
@@ -316,7 +339,7 @@ export function useFS(root: string, structure: TestFsStructure) {
 }
 
 export async function runInlineTests(
-  structure: Record<string, string | ViteUserConfig | WorkspaceProjectConfiguration[]>,
+  structure: TestFsStructure,
   config?: UserConfig,
   options?: VitestRunnerCLIOptions,
 ) {
diff --git a/test/test-utils/typed-object.ts b/test/test-utils/typed-object.ts
new file mode 100644
index 000000000000..78e18eca070e
--- /dev/null
+++ b/test/test-utils/typed-object.ts
@@ -0,0 +1,31 @@
+interface Getter<T> {
+  get: <K extends keyof T>(key: K) => T[K] extends (...args: any[]) => any ? ReturnType<T[K]> : T[K]
+}
+
+interface AsyncGetter<T> {
+  get: <K extends keyof T>(key: K) => Promise<T[K] extends (...args: any[]) => any ? ReturnType<T[K]> : T[K]>
+}
+
+type ObjectValue<T> = T extends (...args: any[]) => any ? ReturnType<T> : T
+
+type TypedObject<T extends Record<string, any>> = {
+  [K in keyof T]: T[K] extends (args: infer A) => any
+    ? A extends { get: any }
+      ? (args: AsyncGetter<Pick<T, Exclude<keyof T, K>>>) => Promise<ObjectValue<T[K]>>
+      : () => ObjectValue<T[K]>
+    : T[K]
+}
+
+export function createTypedObject<T extends Record<string, any>>(obj: TypedObject<T>): T {
+  return obj as T
+}
+
+// Example usage:
+const _example = createTypedObject({
+  key: () => true as const,
+  otherKey: async ({ get }) => {
+    const res = await get('key')
+    // res is typed as "true"
+    return res as true
+  },
+})

From a3d6453d3298c7c42f41e111f1a2f3a97fa006b1 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Wed, 7 May 2025 14:06:16 +0200
Subject: [PATCH 13/30] chore: delete

---
 test/test-utils/typed-object.ts | 31 -------------------------------
 1 file changed, 31 deletions(-)
 delete mode 100644 test/test-utils/typed-object.ts

diff --git a/test/test-utils/typed-object.ts b/test/test-utils/typed-object.ts
deleted file mode 100644
index 78e18eca070e..000000000000
--- a/test/test-utils/typed-object.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-interface Getter<T> {
-  get: <K extends keyof T>(key: K) => T[K] extends (...args: any[]) => any ? ReturnType<T[K]> : T[K]
-}
-
-interface AsyncGetter<T> {
-  get: <K extends keyof T>(key: K) => Promise<T[K] extends (...args: any[]) => any ? ReturnType<T[K]> : T[K]>
-}
-
-type ObjectValue<T> = T extends (...args: any[]) => any ? ReturnType<T> : T
-
-type TypedObject<T extends Record<string, any>> = {
-  [K in keyof T]: T[K] extends (args: infer A) => any
-    ? A extends { get: any }
-      ? (args: AsyncGetter<Pick<T, Exclude<keyof T, K>>>) => Promise<ObjectValue<T[K]>>
-      : () => ObjectValue<T[K]>
-    : T[K]
-}
-
-export function createTypedObject<T extends Record<string, any>>(obj: TypedObject<T>): T {
-  return obj as T
-}
-
-// Example usage:
-const _example = createTypedObject({
-  key: () => true as const,
-  otherKey: async ({ get }) => {
-    const res = await get('key')
-    // res is typed as "true"
-    return res as true
-  },
-})

From 2cc955786cb5f14530314849d894849de83364b6 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Fri, 9 May 2025 12:00:56 +0200
Subject: [PATCH 14/30] chore: try teardown

---
 packages/runner/src/run.ts                  | 12 +++
 packages/vitest/src/node/pools/forks.ts     | 21 ++++-
 packages/vitest/src/node/pools/threads.ts   | 11 ++-
 packages/vitest/src/node/pools/vmForks.ts   | 14 ++-
 packages/vitest/src/node/pools/vmThreads.ts |  5 +-
 packages/vitest/src/runtime/cleanup.ts      | 14 +++
 packages/vitest/src/runtime/runners/test.ts |  4 +
 packages/vitest/src/runtime/worker.ts       |  6 ++
 packages/vitest/src/types/worker.ts         |  1 +
 test/cli/test/scoped-fixtures.test.ts       | 98 ++++++++++-----------
 10 files changed, 129 insertions(+), 57 deletions(-)
 create mode 100644 packages/vitest/src/runtime/cleanup.ts

diff --git a/packages/runner/src/run.ts b/packages/runner/src/run.ts
index 602c620debb5..7d63bfef12cc 100644
--- a/packages/runner/src/run.ts
+++ b/packages/runner/src/run.ts
@@ -602,6 +602,8 @@ export async function runFiles(files: File[], runner: VitestRunner): Promise<voi
   }
 }
 
+const workerRunners = new WeakSet<VitestRunner>()
+
 export async function startTests(specs: string[] | FileSpecification[], runner: VitestRunner): Promise<File[]> {
   const cancel = runner.cancel?.bind(runner)
   // Ideally, we need to have an event listener for this, but only have a runner here.
@@ -615,6 +617,16 @@ export async function startTests(specs: string[] | FileSpecification[], runner:
     return cancel?.(reason)
   }
 
+  if (!workerRunners.has(runner)) {
+    runner.onCleanupWorkerContext?.(async () => {
+      const context = runner.getWorkerContext?.()
+      if (context) {
+        await callFixtureCleanup(context)
+      }
+    })
+    workerRunners.add(runner)
+  }
+
   try {
     const paths = specs.map(f => typeof f === 'string' ? f : f.filepath)
     await runner.onBeforeCollect?.(paths)
diff --git a/packages/vitest/src/node/pools/forks.ts b/packages/vitest/src/node/pools/forks.ts
index f0293256e1fc..e629e627b81d 100644
--- a/packages/vitest/src/node/pools/forks.ts
+++ b/packages/vitest/src/node/pools/forks.ts
@@ -42,7 +42,7 @@ function createChildProcessChannel(project: TestProject, collect = false) {
     },
   })
 
-  project.ctx.onCancel(reason => rpc.onCancel(reason))
+  project.vitest.onCancel(reason => rpc.onCancel(reason))
 
   return { channel, cleanup }
 }
@@ -228,6 +228,9 @@ export function createForksPool(
             await new Promise<void>(resolve =>
               pool.queueSize === 0 ? resolve() : pool.once('drain', resolve),
             )
+            if (pool.threads.length) {
+              await cleanupWorkers()
+            }
             await pool.recycleWorkers()
           }
         }
@@ -264,6 +267,7 @@ export function createForksPool(
 
           for (const files of Object.values(filesByOptions)) {
             // Always run environments isolated between each other
+            await cleanupWorkers()
             await pool.recycleWorkers()
 
             const filenames = files.map(f => f.file)
@@ -280,10 +284,23 @@ export function createForksPool(
     }
   }
 
+  async function cleanupWorkers() {
+    const emitter = new EventEmitter()
+    const events = { message: 'message', response: 'response' }
+    const channel: TinypoolChannel = {
+      onMessage: callback => emitter.on(events.message, callback),
+      postMessage: message => emitter.emit(events.response, message),
+    }
+    await pool.run({}, { name: 'cleanup', channel })
+  }
+
   return {
     name: 'forks',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
-    close: () => pool.destroy(),
+    close: async () => {
+      await cleanupWorkers()
+      await pool.destroy()
+    },
   }
 }
diff --git a/packages/vitest/src/node/pools/threads.ts b/packages/vitest/src/node/pools/threads.ts
index 9a8ae875cb6a..062579e339b3 100644
--- a/packages/vitest/src/node/pools/threads.ts
+++ b/packages/vitest/src/node/pools/threads.ts
@@ -224,6 +224,7 @@ export function createThreadsPool(
             await new Promise<void>(resolve =>
               pool.queueSize === 0 ? resolve() : pool.once('drain', resolve),
             )
+            await cleanupWorkers()
             await pool.recycleWorkers()
           }
         }
@@ -259,6 +260,7 @@ export function createThreadsPool(
           )
 
           for (const files of Object.values(filesByOptions)) {
+            await cleanupWorkers()
             // Always run environments isolated between each other
             await pool.recycleWorkers()
 
@@ -276,10 +278,17 @@ export function createThreadsPool(
     }
   }
 
+  async function cleanupWorkers() {
+    // await pool.run({}, { name: 'cleanup' })
+  }
+
   return {
     name: 'threads',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
-    close: () => pool.destroy(),
+    close: async () => {
+      await cleanupWorkers()
+      await pool.destroy()
+    },
   }
 }
diff --git a/packages/vitest/src/node/pools/vmForks.ts b/packages/vitest/src/node/pools/vmForks.ts
index 2b5934ff055d..ae6bef87095f 100644
--- a/packages/vitest/src/node/pools/vmForks.ts
+++ b/packages/vitest/src/node/pools/vmForks.ts
@@ -170,7 +170,7 @@ export function createVmForksPool(
           return configs.get(project)!
         }
 
-        const _config = project.getSerializableConfig()
+        const _config = project.serializedConfig
         const config = wrapSerializableConfig(_config)
 
         configs.set(project, config)
@@ -207,7 +207,17 @@ export function createVmForksPool(
     name: 'vmForks',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
-    close: () => pool.destroy(),
+    close: async () => {
+      const emitter = new EventEmitter()
+
+      const events = { message: 'message', response: 'response' }
+      const channel: TinypoolChannel = {
+        onMessage: callback => emitter.on(events.message, callback),
+        postMessage: message => emitter.emit(events.response, message),
+      }
+      await pool.run({}, { name: 'cleanup', channel })
+      await pool.destroy()
+    },
   }
 }
 
diff --git a/packages/vitest/src/node/pools/vmThreads.ts b/packages/vitest/src/node/pools/vmThreads.ts
index 72478992f2ea..f8d735550327 100644
--- a/packages/vitest/src/node/pools/vmThreads.ts
+++ b/packages/vitest/src/node/pools/vmThreads.ts
@@ -200,7 +200,10 @@ export function createVmThreadsPool(
     name: 'vmThreads',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
-    close: () => pool.destroy(),
+    close: async () => {
+      await pool.run({}, { name: 'cleanup' })
+      await pool.destroy()
+    },
   }
 }
 
diff --git a/packages/vitest/src/runtime/cleanup.ts b/packages/vitest/src/runtime/cleanup.ts
new file mode 100644
index 000000000000..f74472ed1544
--- /dev/null
+++ b/packages/vitest/src/runtime/cleanup.ts
@@ -0,0 +1,14 @@
+const listeners = new Set<() => unknown>()
+
+export function addCleanupListener(listener: () => unknown): void {
+  listeners.add(listener)
+}
+
+export function removeCleanupListener(listener: () => unknown): void {
+  listeners.delete(listener)
+}
+
+export async function cleanup(): Promise<void> {
+  const promises = [...listeners].map(l => l())
+  await Promise.all(promises)
+}
diff --git a/packages/vitest/src/runtime/runners/test.ts b/packages/vitest/src/runtime/runners/test.ts
index b496bea0c0a9..16f20caf3374 100644
--- a/packages/vitest/src/runtime/runners/test.ts
+++ b/packages/vitest/src/runtime/runners/test.ts
@@ -46,6 +46,10 @@ export class VitestTestRunner implements VitestRunner {
     this.workerState.current = file
   }
 
+  onCleanupWorkerContext(listener: () => unknown): void {
+    this.workerState.onCleanup(listener)
+  }
+
   onAfterRunFiles(): void {
     this.snapshotClient.clear()
     this.workerState.current = undefined
diff --git a/packages/vitest/src/runtime/worker.ts b/packages/vitest/src/runtime/worker.ts
index 5bbe1a857816..2025ca98e801 100644
--- a/packages/vitest/src/runtime/worker.ts
+++ b/packages/vitest/src/runtime/worker.ts
@@ -5,6 +5,7 @@ import { createStackString, parseStacktrace } from '@vitest/utils/source-map'
 import { workerId as poolId } from 'tinypool'
 import { ModuleCacheMap } from 'vite-node/client'
 import { loadEnvironment } from '../integrations/env/loader'
+import { addCleanupListener, cleanup as cleanupWorker } from './cleanup'
 import { setupInspect } from './inspector'
 import { createRuntimeRpc, rpcDone } from './rpc'
 import { isChildProcess, setProcessTitle } from './utils'
@@ -91,6 +92,7 @@ async function execute(method: 'run' | 'collect', ctx: ContextRPC) {
         prepare: prepareStart,
       },
       rpc,
+      onCleanup: listener => addCleanupListener(listener),
       providedContext: ctx.providedContext,
       onFilterStackTrace(stack) {
         return createStackString(parseStacktrace(stack))
@@ -120,3 +122,7 @@ export function run(ctx: ContextRPC): Promise<void> {
 export function collect(ctx: ContextRPC): Promise<void> {
   return execute('collect', ctx)
 }
+
+export async function cleanup(): Promise<void> {
+  return cleanupWorker()
+}
diff --git a/packages/vitest/src/types/worker.ts b/packages/vitest/src/types/worker.ts
index 05b511c4a742..7a871d57036f 100644
--- a/packages/vitest/src/types/worker.ts
+++ b/packages/vitest/src/types/worker.ts
@@ -45,6 +45,7 @@ export interface WorkerGlobalState {
   onCancel: Promise<CancelReason>
   moduleCache: ModuleCacheMap
   moduleExecutionInfo?: ModuleExecutionInfo
+  onCleanup: (listener: () => unknown) => void
   providedContext: Record<string, any>
   durations: {
     environment: number
diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index 0a798701e2dd..a90bff833f23 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -33,31 +33,28 @@ test('test fixture cannot import from file fixture', async () => {
 })
 
 test('can import file fixture inside the local fixture', async () => {
-  const { stderr, fixtures, tests } = await runFixtureTests(
-    ({ log }) => it.extend<{
-      file: string
-      local: string
-    }>({
-      local: async ({ file }, use) => {
-        log('init local')
-        await use(file)
-        log('teardown local')
-      },
-      file: [
-        async ({}, use) => {
-          log('init file')
-          await use('file')
-          log('teardown file')
-        },
-        { scope: 'file' },
-      ],
-    }),
-    {
-      'basic.test.ts': ({ extendedTest }) => {
-        extendedTest('test1', ({ local: _local }) => {})
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
+    file: string
+    local: string
+  }>({
+    local: async ({ file }, use) => {
+      log('init local')
+      await use(file)
+      log('teardown local')
+    },
+    file: [
+      async ({}, use) => {
+        log('init file')
+        await use('file')
+        log('teardown file')
       },
+      { scope: 'file' },
+    ],
+  }), {
+    'basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ local: _local }) => {})
     },
-  )
+  })
 
   expect(stderr).toBe('')
   expect(fixtures).toMatchInlineSnapshot(`
@@ -70,33 +67,31 @@ test('can import file fixture inside the local fixture', async () => {
 })
 
 test.skip('can import worker fixture inside the local fixture', async () => {
-  const { stderr, fixtures, tests } = await runFixtureTests(
-    ({ log }) => it.extend<{
-      worker: string
-      local: string
-    }>({
-      local: async ({ worker }, use) => {
-        log('init local')
-        await use(worker)
-        log('teardown local')
-      },
-      worker: [
-        async ({}, use) => {
-          log('init worker')
-          await use('worker')
-          log('teardown worker')
-        },
-        { scope: 'worker' },
-      ],
-    }),
-    {
-      'basic.test.ts': ({ extendedTest }) => {
-        extendedTest('test1', ({ local }) => {
-          expect(local).toBe('worker')
-        })
+  const { stderr, stdout, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
+    worker: string
+    local: string
+  }>({
+    local: async ({ worker }, use) => {
+      log('init local')
+      await use(worker)
+      log('teardown local')
+    },
+    worker: [
+      async ({}, use) => {
+        log('init worker')
+        await use('worker')
+        log('teardown worker')
       },
+      { scope: 'worker' },
+    ],
+  }), {
+    'basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ local }) => {
+        expect(local).toBe('worker')
+      })
     },
-  )
+  })
+  console.log(stdout)
 
   expect(stderr).toBe('')
   // TODO: worker teardown is not called
@@ -319,7 +314,7 @@ test.for([
   true,
   false,
 ])('file fixture is provided as a factory and is initialised once in all suites, teardown is called once per file (isolate %s)', async (isolate) => {
-  const { stderr, fixtures, tests } = await runFixtureTests<{ file: string }>(({ log }) => it.extend<{ file: string }>({
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ file: string }>({
     file: [
       async ({}, use) => {
         log('init file')
@@ -359,7 +354,7 @@ test.for([
       })
     },
 
-    'second.test.js': ({ extendedTest }: { extendedTest: TestAPI<{ file: string }> }) => {
+    'second.test.js': ({ extendedTest }) => {
       // doesn't access "file", not initialised
       extendedTest('[second] test 0', ({}) => {})
       // accesses "file" for the first time, initialised
@@ -371,7 +366,7 @@ test.for([
       })
     },
 
-    'third.test.js': ({ extendedTest }: { extendedTest: TestAPI<{ file: string }> }) => {
+    'third.test.js': ({ extendedTest }) => {
       // doesn't access "file" at all
       extendedTest('[third] test 0', ({}) => {})
     },
@@ -431,6 +426,7 @@ async function runFixtureTests<T>(
 
   return {
     stderr,
+    stdout,
     fixtures: getFixtureLogs(stdout),
     tests: getSuccessTests(stdout),
   }

From 1ebb162993b2df8ef1e388369b4ea79888dd5086 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Fri, 23 May 2025 16:55:30 +0200
Subject: [PATCH 15/30] chore: typos

---
 packages/runner/src/fixture.ts      | 2 +-
 packages/runner/src/types/runner.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/runner/src/fixture.ts b/packages/runner/src/fixture.ts
index 8a59e1e15be4..333456b8d639 100644
--- a/packages/runner/src/fixture.ts
+++ b/packages/runner/src/fixture.ts
@@ -233,7 +233,7 @@ function resolveFixtureValue(
 
   if (fixture.scope === 'worker') {
     if (!workerContext) {
-      throw new TypeError('[@vitets/runner] The worker context is not available in the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.')
+      throw new TypeError('[@vitest/runner] The worker context is not available in the current test runner. Please, provide the `getWorkerContext` method when initiating the runner.')
     }
     fixtureContext = workerContext
   }
diff --git a/packages/runner/src/types/runner.ts b/packages/runner/src/types/runner.ts
index 3247d43c8c03..d2e76e259980 100644
--- a/packages/runner/src/types/runner.ts
+++ b/packages/runner/src/types/runner.ts
@@ -163,7 +163,7 @@ export interface VitestRunner {
   pool?: string
 
   /**
-   * Return the worker context for fixutres specified with `scope: 'worker'`
+   * Return the worker context for fixtures specified with `scope: 'worker'`
    */
   getWorkerContext?: () => Record<string, unknown>
   onCleanupWorkerContext?: (cleanup: () => unknown) => void

From a710f2fdd34a7721bcc6e4bfb41c86724c7cb00d Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Fri, 23 May 2025 17:10:22 +0200
Subject: [PATCH 16/30] feat: use `teardown` from tinypool

---
 packages/browser/src/client/tester/state.ts  |  1 +
 packages/browser/src/client/tester/tester.ts |  4 ++++
 packages/browser/src/client/utils.ts         |  1 +
 packages/vitest/package.json                 |  2 +-
 packages/vitest/src/node/pools/forks.ts      |  1 +
 packages/vitest/src/node/pools/threads.ts    |  1 +
 packages/vitest/src/runtime/worker.ts        |  2 +-
 pnpm-lock.yaml                               | 11 ++++++-----
 test/cli/test/scoped-fixtures.test.ts        |  5 +++--
 9 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/packages/browser/src/client/tester/state.ts b/packages/browser/src/client/tester/state.ts
index 2e740a9d8913..5cdbd00e55d8 100644
--- a/packages/browser/src/client/tester/state.ts
+++ b/packages/browser/src/client/tester/state.ts
@@ -30,6 +30,7 @@ const state: WorkerGlobalState = {
       throw new Error('Not called in the browser')
     },
   },
+  onCleanup: fn => getBrowserState().cleanups.push(fn),
   moduleCache: getBrowserState().moduleCache,
   rpc: null as any,
   durations: {
diff --git a/packages/browser/src/client/tester/tester.ts b/packages/browser/src/client/tester/tester.ts
index a7ec2a805555..1751c98d8c52 100644
--- a/packages/browser/src/client/tester/tester.ts
+++ b/packages/browser/src/client/tester/tester.ts
@@ -234,6 +234,10 @@ async function cleanup() {
   await userEvent.cleanup()
     .catch(error => unhandledError(error, 'Cleanup Error'))
 
+  await Promise.all(
+    getBrowserState().cleanups.map(fn => fn()),
+  ).catch(error => unhandledError(error, 'Cleanup Error'))
+
   // if isolation is disabled, Vitest reuses the same iframe and we
   // don't need to switch the context back at all
   if (contextSwitched) {
diff --git a/packages/browser/src/client/utils.ts b/packages/browser/src/client/utils.ts
index 7a200a9c8a03..b18aa80a18b7 100644
--- a/packages/browser/src/client/utils.ts
+++ b/packages/browser/src/client/utils.ts
@@ -81,6 +81,7 @@ export interface BrowserRunnerState {
   method: 'run' | 'collect'
   orchestrator?: IframeOrchestrator
   commands: CommandsManager
+  cleanups: Array<() => unknown>
   cdp?: {
     on: (event: string, listener: (payload: any) => void) => void
     once: (event: string, listener: (payload: any) => void) => void
diff --git a/packages/vitest/package.json b/packages/vitest/package.json
index 152bb22f3de0..d70969e6f770 100644
--- a/packages/vitest/package.json
+++ b/packages/vitest/package.json
@@ -168,7 +168,7 @@
     "tinybench": "^2.9.0",
     "tinyexec": "^0.3.2",
     "tinyglobby": "catalog:",
-    "tinypool": "^1.0.2",
+    "tinypool": "https://pkg.pr.new/tinypool@115",
     "tinyrainbow": "catalog:",
     "vite": "^5.0.0 || ^6.0.0",
     "vite-node": "workspace:*",
diff --git a/packages/vitest/src/node/pools/forks.ts b/packages/vitest/src/node/pools/forks.ts
index e629e627b81d..1f05d856ff3c 100644
--- a/packages/vitest/src/node/pools/forks.ts
+++ b/packages/vitest/src/node/pools/forks.ts
@@ -72,6 +72,7 @@ export function createForksPool(
   const options: TinypoolOptions = {
     runtime: 'child_process',
     filename: resolve(ctx.distPath, 'worker.js'),
+    teardown: 'teardown',
 
     maxThreads,
     minThreads,
diff --git a/packages/vitest/src/node/pools/threads.ts b/packages/vitest/src/node/pools/threads.ts
index 062579e339b3..be79a089d884 100644
--- a/packages/vitest/src/node/pools/threads.ts
+++ b/packages/vitest/src/node/pools/threads.ts
@@ -63,6 +63,7 @@ export function createThreadsPool(
 
   const options: TinypoolOptions = {
     filename: resolve(ctx.distPath, 'worker.js'),
+    teardown: 'teardown',
     // TODO: investigate further
     // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
     useAtomics: poolOptions.useAtomics ?? false,
diff --git a/packages/vitest/src/runtime/worker.ts b/packages/vitest/src/runtime/worker.ts
index 2025ca98e801..f35793b7cfe1 100644
--- a/packages/vitest/src/runtime/worker.ts
+++ b/packages/vitest/src/runtime/worker.ts
@@ -123,6 +123,6 @@ export function collect(ctx: ContextRPC): Promise<void> {
   return execute('collect', ctx)
 }
 
-export async function cleanup(): Promise<void> {
+export async function teardown(): Promise<void> {
   return cleanupWorker()
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7eb56caa1720..9945694bba30 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1001,8 +1001,8 @@ importers:
         specifier: 'catalog:'
         version: 0.2.13
       tinypool:
-        specifier: ^1.0.2
-        version: 1.0.2
+        specifier: https://pkg.pr.new/tinypool@115
+        version: https://pkg.pr.new/tinypool@115
       tinyrainbow:
         specifier: 'catalog:'
         version: 2.0.0
@@ -8333,8 +8333,9 @@ packages:
       picocolors:
         optional: true
 
-  tinypool@1.0.2:
-    resolution: {integrity: sha512-al6n+QEANGFOMf/dmUMsuS5/r9B06uwlyNjZZql/zv8J7ybHCgoihBNORZCY2mzUuAnomQa2JdhyHKzZxPCrFA==}
+  tinypool@https://pkg.pr.new/tinypool@115:
+    resolution: {tarball: https://pkg.pr.new/tinypool@115}
+    version: 1.0.2
     engines: {node: ^18.0.0 || >=20.0.0}
 
   tinyrainbow@2.0.0:
@@ -16814,7 +16815,7 @@ snapshots:
     optionalDependencies:
       picocolors: 1.1.1
 
-  tinypool@1.0.2: {}
+  tinypool@https://pkg.pr.new/tinypool@115: {}
 
   tinyrainbow@2.0.0: {}
 
diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index a90bff833f23..4f4e2df897f6 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -66,7 +66,7 @@ test('can import file fixture inside the local fixture', async () => {
   expect(tests).toMatchInlineSnapshot(`" ✓ basic.test.ts > test1 <time>"`)
 })
 
-test.skip('can import worker fixture inside the local fixture', async () => {
+test.only('can import worker fixture inside the local fixture', async () => {
   const { stderr, stdout, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
     worker: string
     local: string
@@ -98,7 +98,8 @@ test.skip('can import worker fixture inside the local fixture', async () => {
   expect(fixtures).toMatchInlineSnapshot(`
     ">> fixture | init worker | test1
     >> fixture | init local | test1
-    >> fixture | teardown local | test1"
+    >> fixture | teardown local | test1
+    >> fixture | teardown worker | test1"
   `)
   expect(tests).toMatchInlineSnapshot(`" ✓ basic.test.ts > test1 <time>"`)
 })

From 3262507a6cb6d3b804a62c9750c4fa43cfb98ad0 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Mon, 26 May 2025 10:57:37 +0200
Subject: [PATCH 17/30] chore: remove unused

---
 packages/vitest/src/node/pools/forks.ts   | 15 ---------------
 packages/vitest/src/node/pools/threads.ts |  7 -------
 2 files changed, 22 deletions(-)

diff --git a/packages/vitest/src/node/pools/forks.ts b/packages/vitest/src/node/pools/forks.ts
index 1f05d856ff3c..684b7c5c5d52 100644
--- a/packages/vitest/src/node/pools/forks.ts
+++ b/packages/vitest/src/node/pools/forks.ts
@@ -229,9 +229,6 @@ export function createForksPool(
             await new Promise<void>(resolve =>
               pool.queueSize === 0 ? resolve() : pool.once('drain', resolve),
             )
-            if (pool.threads.length) {
-              await cleanupWorkers()
-            }
             await pool.recycleWorkers()
           }
         }
@@ -268,7 +265,6 @@ export function createForksPool(
 
           for (const files of Object.values(filesByOptions)) {
             // Always run environments isolated between each other
-            await cleanupWorkers()
             await pool.recycleWorkers()
 
             const filenames = files.map(f => f.file)
@@ -285,22 +281,11 @@ export function createForksPool(
     }
   }
 
-  async function cleanupWorkers() {
-    const emitter = new EventEmitter()
-    const events = { message: 'message', response: 'response' }
-    const channel: TinypoolChannel = {
-      onMessage: callback => emitter.on(events.message, callback),
-      postMessage: message => emitter.emit(events.response, message),
-    }
-    await pool.run({}, { name: 'cleanup', channel })
-  }
-
   return {
     name: 'forks',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
     close: async () => {
-      await cleanupWorkers()
       await pool.destroy()
     },
   }
diff --git a/packages/vitest/src/node/pools/threads.ts b/packages/vitest/src/node/pools/threads.ts
index be79a089d884..08842ea743aa 100644
--- a/packages/vitest/src/node/pools/threads.ts
+++ b/packages/vitest/src/node/pools/threads.ts
@@ -225,7 +225,6 @@ export function createThreadsPool(
             await new Promise<void>(resolve =>
               pool.queueSize === 0 ? resolve() : pool.once('drain', resolve),
             )
-            await cleanupWorkers()
             await pool.recycleWorkers()
           }
         }
@@ -261,7 +260,6 @@ export function createThreadsPool(
           )
 
           for (const files of Object.values(filesByOptions)) {
-            await cleanupWorkers()
             // Always run environments isolated between each other
             await pool.recycleWorkers()
 
@@ -279,16 +277,11 @@ export function createThreadsPool(
     }
   }
 
-  async function cleanupWorkers() {
-    // await pool.run({}, { name: 'cleanup' })
-  }
-
   return {
     name: 'threads',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
     close: async () => {
-      await cleanupWorkers()
       await pool.destroy()
     },
   }

From f78f4a46c6efd4162314f72c1274f6f7d63773b0 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Mon, 26 May 2025 11:00:42 +0200
Subject: [PATCH 18/30] test: fix tests

---
 test/cli/test/scoped-fixtures.test.ts | 35 ++++++++++++++++-----------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index 4f4e2df897f6..5fabbcf85618 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -8,6 +8,7 @@ import { runInlineTests } from '../../test-utils'
 declare module 'vitest' {
   interface TestContext {
     file: string
+    worker: string
   }
 }
 
@@ -66,8 +67,8 @@ test('can import file fixture inside the local fixture', async () => {
   expect(tests).toMatchInlineSnapshot(`" ✓ basic.test.ts > test1 <time>"`)
 })
 
-test.only('can import worker fixture inside the local fixture', async () => {
-  const { stderr, stdout, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
+test('can import worker fixture inside the local fixture', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
     worker: string
     local: string
   }>({
@@ -91,10 +92,8 @@ test.only('can import worker fixture inside the local fixture', async () => {
       })
     },
   })
-  console.log(stdout)
 
   expect(stderr).toBe('')
-  // TODO: worker teardown is not called
   expect(fixtures).toMatchInlineSnapshot(`
     ">> fixture | init worker | test1
     >> fixture | init local | test1
@@ -125,7 +124,7 @@ test('test fixture cannot import from worker fixture', async () => {
   expect(stderr).toContain('cannot use the test fixture "local" inside the worker fixture "worker"')
 })
 
-test.skip('auto worker fixture is initialised always before the first test', async () => {
+test('auto worker fixture is initialised always before the first test', async () => {
   const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
     worker: [
       async ({}, use) => {
@@ -145,8 +144,10 @@ test.skip('auto worker fixture is initialised always before the first test', asy
   })
 
   expect(stderr).toBe('')
-  // TODO: teardown is not called
-  expect(fixtures).toMatchInlineSnapshot(`">> fixture | init file | test1"`)
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init file | test1
+    >> fixture | teardown file | test4"
+  `)
   expect(tests).toMatchInlineSnapshot(`
     " ✓ basic.test.ts > test1 <time>
      ✓ basic.test.ts > test2 <time>
@@ -205,7 +206,7 @@ test('file fixture can import a static value from test fixture', async () => {
   expect(stderr).toBe('')
 })
 
-test.skip('worker fixtures are available in beforeEach and afterEach', async () => {
+test('worker fixtures are available in beforeEach and afterEach', async () => {
   const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
     worker: [
       async ({}, use) => {
@@ -217,11 +218,11 @@ test.skip('worker fixtures are available in beforeEach and afterEach', async ()
     ],
   }), {
     'basic.test.ts': ({ extendedTest }) => {
-      beforeEach(({ file }) => {
-        console.log('>> fixture | beforeEach |', file)
+      beforeEach(({ worker }) => {
+        console.log('>> fixture | beforeEach |', worker)
       })
-      afterEach(({ file }) => {
-        console.log('>> fixture | afterEach |', file)
+      afterEach(({ worker }) => {
+        console.log('>> fixture | afterEach |', worker)
       })
       extendedTest('test1', ({}) => {})
       extendedTest('test2', ({}) => {})
@@ -229,8 +230,14 @@ test.skip('worker fixtures are available in beforeEach and afterEach', async ()
   })
 
   expect(stderr).toBe('')
-  // TODO: teardown is not called
-  expect(fixtures).toMatchInlineSnapshot()
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init worker | test1
+    >> fixture | beforeEach | worker
+    >> fixture | afterEach | worker
+    >> fixture | beforeEach | worker
+    >> fixture | afterEach | worker
+    >> fixture | teardown worker | test2"
+  `)
   expect(tests).toMatchInlineSnapshot(`
     " ✓ basic.test.ts > test1 <time>
      ✓ basic.test.ts > test2 <time>"

From 8a2a41c67cea324c3382820303565e203561d94b Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Mon, 26 May 2025 11:27:00 +0200
Subject: [PATCH 19/30] test: isolate false

---
 test/cli/test/scoped-fixtures.test.ts | 97 ++++++++++++++++++++++++---
 1 file changed, 88 insertions(+), 9 deletions(-)

diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index 5fabbcf85618..f31ce6afdfb5 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -5,13 +5,15 @@ import type { ViteUserConfig } from 'vitest/config'
 import type { TestFsStructure } from '../../test-utils'
 import { runInlineTests } from '../../test-utils'
 
-declare module 'vitest' {
-  interface TestContext {
-    file: string
-    worker: string
-  }
+interface TestContext {
+  file: string
+  worker: string
 }
 
+// TODO: test several workers
+// TODO: works in the browser
+// TODO: works in vmThreads, vmForks, forks, threads
+
 test('test fixture cannot import from file fixture', async () => {
   const { stderr } = await runInlineTests({
     'basic.test.ts': () => {
@@ -206,6 +208,83 @@ test('file fixture can import a static value from test fixture', async () => {
   expect(stderr).toBe('')
 })
 
+test('worker fixture initiates and torn down in different workers', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
+    worker: [
+      async ({}, use) => {
+        log('init worker')
+        await use('worker')
+        log('teardown worker')
+      },
+      { scope: 'worker' },
+    ],
+  }), {
+    '1-basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ worker: _worker }) => {})
+    },
+    '2-basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ worker: _worker }) => {})
+    },
+    'vitest.config.ts': {
+      test: {
+        globals: true,
+        isolate: false,
+        maxWorkers: 2,
+        minWorkers: 2,
+        pool: 'threads',
+      },
+    },
+  })
+
+  expect(stderr).toBe('')
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init worker | test1
+    >> fixture | teardown worker | test1
+    >> fixture | init worker | test1
+    >> fixture | teardown worker | test1"
+  `)
+  expect(tests).toMatchInlineSnapshot(`
+    " ✓ 1-basic.test.ts > test1 <time>
+     ✓ 2-basic.test.ts > test1 <time>"
+  `)
+})
+
+test.only('worker fixture initiates and torn down in one worker', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
+    worker: [
+      async ({}, use) => {
+        log('init worker')
+        await use('worker')
+        log('teardown worker')
+      },
+      { scope: 'worker' },
+    ],
+  }), {
+    '1-basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ worker: _worker }) => {})
+    },
+    '2-basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ worker: _worker }) => {})
+    },
+    'vitest.config.ts': {
+      test: {
+        globals: true,
+        isolate: false,
+        maxWorkers: 1,
+        minWorkers: 1,
+        pool: 'threads',
+      },
+    },
+  })
+
+  expect(stderr).toBe('')
+  expect(fixtures).toMatchInlineSnapshot(`">> fixture | init worker | test1"`)
+  expect(tests).toMatchInlineSnapshot(`
+    " ✓ 1-basic.test.ts > test1 <time>
+     ✓ 2-basic.test.ts > test1 <time>"
+  `)
+})
+
 test('worker fixtures are available in beforeEach and afterEach', async () => {
   const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
     worker: [
@@ -218,10 +297,10 @@ test('worker fixtures are available in beforeEach and afterEach', async () => {
     ],
   }), {
     'basic.test.ts': ({ extendedTest }) => {
-      beforeEach(({ worker }) => {
+      beforeEach<TestContext>(({ worker }) => {
         console.log('>> fixture | beforeEach |', worker)
       })
-      afterEach(({ worker }) => {
+      afterEach<TestContext>(({ worker }) => {
         console.log('>> fixture | afterEach |', worker)
       })
       extendedTest('test1', ({}) => {})
@@ -258,10 +337,10 @@ test('file fixtures are available in beforeEach and afterEach', async () => {
     ],
   }), {
     'basic.test.ts': ({ extendedTest }) => {
-      beforeEach(({ file }) => {
+      beforeEach<TestContext>(({ file }) => {
         console.log('>> fixture | beforeEach |', file)
       })
-      afterEach(({ file }) => {
+      afterEach<TestContext>(({ file }) => {
         console.log('>> fixture | afterEach |', file)
       })
       extendedTest('test1', ({}) => {})

From f2189a795e2e7a7b9db0b057baa81e261d910e86 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Mon, 26 May 2025 11:30:59 +0200
Subject: [PATCH 20/30] fix: remove unused cleanup

---
 packages/vitest/src/node/pools/vmForks.ts   | 8 --------
 packages/vitest/src/node/pools/vmThreads.ts | 1 -
 2 files changed, 9 deletions(-)

diff --git a/packages/vitest/src/node/pools/vmForks.ts b/packages/vitest/src/node/pools/vmForks.ts
index 580dd8640353..dbf34afde474 100644
--- a/packages/vitest/src/node/pools/vmForks.ts
+++ b/packages/vitest/src/node/pools/vmForks.ts
@@ -208,14 +208,6 @@ export function createVmForksPool(
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
     close: async () => {
-      const emitter = new EventEmitter()
-
-      const events = { message: 'message', response: 'response' }
-      const channel: TinypoolChannel = {
-        onMessage: callback => emitter.on(events.message, callback),
-        postMessage: message => emitter.emit(events.response, message),
-      }
-      await pool.run({}, { name: 'cleanup', channel })
       await pool.destroy()
     },
   }
diff --git a/packages/vitest/src/node/pools/vmThreads.ts b/packages/vitest/src/node/pools/vmThreads.ts
index 8e46b29ea71e..5fdfb539a9b9 100644
--- a/packages/vitest/src/node/pools/vmThreads.ts
+++ b/packages/vitest/src/node/pools/vmThreads.ts
@@ -201,7 +201,6 @@ export function createVmThreadsPool(
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
     close: async () => {
-      await pool.run({}, { name: 'cleanup' })
       await pool.destroy()
     },
   }

From b5dc60cfc0030a4bf5bcdffb280ab7470ff2afe9 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Mon, 26 May 2025 12:05:40 +0200
Subject: [PATCH 21/30] fix: support worker fixture in vmThreads

---
 packages/runner/src/fixture.ts            |  7 +-
 packages/runner/src/suite.ts              |  4 +-
 packages/vitest/src/runtime/runVmTests.ts |  2 +
 test/cli/test/scoped-fixtures.test.ts     | 83 ++++++++++++++++++++++-
 4 files changed, 91 insertions(+), 5 deletions(-)

diff --git a/packages/runner/src/fixture.ts b/packages/runner/src/fixture.ts
index 333456b8d639..c57528044cc9 100644
--- a/packages/runner/src/fixture.ts
+++ b/packages/runner/src/fixture.ts
@@ -46,7 +46,7 @@ export function mergeScopedFixtures(
 export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
   fixtures: Record<string, any>,
   context: T,
-  inject: (key: string) => unknown,
+  runner: VitestRunner,
 ): T {
   const fixtureOptionKeys = ['auto', 'injected', 'scope']
   const fixtureArray: FixtureItem[] = Object.entries(fixtures).map(
@@ -63,11 +63,14 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
         Object.assign(fixtureItem, value[1])
         const userValue = value[0]
         fixtureItem.value = fixtureItem.injected
-          ? (inject(prop) ?? userValue)
+          ? (runner.injectValue?.(prop) ?? userValue)
           : userValue
       }
 
       fixtureItem.scope = fixtureItem.scope || 'test'
+      if (fixtureItem.scope === 'worker' && !runner.getWorkerContext) {
+        fixtureItem.scope = 'file'
+      }
       fixtureItem.prop = prop
       fixtureItem.isFn = typeof fixtureItem.value === 'function'
       return fixtureItem
diff --git a/packages/runner/src/suite.ts b/packages/runner/src/suite.ts
index fc4e45c25a34..fc81d27faa00 100644
--- a/packages/runner/src/suite.ts
+++ b/packages/runner/src/suite.ts
@@ -423,7 +423,7 @@ function createSuiteCollector(
       const parsed = mergeContextFixtures(
         fixtures,
         { fixtures: collectorFixtures },
-        (key: string) => getRunner().injectValue?.(key),
+        runner,
       )
       if (parsed.fixtures) {
         collectorFixtures = parsed.fixtures
@@ -766,7 +766,7 @@ export function createTaskCollector(
     const _context = mergeContextFixtures(
       fixtures,
       context || {},
-      (key: string) => getRunner().injectValue?.(key),
+      runner,
     )
 
     return createTest(function fn(
diff --git a/packages/vitest/src/runtime/runVmTests.ts b/packages/vitest/src/runtime/runVmTests.ts
index 8ebaa2443363..c1a92b2d478d 100644
--- a/packages/vitest/src/runtime/runVmTests.ts
+++ b/packages/vitest/src/runtime/runVmTests.ts
@@ -77,6 +77,8 @@ export async function run(
 
   config.snapshotOptions.snapshotEnvironment = snapshotEnvironment
 
+  runner.getWorkerContext = undefined
+
   workerState.onCancel.then((reason) => {
     closeInspector(config)
     runner.cancel?.(reason)
diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index f31ce6afdfb5..875ae432f732 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -208,6 +208,87 @@ test('file fixture can import a static value from test fixture', async () => {
   expect(stderr).toBe('')
 })
 
+test('worker fixture works in vmThreads and runs for every file', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
+    worker: [
+      async ({}, use) => {
+        log('init worker')
+        await use('worker')
+        log('teardown worker')
+      },
+      { scope: 'worker' },
+    ],
+  }), {
+    '1-basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ worker: _worker }) => {})
+    },
+    '2-basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ worker: _worker }) => {})
+    },
+    'vitest.config.ts': {
+      test: {
+        globals: true,
+        maxWorkers: 1,
+        minWorkers: 1,
+        pool: 'vmThreads',
+      },
+    },
+  })
+
+  expect(stderr).toBe('')
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init worker | test1
+    >> fixture | teardown worker | test1
+    >> fixture | init worker | test1
+    >> fixture | teardown worker | test1"
+  `)
+  expect(tests).toMatchInlineSnapshot(`
+    " ✓ 1-basic.test.ts > test1 <time>
+     ✓ 2-basic.test.ts > test1 <time>"
+  `)
+})
+
+test('worker fixtures in isolated tests init and teardown twice', async () => {
+  const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
+    worker: [
+      async ({}, use) => {
+        log('init worker')
+        await use('worker')
+        log('teardown worker')
+      },
+      { scope: 'worker' },
+    ],
+  }), {
+    '1-basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ worker: _worker }) => {})
+    },
+    '2-basic.test.ts': ({ extendedTest }) => {
+      extendedTest('test1', ({ worker: _worker }) => {})
+    },
+    'vitest.config.ts': {
+      test: {
+        globals: true,
+        isolate: true,
+        maxWorkers: 2,
+        minWorkers: 2,
+        pool: 'threads',
+      },
+    },
+  })
+
+  expect(stderr).toBe('')
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init worker | test1
+    >> fixture | teardown worker | test1
+    >> fixture | init worker | test1
+    >> fixture | teardown worker | test1"
+  `)
+  expect(tests).toMatchInlineSnapshot(`
+    " ✓ 1-basic.test.ts > test1 <time>
+     ✓ 2-basic.test.ts > test1 <time>"
+  `)
+})
+
 test('worker fixture initiates and torn down in different workers', async () => {
   const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
     worker: [
@@ -249,7 +330,7 @@ test('worker fixture initiates and torn down in different workers', async () =>
   `)
 })
 
-test.only('worker fixture initiates and torn down in one worker', async () => {
+test('worker fixture initiates and torn down in one non-isolated worker', async () => {
   const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
     worker: [
       async ({}, use) => {

From 8b735ceab26f51ca39fe54d60af924a81c8b7965 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Mon, 26 May 2025 12:27:59 +0200
Subject: [PATCH 22/30] test: add browser tests

---
 .../src/client/public/esm-client-injector.js  |   1 +
 test/cli/test/scoped-fixtures.test.ts         | 165 +++++++++++++++++-
 2 files changed, 161 insertions(+), 5 deletions(-)

diff --git a/packages/browser/src/client/public/esm-client-injector.js b/packages/browser/src/client/public/esm-client-injector.js
index 720d9e669c65..3f0953bbbd3a 100644
--- a/packages/browser/src/client/public/esm-client-injector.js
+++ b/packages/browser/src/client/public/esm-client-injector.js
@@ -20,6 +20,7 @@
     wrapModule,
     wrapDynamicImport: wrapModule,
     moduleCache,
+    cleanups: [],
     config: { __VITEST_CONFIG__ },
     viteConfig: { __VITEST_VITE_CONFIG__ },
     type: { __VITEST_TYPE__ },
diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index 875ae432f732..55637dd7721a 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -10,10 +10,6 @@ interface TestContext {
   worker: string
 }
 
-// TODO: test several workers
-// TODO: works in the browser
-// TODO: works in vmThreads, vmForks, forks, threads
-
 test('test fixture cannot import from file fixture', async () => {
   const { stderr } = await runInlineTests({
     'basic.test.ts': () => {
@@ -289,7 +285,8 @@ test('worker fixtures in isolated tests init and teardown twice', async () => {
   `)
 })
 
-test('worker fixture initiates and torn down in different workers', async () => {
+// TODO: no-isolate breaks tests
+test.skip('worker fixture initiates and torn down in different workers', async () => {
   const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
     worker: [
       async ({}, use) => {
@@ -572,10 +569,168 @@ test.for([
   `)
 })
 
+describe.for([
+  { pool: 'forks' },
+  { pool: 'threads' },
+  {
+    pool: 'browser',
+    name: 'core',
+    browser: {
+      enabled: true,
+      provider: 'playwright',
+      headless: true,
+      instances: [
+        { browser: 'chromium', name: '' },
+      ],
+    },
+  },
+])('works properly in $pool', (options) => {
+  test('file and worker fixtures are initiated', async () => {
+    const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
+      file: string
+      worker: string
+    }>({
+      worker: [
+        async ({}, use) => {
+          log('init worker')
+          await use('worker')
+          log('teardown worker')
+        },
+        { scope: 'worker' },
+      ],
+      file: [
+        async ({}, use) => {
+          log('init file')
+          await use('file')
+          log('teardown file')
+        },
+        { scope: 'file' },
+      ],
+    }), {
+      'basic.test.ts': ({ extendedTest }) => {
+        extendedTest('test1', ({ file: _file, worker: _worker }) => {})
+      },
+      'vitest.config.js': { test: options },
+    })
+
+    expect(stderr).toBe('')
+    expect(fixtures).toMatchInlineSnapshot(`
+      ">> fixture | init worker | test1
+      >> fixture | init file | test1
+      >> fixture | teardown file | test1
+      >> fixture | teardown worker | test1"
+    `)
+    expect(tests).toMatchInlineSnapshot(`" ✓ basic.test.ts > test1 <time>"`)
+  })
+
+  test('file and worker fixtures are initiated with auto', async () => {
+    const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
+      file: string
+      worker: string
+    }>({
+      worker: [
+        async ({}, use) => {
+          log('init worker')
+          await use('worker')
+          log('teardown worker')
+        },
+        { scope: 'worker', auto: true },
+      ],
+      file: [
+        async ({}, use) => {
+          log('init file')
+          await use('file')
+          log('teardown file')
+        },
+        { scope: 'file', auto: true },
+      ],
+    }), {
+      'basic.test.ts': ({ extendedTest }) => {
+        extendedTest('test1', () => {})
+      },
+      'vitest.config.js': { test: options },
+    })
+
+    expect(stderr).toBe('')
+    expect(fixtures).toMatchInlineSnapshot(`
+      ">> fixture | init worker | test1
+      >> fixture | init file | test1
+      >> fixture | teardown file | test1
+      >> fixture | teardown worker | test1"
+    `)
+    expect(tests).toMatchInlineSnapshot(`" ✓ basic.test.ts > test1 <time>"`)
+  })
+})
+
+describe('browser tests', () => {
+  test.only('initiates worker scope once for non-isolated tests', async () => {
+    const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
+      file: string
+      worker: string
+    }>({
+      worker: [
+        async ({}, use) => {
+          log('init worker')
+          await use('worker')
+          log('teardown worker')
+        },
+        { scope: 'worker' },
+      ],
+      file: [
+        async ({}, use) => {
+          log('init file')
+          await use('file')
+          log('teardown file')
+        },
+        { scope: 'file' },
+      ],
+    }), {
+      '1-basic.test.ts': ({ extendedTest }) => {
+        extendedTest('test1', ({ file: _file, worker: _worker }) => {})
+      },
+      '2-basic.test.ts': ({ extendedTest }) => {
+        extendedTest('test2', ({ file: _file, worker: _worker }) => {})
+      },
+      'vitest.config.js': {
+        test: {
+          maxWorkers: 1,
+          minWorkers: 1,
+          browser: {
+            enabled: true,
+            provider: 'playwright',
+            headless: true,
+            isolate: false,
+            instances: [
+              { browser: 'chromium' },
+            ],
+          },
+        },
+      },
+    })
+
+    expect(stderr).toBe('')
+    expect(fixtures).toMatchInlineSnapshot(`
+      ">> fixture | init worker | test1
+      >> fixture | init file | test1
+      >> fixture | teardown file | test1
+      >> fixture | init file | test2
+      >> fixture | teardown file | test2
+      >> fixture | teardown worker | test2"
+    `)
+    expect(tests).toMatchInlineSnapshot(`
+      " ✓ |chromium| 1-basic.test.ts > test1 <time>
+       ✓ |chromium| 2-basic.test.ts > test2 <time>"
+    `)
+  })
+})
+
 async function runFixtureTests<T>(
   extendedTest: ({ log }: { log: typeof console.log }) => TestAPI<T>,
   fs: Record<string, ((context: { extendedTest: TestAPI<T> }) => unknown) | ViteUserConfig>,
 ) {
+  if (typeof fs['vitest.config.js'] === 'object') {
+    fs['vitest.config.js'].test!.globals = true
+  }
   const { stderr, stdout } = await runInlineTests({
     'test.js': `
     export const extendedTest = (${extendedTest.toString()})({ log: (...args) => console.log('>> fixture |', ...args, '| ' + expect.getState().currentTestName) })

From a80a737141b3f45edcdad628b2681330126839ab Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Mon, 26 May 2025 13:24:08 +0200
Subject: [PATCH 23/30] chore: remove only

---
 test/cli/test/scoped-fixtures.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index 55637dd7721a..8aa93cee51c8 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -663,7 +663,7 @@ describe.for([
 })
 
 describe('browser tests', () => {
-  test.only('initiates worker scope once for non-isolated tests', async () => {
+  test('initiates worker scope once for non-isolated tests', async () => {
     const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{
       file: string
       worker: string

From d1e67a41b9a483d90b70151ad3e160a373b05ef5 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Tue, 27 May 2025 17:36:33 +0200
Subject: [PATCH 24/30] chore: refactor ctx->vitest

---
 packages/vitest/src/node/pools/forks.ts     | 28 ++++++++--------
 packages/vitest/src/node/pools/threads.ts   | 36 ++++++++++-----------
 packages/vitest/src/node/pools/vmForks.ts   | 32 +++++++++---------
 packages/vitest/src/node/pools/vmThreads.ts | 36 ++++++++++-----------
 4 files changed, 66 insertions(+), 66 deletions(-)

diff --git a/packages/vitest/src/node/pools/forks.ts b/packages/vitest/src/node/pools/forks.ts
index 684b7c5c5d52..8f22be2e4e93 100644
--- a/packages/vitest/src/node/pools/forks.ts
+++ b/packages/vitest/src/node/pools/forks.ts
@@ -48,7 +48,7 @@ function createChildProcessChannel(project: TestProject, collect = false) {
 }
 
 export function createForksPool(
-  ctx: Vitest,
+  vitest: Vitest,
   { execArgv, env }: PoolProcessOptions,
 ): ProcessPool {
   const numCpus
@@ -56,22 +56,22 @@ export function createForksPool(
       ? nodeos.availableParallelism()
       : nodeos.cpus().length
 
-  const threadsCount = ctx.config.watch
+  const threadsCount = vitest.config.watch
     ? Math.max(Math.floor(numCpus / 2), 1)
     : Math.max(numCpus - 1, 1)
 
-  const poolOptions = ctx.config.poolOptions?.forks ?? {}
+  const poolOptions = vitest.config.poolOptions?.forks ?? {}
 
   const maxThreads
-    = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount
+    = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount
   const minThreads
-    = poolOptions.minForks ?? ctx.config.minWorkers ?? threadsCount
+    = poolOptions.minForks ?? vitest.config.minWorkers ?? threadsCount
 
-  const worker = resolve(ctx.distPath, 'workers/forks.js')
+  const worker = resolve(vitest.distPath, 'workers/forks.js')
 
   const options: TinypoolOptions = {
     runtime: 'child_process',
-    filename: resolve(ctx.distPath, 'worker.js'),
+    filename: resolve(vitest.distPath, 'worker.js'),
     teardown: 'teardown',
 
     maxThreads,
@@ -80,7 +80,7 @@ export function createForksPool(
     env,
     execArgv: [...(poolOptions.execArgv ?? []), ...execArgv],
 
-    terminateTimeout: ctx.config.teardownTimeout,
+    terminateTimeout: vitest.config.teardownTimeout,
     concurrentTasksPerWorker: 1,
   }
 
@@ -90,7 +90,7 @@ export function createForksPool(
     options.isolateWorkers = true
   }
 
-  if (poolOptions.singleFork || !ctx.config.fileParallelism) {
+  if (poolOptions.singleFork || !vitest.config.fileParallelism) {
     options.maxThreads = 1
     options.minThreads = 1
   }
@@ -108,7 +108,7 @@ export function createForksPool(
       invalidates: string[] = [],
     ) {
       const paths = files.map(f => f.filepath)
-      ctx.state.clearFiles(project, paths)
+      vitest.state.clearFiles(project, paths)
 
       const { channel, cleanup } = createChildProcessChannel(project, name === 'collect')
       const workerId = ++id
@@ -132,17 +132,17 @@ export function createForksPool(
           error instanceof Error
           && /Failed to terminate worker/.test(error.message)
         ) {
-          ctx.state.addProcessTimeoutCause(
+          vitest.state.addProcessTimeoutCause(
             `Failed to terminate worker while running ${paths.join(', ')}.`,
           )
         }
         // Intentionally cancelled
         else if (
-          ctx.isCancelling
+          vitest.isCancelling
           && error instanceof Error
           && /The task has been cancelled/.test(error.message)
         ) {
-          ctx.state.cancelFiles(paths, project)
+          vitest.state.cancelFiles(paths, project)
         }
         else {
           throw error
@@ -155,7 +155,7 @@ export function createForksPool(
 
     return async (specs, invalidates) => {
       // Cancel pending tasks from pool when possible
-      ctx.onCancel(() => pool.cancelPendingTasks())
+      vitest.onCancel(() => pool.cancelPendingTasks())
 
       const configs = new WeakMap<TestProject, SerializedConfig>()
       const getConfig = (project: TestProject): SerializedConfig => {
diff --git a/packages/vitest/src/node/pools/threads.ts b/packages/vitest/src/node/pools/threads.ts
index 08842ea743aa..b5318b244025 100644
--- a/packages/vitest/src/node/pools/threads.ts
+++ b/packages/vitest/src/node/pools/threads.ts
@@ -34,13 +34,13 @@ function createWorkerChannel(project: TestProject, collect: boolean) {
     },
   })
 
-  project.ctx.onCancel(reason => rpc.onCancel(reason))
+  project.vitest.onCancel(reason => rpc.onCancel(reason))
 
   return { workerPort, port }
 }
 
 export function createThreadsPool(
-  ctx: Vitest,
+  vitest: Vitest,
   { execArgv, env }: PoolProcessOptions,
 ): ProcessPool {
   const numCpus
@@ -48,21 +48,21 @@ export function createThreadsPool(
       ? nodeos.availableParallelism()
       : nodeos.cpus().length
 
-  const threadsCount = ctx.config.watch
+  const threadsCount = vitest.config.watch
     ? Math.max(Math.floor(numCpus / 2), 1)
     : Math.max(numCpus - 1, 1)
 
-  const poolOptions = ctx.config.poolOptions?.threads ?? {}
+  const poolOptions = vitest.config.poolOptions?.threads ?? {}
 
   const maxThreads
-    = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount
+    = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount
   const minThreads
-    = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount
+    = poolOptions.minThreads ?? vitest.config.minWorkers ?? threadsCount
 
-  const worker = resolve(ctx.distPath, 'workers/threads.js')
+  const worker = resolve(vitest.distPath, 'workers/threads.js')
 
   const options: TinypoolOptions = {
-    filename: resolve(ctx.distPath, 'worker.js'),
+    filename: resolve(vitest.distPath, 'worker.js'),
     teardown: 'teardown',
     // TODO: investigate further
     // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
@@ -74,7 +74,7 @@ export function createThreadsPool(
     env,
     execArgv: [...(poolOptions.execArgv ?? []), ...execArgv],
 
-    terminateTimeout: ctx.config.teardownTimeout,
+    terminateTimeout: vitest.config.teardownTimeout,
     concurrentTasksPerWorker: 1,
   }
 
@@ -84,7 +84,7 @@ export function createThreadsPool(
     options.isolateWorkers = true
   }
 
-  if (poolOptions.singleThread || !ctx.config.fileParallelism) {
+  if (poolOptions.singleThread || !vitest.config.fileParallelism) {
     options.maxThreads = 1
     options.minThreads = 1
   }
@@ -102,7 +102,7 @@ export function createThreadsPool(
       invalidates: string[] = [],
     ) {
       const paths = files.map(f => f.filepath)
-      ctx.state.clearFiles(project, paths)
+      vitest.state.clearFiles(project, paths)
 
       const { workerPort, port } = createWorkerChannel(project, name === 'collect')
       const workerId = ++id
@@ -127,7 +127,7 @@ export function createThreadsPool(
           error instanceof Error
           && /Failed to terminate worker/.test(error.message)
         ) {
-          ctx.state.addProcessTimeoutCause(
+          vitest.state.addProcessTimeoutCause(
             `Failed to terminate worker while running ${paths.join(
               ', ',
             )}. \nSee https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`,
@@ -135,25 +135,25 @@ export function createThreadsPool(
         }
         // Intentionally cancelled
         else if (
-          ctx.isCancelling
+          vitest.isCancelling
           && error instanceof Error
           && /The task has been cancelled/.test(error.message)
         ) {
-          ctx.state.cancelFiles(paths, project)
+          vitest.state.cancelFiles(paths, project)
         }
         else {
           throw error
         }
       }
       finally {
-        port.close()
-        workerPort.close()
+        port.unref()
+        workerPort.unref()
       }
     }
 
     return async (specs, invalidates) => {
       // Cancel pending tasks from pool when possible
-      ctx.onCancel(() => pool.cancelPendingTasks())
+      vitest.onCancel(() => pool.cancelPendingTasks())
 
       const configs = new WeakMap<TestProject, SerializedConfig>()
       const getConfig = (project: TestProject): SerializedConfig => {
@@ -161,7 +161,7 @@ export function createThreadsPool(
           return configs.get(project)!
         }
 
-        const config = project.getSerializableConfig()
+        const config = project.serializedConfig
         configs.set(project, config)
         return config
       }
diff --git a/packages/vitest/src/node/pools/vmForks.ts b/packages/vitest/src/node/pools/vmForks.ts
index dbf34afde474..9a4ff9eca292 100644
--- a/packages/vitest/src/node/pools/vmForks.ts
+++ b/packages/vitest/src/node/pools/vmForks.ts
@@ -48,13 +48,13 @@ function createChildProcessChannel(project: TestProject, collect: boolean) {
     },
   )
 
-  project.ctx.onCancel(reason => rpc.onCancel(reason))
+  project.vitest.onCancel(reason => rpc.onCancel(reason))
 
   return { channel, cleanup }
 }
 
 export function createVmForksPool(
-  ctx: Vitest,
+  vitest: Vitest,
   { execArgv, env }: PoolProcessOptions,
 ): ProcessPool {
   const numCpus
@@ -62,22 +62,22 @@ export function createVmForksPool(
       ? nodeos.availableParallelism()
       : nodeos.cpus().length
 
-  const threadsCount = ctx.config.watch
+  const threadsCount = vitest.config.watch
     ? Math.max(Math.floor(numCpus / 2), 1)
     : Math.max(numCpus - 1, 1)
 
-  const poolOptions = ctx.config.poolOptions?.vmForks ?? {}
+  const poolOptions = vitest.config.poolOptions?.vmForks ?? {}
 
   const maxThreads
-    = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount
+    = poolOptions.maxForks ?? vitest.config.maxWorkers ?? threadsCount
   const minThreads
-    = poolOptions.maxForks ?? ctx.config.minWorkers ?? threadsCount
+    = poolOptions.maxForks ?? vitest.config.minWorkers ?? threadsCount
 
-  const worker = resolve(ctx.distPath, 'workers/vmForks.js')
+  const worker = resolve(vitest.distPath, 'workers/vmForks.js')
 
   const options: TinypoolOptions = {
     runtime: 'child_process',
-    filename: resolve(ctx.distPath, 'worker.js'),
+    filename: resolve(vitest.distPath, 'worker.js'),
 
     maxThreads,
     minThreads,
@@ -92,12 +92,12 @@ export function createVmForksPool(
       ...execArgv,
     ],
 
-    terminateTimeout: ctx.config.teardownTimeout,
+    terminateTimeout: vitest.config.teardownTimeout,
     concurrentTasksPerWorker: 1,
-    maxMemoryLimitBeforeRecycle: getMemoryLimit(ctx.config) || undefined,
+    maxMemoryLimitBeforeRecycle: getMemoryLimit(vitest.config) || undefined,
   }
 
-  if (poolOptions.singleFork || !ctx.config.fileParallelism) {
+  if (poolOptions.singleFork || !vitest.config.fileParallelism) {
     options.maxThreads = 1
     options.minThreads = 1
   }
@@ -115,7 +115,7 @@ export function createVmForksPool(
       invalidates: string[] = [],
     ) {
       const paths = files.map(f => f.filepath)
-      ctx.state.clearFiles(project, paths)
+      vitest.state.clearFiles(project, paths)
 
       const { channel, cleanup } = createChildProcessChannel(project, name === 'collect')
       const workerId = ++id
@@ -139,17 +139,17 @@ export function createVmForksPool(
           error instanceof Error
           && /Failed to terminate worker/.test(error.message)
         ) {
-          ctx.state.addProcessTimeoutCause(
+          vitest.state.addProcessTimeoutCause(
             `Failed to terminate worker while running ${paths.join(', ')}.`,
           )
         }
         // Intentionally cancelled
         else if (
-          ctx.isCancelling
+          vitest.isCancelling
           && error instanceof Error
           && /The task has been cancelled/.test(error.message)
         ) {
-          ctx.state.cancelFiles(paths, project)
+          vitest.state.cancelFiles(paths, project)
         }
         else {
           throw error
@@ -162,7 +162,7 @@ export function createVmForksPool(
 
     return async (specs, invalidates) => {
       // Cancel pending tasks from pool when possible
-      ctx.onCancel(() => pool.cancelPendingTasks())
+      vitest.onCancel(() => pool.cancelPendingTasks())
 
       const configs = new Map<TestProject, SerializedConfig>()
       const getConfig = (project: TestProject): SerializedConfig => {
diff --git a/packages/vitest/src/node/pools/vmThreads.ts b/packages/vitest/src/node/pools/vmThreads.ts
index 5fdfb539a9b9..99f87df2ed3d 100644
--- a/packages/vitest/src/node/pools/vmThreads.ts
+++ b/packages/vitest/src/node/pools/vmThreads.ts
@@ -37,13 +37,13 @@ function createWorkerChannel(project: TestProject, collect: boolean) {
     },
   })
 
-  project.ctx.onCancel(reason => rpc.onCancel(reason))
+  project.vitest.onCancel(reason => rpc.onCancel(reason))
 
   return { workerPort, port }
 }
 
 export function createVmThreadsPool(
-  ctx: Vitest,
+  vitest: Vitest,
   { execArgv, env }: PoolProcessOptions,
 ): ProcessPool {
   const numCpus
@@ -51,21 +51,21 @@ export function createVmThreadsPool(
       ? nodeos.availableParallelism()
       : nodeos.cpus().length
 
-  const threadsCount = ctx.config.watch
+  const threadsCount = vitest.config.watch
     ? Math.max(Math.floor(numCpus / 2), 1)
     : Math.max(numCpus - 1, 1)
 
-  const poolOptions = ctx.config.poolOptions?.vmThreads ?? {}
+  const poolOptions = vitest.config.poolOptions?.vmThreads ?? {}
 
   const maxThreads
-    = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount
+    = poolOptions.maxThreads ?? vitest.config.maxWorkers ?? threadsCount
   const minThreads
-    = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount
+    = poolOptions.minThreads ?? vitest.config.minWorkers ?? threadsCount
 
-  const worker = resolve(ctx.distPath, 'workers/vmThreads.js')
+  const worker = resolve(vitest.distPath, 'workers/vmThreads.js')
 
   const options: TinypoolOptions = {
-    filename: resolve(ctx.distPath, 'worker.js'),
+    filename: resolve(vitest.distPath, 'worker.js'),
     // TODO: investigate further
     // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
     useAtomics: poolOptions.useAtomics ?? false,
@@ -83,12 +83,12 @@ export function createVmThreadsPool(
       ...execArgv,
     ],
 
-    terminateTimeout: ctx.config.teardownTimeout,
+    terminateTimeout: vitest.config.teardownTimeout,
     concurrentTasksPerWorker: 1,
-    maxMemoryLimitBeforeRecycle: getMemoryLimit(ctx.config) || undefined,
+    maxMemoryLimitBeforeRecycle: getMemoryLimit(vitest.config) || undefined,
   }
 
-  if (poolOptions.singleThread || !ctx.config.fileParallelism) {
+  if (poolOptions.singleThread || !vitest.config.fileParallelism) {
     options.maxThreads = 1
     options.minThreads = 1
   }
@@ -106,7 +106,7 @@ export function createVmThreadsPool(
       invalidates: string[] = [],
     ) {
       const paths = files.map(f => f.filepath)
-      ctx.state.clearFiles(project, paths)
+      vitest.state.clearFiles(project, paths)
 
       const { workerPort, port } = createWorkerChannel(project, name === 'collect')
       const workerId = ++id
@@ -131,7 +131,7 @@ export function createVmThreadsPool(
           error instanceof Error
           && /Failed to terminate worker/.test(error.message)
         ) {
-          ctx.state.addProcessTimeoutCause(
+          vitest.state.addProcessTimeoutCause(
             `Failed to terminate worker while running ${paths.join(
               ', ',
             )}. \nSee https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`,
@@ -139,25 +139,25 @@ export function createVmThreadsPool(
         }
         // Intentionally cancelled
         else if (
-          ctx.isCancelling
+          vitest.isCancelling
           && error instanceof Error
           && /The task has been cancelled/.test(error.message)
         ) {
-          ctx.state.cancelFiles(paths, project)
+          vitest.state.cancelFiles(paths, project)
         }
         else {
           throw error
         }
       }
       finally {
-        port.close()
-        workerPort.close()
+        port.unref()
+        workerPort.unref()
       }
     }
 
     return async (specs, invalidates) => {
       // Cancel pending tasks from pool when possible
-      ctx.onCancel(() => pool.cancelPendingTasks())
+      vitest.onCancel(() => pool.cancelPendingTasks())
 
       const configs = new Map<TestProject, SerializedConfig>()
       const getConfig = (project: TestProject): SerializedConfig => {

From 2236579ed2335dd87a36337621d23a6c068371d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ari=20Perkki=C3=B6?= <ari.perkkio@gmail.com>
Date: Thu, 29 May 2025 18:40:18 +0300
Subject: [PATCH 25/30] fix(pool): close ports and channel using
 `channel.onClose`

---
 packages/vitest/package.json              |  2 +-
 packages/vitest/src/node/pools/forks.ts   |  9 +++------
 packages/vitest/src/node/pools/threads.ts | 11 ++++++-----
 pnpm-lock.yaml                            | 10 +++++-----
 test/cli/test/scoped-fixtures.test.ts     | 11 +++++------
 test/test-utils/index.ts                  | 13 +++++++++----
 6 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/packages/vitest/package.json b/packages/vitest/package.json
index c15b8aa6650b..f38b90fda375 100644
--- a/packages/vitest/package.json
+++ b/packages/vitest/package.json
@@ -168,7 +168,7 @@
     "tinybench": "^2.9.0",
     "tinyexec": "^0.3.2",
     "tinyglobby": "catalog:",
-    "tinypool": "https://pkg.pr.new/tinypool@115",
+    "tinypool": "https://pkg.pr.new/tinypool@b0f41a1",
     "tinyrainbow": "catalog:",
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
     "vite-node": "workspace:*",
diff --git a/packages/vitest/src/node/pools/forks.ts b/packages/vitest/src/node/pools/forks.ts
index 8f22be2e4e93..4da3cd1c8cd2 100644
--- a/packages/vitest/src/node/pools/forks.ts
+++ b/packages/vitest/src/node/pools/forks.ts
@@ -19,12 +19,12 @@ import { createMethodsRPC } from './rpc'
 
 function createChildProcessChannel(project: TestProject, collect = false) {
   const emitter = new EventEmitter()
-  const cleanup = () => emitter.removeAllListeners()
 
   const events = { message: 'message', response: 'response' }
   const channel: TinypoolChannel = {
     onMessage: callback => emitter.on(events.message, callback),
     postMessage: message => emitter.emit(events.response, message),
+    onClose: () => emitter.removeAllListeners(),
   }
 
   const rpc = createBirpc<RunnerRPC, RuntimeRPC>(createMethodsRPC(project, { cacheFs: true, collect }), {
@@ -44,7 +44,7 @@ function createChildProcessChannel(project: TestProject, collect = false) {
 
   project.vitest.onCancel(reason => rpc.onCancel(reason))
 
-  return { channel, cleanup }
+  return channel
 }
 
 export function createForksPool(
@@ -110,7 +110,7 @@ export function createForksPool(
       const paths = files.map(f => f.filepath)
       vitest.state.clearFiles(project, paths)
 
-      const { channel, cleanup } = createChildProcessChannel(project, name === 'collect')
+      const channel = createChildProcessChannel(project, name === 'collect')
       const workerId = ++id
       const data: ContextRPC = {
         pool: 'forks',
@@ -148,9 +148,6 @@ export function createForksPool(
           throw error
         }
       }
-      finally {
-        cleanup()
-      }
     }
 
     return async (specs, invalidates) => {
diff --git a/packages/vitest/src/node/pools/threads.ts b/packages/vitest/src/node/pools/threads.ts
index b5318b244025..217073ea983a 100644
--- a/packages/vitest/src/node/pools/threads.ts
+++ b/packages/vitest/src/node/pools/threads.ts
@@ -105,6 +105,11 @@ export function createThreadsPool(
       vitest.state.clearFiles(project, paths)
 
       const { workerPort, port } = createWorkerChannel(project, name === 'collect')
+      const onClose = () => {
+        port.close()
+        workerPort.close()
+      }
+
       const workerId = ++id
       const data: WorkerContext = {
         pool: 'threads',
@@ -119,7 +124,7 @@ export function createThreadsPool(
         providedContext: project.getProvidedContext(),
       }
       try {
-        await pool.run(data, { transferList: [workerPort], name })
+        await pool.run(data, { transferList: [workerPort], name, channel: { onClose } })
       }
       catch (error) {
         // Worker got stuck and won't terminate - this may cause process to hang
@@ -145,10 +150,6 @@ export function createThreadsPool(
           throw error
         }
       }
-      finally {
-        port.unref()
-        workerPort.unref()
-      }
     }
 
     return async (specs, invalidates) => {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 0c5482101a01..08972953086d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1001,8 +1001,8 @@ importers:
         specifier: 'catalog:'
         version: 0.2.14
       tinypool:
-        specifier: https://pkg.pr.new/tinypool@115
-        version: https://pkg.pr.new/tinypool@115
+        specifier: https://pkg.pr.new/tinypool@b0f41a1
+        version: https://pkg.pr.new/tinypool@b0f41a1
       tinyrainbow:
         specifier: 'catalog:'
         version: 2.0.0
@@ -8159,8 +8159,8 @@ packages:
       picocolors:
         optional: true
 
-  tinypool@https://pkg.pr.new/tinypool@115:
-    resolution: {tarball: https://pkg.pr.new/tinypool@115}
+  tinypool@https://pkg.pr.new/tinypool@b0f41a1:
+    resolution: {tarball: https://pkg.pr.new/tinypool@b0f41a1}
     version: 1.0.2
     engines: {node: ^18.0.0 || >=20.0.0}
 
@@ -16477,7 +16477,7 @@ snapshots:
     optionalDependencies:
       picocolors: 1.1.1
 
-  tinypool@https://pkg.pr.new/tinypool@115: {}
+  tinypool@https://pkg.pr.new/tinypool@b0f41a1: {}
 
   tinyrainbow@2.0.0: {}
 
diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index 8aa93cee51c8..c2c69be5392c 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -221,7 +221,7 @@ test('worker fixture works in vmThreads and runs for every file', async () => {
     '2-basic.test.ts': ({ extendedTest }) => {
       extendedTest('test1', ({ worker: _worker }) => {})
     },
-    'vitest.config.ts': {
+    'vitest.config.js': {
       test: {
         globals: true,
         maxWorkers: 1,
@@ -261,7 +261,7 @@ test('worker fixtures in isolated tests init and teardown twice', async () => {
     '2-basic.test.ts': ({ extendedTest }) => {
       extendedTest('test1', ({ worker: _worker }) => {})
     },
-    'vitest.config.ts': {
+    'vitest.config.js': {
       test: {
         globals: true,
         isolate: true,
@@ -285,8 +285,7 @@ test('worker fixtures in isolated tests init and teardown twice', async () => {
   `)
 })
 
-// TODO: no-isolate breaks tests
-test.skip('worker fixture initiates and torn down in different workers', async () => {
+test('worker fixture initiates and torn down in different workers', async () => {
   const { stderr, fixtures, tests } = await runFixtureTests(({ log }) => it.extend<{ worker: string }>({
     worker: [
       async ({}, use) => {
@@ -303,7 +302,7 @@ test.skip('worker fixture initiates and torn down in different workers', async (
     '2-basic.test.ts': ({ extendedTest }) => {
       extendedTest('test1', ({ worker: _worker }) => {})
     },
-    'vitest.config.ts': {
+    'vitest.config.js': {
       test: {
         globals: true,
         isolate: false,
@@ -317,8 +316,8 @@ test.skip('worker fixture initiates and torn down in different workers', async (
   expect(stderr).toBe('')
   expect(fixtures).toMatchInlineSnapshot(`
     ">> fixture | init worker | test1
-    >> fixture | teardown worker | test1
     >> fixture | init worker | test1
+    >> fixture | teardown worker | test1
     >> fixture | teardown worker | test1"
   `)
   expect(tests).toMatchInlineSnapshot(`
diff --git a/test/test-utils/index.ts b/test/test-utils/index.ts
index f320a16e1db8..68e0a02e116e 100644
--- a/test/test-utils/index.ts
+++ b/test/test-utils/index.ts
@@ -75,6 +75,10 @@ export async function runVitest(
     const { reporters, ...rest } = cliOptions
 
     ctx = await startVitest(mode, cliFilters, {
+      // Test cases are already run with multiple forks/threads
+      maxWorkers: 1,
+      minWorkers: 1,
+
       watch: false,
       // "none" can be used to disable passing "reporter" option so that default value is used (it's not same as reporters: ["default"])
       ...(reporters === 'none' ? {} : reporters ? { reporters } : { reporters: ['verbose'] }),
@@ -83,10 +87,6 @@ export async function runVitest(
         NO_COLOR: 'true',
         ...rest.env,
       },
-
-      // Test cases are already run with multiple forks/threads
-      maxWorkers: 1,
-      minWorkers: 1,
     }, {
       ...viteOverrides,
       server: {
@@ -347,6 +347,11 @@ export async function runInlineTests(
   const fs = useFS(root, structure)
   const vitest = await runVitest({
     root,
+    globals: true,
+    isolate: false,
+    maxWorkers: 2,
+    minWorkers: 2,
+    pool: 'threads',
     ...config,
   }, [], 'test', {}, options)
   return {

From 7a921c76aae1c6e119890a63f422528790731708 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Fri, 30 May 2025 19:32:45 +0200
Subject: [PATCH 26/30] test: update tests

---
 test/cli/test/scoped-fixtures.test.ts | 94 ++++++++++-----------------
 test/test-utils/index.ts              |  5 --
 2 files changed, 36 insertions(+), 63 deletions(-)

diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index c2c69be5392c..67affa185585 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -2,6 +2,7 @@
 
 import type { TestAPI } from 'vitest'
 import type { ViteUserConfig } from 'vitest/config'
+import type { UserConfig } from 'vitest/node'
 import type { TestFsStructure } from '../../test-utils'
 import { runInlineTests } from '../../test-utils'
 
@@ -26,8 +27,7 @@ test('test fixture cannot import from file fixture', async () => {
 
       extendedTest('not working', ({ file: _file }) => {})
     },
-    'vitest.config.js': { test: { globals: true } },
-  })
+  }, { globals: true })
   expect(stderr).toContain('cannot use the test fixture "local" inside the file fixture "file"')
 })
 
@@ -117,8 +117,7 @@ test('test fixture cannot import from worker fixture', async () => {
 
       extendedTest('not working', ({ worker: _worker }) => {})
     },
-    'vitest.config.js': { test: { globals: true } },
-  })
+  }, { globals: true })
   expect(stderr).toContain('cannot use the test fixture "local" inside the worker fixture "worker"')
 })
 
@@ -173,8 +172,7 @@ test('worker fixture can import a static value from test fixture', async () => {
         expect(worker).toBe('local')
       })
     },
-    'vitest.config.js': { test: { globals: true } },
-  })
+  }, { globals: true })
   expect(stdout).toContain('basic.test.ts')
   expect(stderr).toBe('')
 })
@@ -198,8 +196,7 @@ test('file fixture can import a static value from test fixture', async () => {
         expect(file).toBe('local')
       })
     },
-    'vitest.config.js': { test: { globals: true } },
-  })
+  }, { globals: true })
   expect(stdout).toContain('basic.test.ts')
   expect(stderr).toBe('')
 })
@@ -221,14 +218,6 @@ test('worker fixture works in vmThreads and runs for every file', async () => {
     '2-basic.test.ts': ({ extendedTest }) => {
       extendedTest('test1', ({ worker: _worker }) => {})
     },
-    'vitest.config.js': {
-      test: {
-        globals: true,
-        maxWorkers: 1,
-        minWorkers: 1,
-        pool: 'vmThreads',
-      },
-    },
   })
 
   expect(stderr).toBe('')
@@ -261,15 +250,11 @@ test('worker fixtures in isolated tests init and teardown twice', async () => {
     '2-basic.test.ts': ({ extendedTest }) => {
       extendedTest('test1', ({ worker: _worker }) => {})
     },
-    'vitest.config.js': {
-      test: {
-        globals: true,
-        isolate: true,
-        maxWorkers: 2,
-        minWorkers: 2,
-        pool: 'threads',
-      },
-    },
+  }, {
+    globals: true,
+    maxWorkers: 1,
+    minWorkers: 1,
+    pool: 'vmThreads',
   })
 
   expect(stderr).toBe('')
@@ -302,15 +287,12 @@ test('worker fixture initiates and torn down in different workers', async () =>
     '2-basic.test.ts': ({ extendedTest }) => {
       extendedTest('test1', ({ worker: _worker }) => {})
     },
-    'vitest.config.js': {
-      test: {
-        globals: true,
-        isolate: false,
-        maxWorkers: 2,
-        minWorkers: 2,
-        pool: 'threads',
-      },
-    },
+  }, {
+    globals: true,
+    isolate: false,
+    maxWorkers: 2,
+    minWorkers: 2,
+    pool: 'threads',
   })
 
   expect(stderr).toBe('')
@@ -343,19 +325,19 @@ test('worker fixture initiates and torn down in one non-isolated worker', async
     '2-basic.test.ts': ({ extendedTest }) => {
       extendedTest('test1', ({ worker: _worker }) => {})
     },
-    'vitest.config.ts': {
-      test: {
-        globals: true,
-        isolate: false,
-        maxWorkers: 1,
-        minWorkers: 1,
-        pool: 'threads',
-      },
-    },
+  }, {
+    globals: true,
+    isolate: false,
+    maxWorkers: 1,
+    minWorkers: 1,
+    pool: 'threads',
   })
 
   expect(stderr).toBe('')
-  expect(fixtures).toMatchInlineSnapshot(`">> fixture | init worker | test1"`)
+  expect(fixtures).toMatchInlineSnapshot(`
+    ">> fixture | init worker | test1
+    >> fixture | teardown worker | test1"
+  `)
   expect(tests).toMatchInlineSnapshot(`
     " ✓ 1-basic.test.ts > test1 <time>
      ✓ 2-basic.test.ts > test1 <time>"
@@ -534,14 +516,10 @@ test.for([
       // doesn't access "file" at all
       extendedTest('[third] test 0', ({}) => {})
     },
-
-    'vitest.config.js': {
-      test: {
-        globals: true,
-        isolate,
-        maxWorkers: 1,
-      },
-    },
+  }, {
+    globals: true,
+    isolate,
+    maxWorkers: 1,
   })
 
   expect(stderr).toBe('')
@@ -555,11 +533,11 @@ test.for([
 
   expect(tests).toMatchInlineSnapshot(`
     " ✓ basic.test.js > [first] test 1 <time>
-     ✓ basic.test.js > test 2 <time>
-     ✓ basic.test.js > test 3 <time>
+     ✓ basic.test.js > suite 1 > suite 2 > [first] test 1 2 1 <time>
      ✓ basic.test.js > suite 1 > test 1 1 <time>
      ✓ basic.test.js > suite 1 > test 1 2 <time>
-     ✓ basic.test.js > suite 1 > suite 2 > [first] test 1 2 1 <time>
+     ✓ basic.test.js > test 2 <time>
+     ✓ basic.test.js > test 3 <time>
      ✓ second.test.js > [second] test 0 <time>
      ✓ second.test.js > [second] test 1 <time>
      ✓ second.test.js > [second] test 2 <time>
@@ -692,8 +670,6 @@ describe('browser tests', () => {
       },
       'vitest.config.js': {
         test: {
-          maxWorkers: 1,
-          minWorkers: 1,
           browser: {
             enabled: true,
             provider: 'playwright',
@@ -726,6 +702,7 @@ describe('browser tests', () => {
 async function runFixtureTests<T>(
   extendedTest: ({ log }: { log: typeof console.log }) => TestAPI<T>,
   fs: Record<string, ((context: { extendedTest: TestAPI<T> }) => unknown) | ViteUserConfig>,
+  config?: UserConfig,
 ) {
   if (typeof fs['vitest.config.js'] === 'object') {
     fs['vitest.config.js'].test!.globals = true
@@ -744,7 +721,7 @@ async function runFixtureTests<T>(
       }
       return acc
     }, {} as TestFsStructure),
-  })
+  }, config)
 
   return {
     stderr,
@@ -759,6 +736,7 @@ function getSuccessTests(stdout: string) {
     .split('\n')
     .filter(f => f.startsWith(' ✓ '))
     .map(f => f.replace(/\dms/, '<time>'))
+    .sort()
     .join('\n')
 }
 
diff --git a/test/test-utils/index.ts b/test/test-utils/index.ts
index b974c2f8396f..0684add738a9 100644
--- a/test/test-utils/index.ts
+++ b/test/test-utils/index.ts
@@ -350,11 +350,6 @@ export async function runInlineTests(
   const fs = useFS(root, structure)
   const vitest = await runVitest({
     root,
-    globals: true,
-    isolate: false,
-    maxWorkers: 2,
-    minWorkers: 2,
-    pool: 'threads',
     ...config,
   }, [], 'test', viteOverrides, options)
   return {

From 684634694d5c6f4661d5aea2867534620ff0cef2 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Fri, 30 May 2025 19:35:57 +0200
Subject: [PATCH 27/30] chore: use a stable sequencer

---
 test/cli/test/scoped-fixtures.test.ts | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index 67affa185585..465af24d29f6 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -2,7 +2,7 @@
 
 import type { TestAPI } from 'vitest'
 import type { ViteUserConfig } from 'vitest/config'
-import type { UserConfig } from 'vitest/node'
+import type { TestSpecification, UserConfig } from 'vitest/node'
 import type { TestFsStructure } from '../../test-utils'
 import { runInlineTests } from '../../test-utils'
 
@@ -533,11 +533,11 @@ test.for([
 
   expect(tests).toMatchInlineSnapshot(`
     " ✓ basic.test.js > [first] test 1 <time>
-     ✓ basic.test.js > suite 1 > suite 2 > [first] test 1 2 1 <time>
-     ✓ basic.test.js > suite 1 > test 1 1 <time>
-     ✓ basic.test.js > suite 1 > test 1 2 <time>
      ✓ basic.test.js > test 2 <time>
      ✓ basic.test.js > test 3 <time>
+     ✓ basic.test.js > suite 1 > test 1 1 <time>
+     ✓ basic.test.js > suite 1 > test 1 2 <time>
+     ✓ basic.test.js > suite 1 > suite 2 > [first] test 1 2 1 <time>
      ✓ second.test.js > [second] test 0 <time>
      ✓ second.test.js > [second] test 1 <time>
      ✓ second.test.js > [second] test 2 <time>
@@ -721,7 +721,7 @@ async function runFixtureTests<T>(
       }
       return acc
     }, {} as TestFsStructure),
-  }, config)
+  }, { ...config, sequence: { sequencer: StableTestFileOrderSorter } })
 
   return {
     stderr,
@@ -736,7 +736,6 @@ function getSuccessTests(stdout: string) {
     .split('\n')
     .filter(f => f.startsWith(' ✓ '))
     .map(f => f.replace(/\dms/, '<time>'))
-    .sort()
     .join('\n')
 }
 
@@ -746,3 +745,13 @@ function getFixtureLogs(stdout: string) {
     .filter(f => f.startsWith('>> fixture |'))
     .join('\n')
 }
+
+class StableTestFileOrderSorter {
+  sort(files: TestSpecification[]) {
+    return files.sort((a, b) => a.moduleId.localeCompare(b.moduleId))
+  }
+
+  shard(files: TestSpecification[]) {
+    return files
+  }
+}

From 705b2c9abd345c470d0786f65a65199a43c6e5fe Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Fri, 30 May 2025 19:46:08 +0200
Subject: [PATCH 28/30] chore: update assertion for parallel tests

---
 test/cli/test/scoped-fixtures.test.ts | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/test/cli/test/scoped-fixtures.test.ts b/test/cli/test/scoped-fixtures.test.ts
index 465af24d29f6..ee31758f2a1c 100644
--- a/test/cli/test/scoped-fixtures.test.ts
+++ b/test/cli/test/scoped-fixtures.test.ts
@@ -285,7 +285,7 @@ test('worker fixture initiates and torn down in different workers', async () =>
       extendedTest('test1', ({ worker: _worker }) => {})
     },
     '2-basic.test.ts': ({ extendedTest }) => {
-      extendedTest('test1', ({ worker: _worker }) => {})
+      extendedTest('test2', ({ worker: _worker }) => {})
     },
   }, {
     globals: true,
@@ -296,16 +296,16 @@ test('worker fixture initiates and torn down in different workers', async () =>
   })
 
   expect(stderr).toBe('')
-  expect(fixtures).toMatchInlineSnapshot(`
-    ">> fixture | init worker | test1
-    >> fixture | init worker | test1
-    >> fixture | teardown worker | test1
-    >> fixture | teardown worker | test1"
-  `)
-  expect(tests).toMatchInlineSnapshot(`
-    " ✓ 1-basic.test.ts > test1 <time>
-     ✓ 2-basic.test.ts > test1 <time>"
-  `)
+
+  // tests run in parallel so we can't guarantee the order
+  expect(fixtures).toContain(`>> fixture | init worker | test1`)
+  expect(fixtures).toContain(`>> fixture | teardown worker | test1`)
+
+  expect(fixtures).toContain(`>> fixture | init worker | test2`)
+  expect(fixtures).toContain(`>> fixture | teardown worker | test2`)
+
+  expect(tests).toContain(' ✓ 1-basic.test.ts > test1 <time>')
+  expect(tests).toContain(' ✓ 2-basic.test.ts > test2 <time>')
 })
 
 test('worker fixture initiates and torn down in one non-isolated worker', async () => {

From 3b275b550360639cf46626f2bdad0eb55a0310b2 Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Fri, 30 May 2025 20:13:08 +0200
Subject: [PATCH 29/30] chore: cleanup

---
 docs/guide/test-context.md                  | 2 +-
 packages/vitest/src/node/pools/forks.ts     | 4 +---
 packages/vitest/src/node/pools/threads.ts   | 4 +---
 packages/vitest/src/node/pools/vmForks.ts   | 4 +---
 packages/vitest/src/node/pools/vmThreads.ts | 4 +---
 5 files changed, 5 insertions(+), 13 deletions(-)

diff --git a/docs/guide/test-context.md b/docs/guide/test-context.md
index 2adbae58029f..310e7d3892db 100644
--- a/docs/guide/test-context.md
+++ b/docs/guide/test-context.md
@@ -373,7 +373,7 @@ describe('another type of schema', () => {
 })
 ```
 
-#### Per-Scope Context <Version>?</Version>
+#### Per-Scope Context <Version>3.2.0</Version>
 
 You can define context that will be initiated once per file or a worker. It is initiated the same way as a regular fixture with an objects parameter:
 
diff --git a/packages/vitest/src/node/pools/forks.ts b/packages/vitest/src/node/pools/forks.ts
index 4da3cd1c8cd2..e3322e71df48 100644
--- a/packages/vitest/src/node/pools/forks.ts
+++ b/packages/vitest/src/node/pools/forks.ts
@@ -282,8 +282,6 @@ export function createForksPool(
     name: 'forks',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
-    close: async () => {
-      await pool.destroy()
-    },
+    close: () => pool.destroy(),
   }
 }
diff --git a/packages/vitest/src/node/pools/threads.ts b/packages/vitest/src/node/pools/threads.ts
index 217073ea983a..5a3c1585839d 100644
--- a/packages/vitest/src/node/pools/threads.ts
+++ b/packages/vitest/src/node/pools/threads.ts
@@ -282,8 +282,6 @@ export function createThreadsPool(
     name: 'threads',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
-    close: async () => {
-      await pool.destroy()
-    },
+    close: () => pool.destroy(),
   }
 }
diff --git a/packages/vitest/src/node/pools/vmForks.ts b/packages/vitest/src/node/pools/vmForks.ts
index 9a4ff9eca292..669fd442e714 100644
--- a/packages/vitest/src/node/pools/vmForks.ts
+++ b/packages/vitest/src/node/pools/vmForks.ts
@@ -207,9 +207,7 @@ export function createVmForksPool(
     name: 'vmForks',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
-    close: async () => {
-      await pool.destroy()
-    },
+    close: () => pool.destroy(),
   }
 }
 
diff --git a/packages/vitest/src/node/pools/vmThreads.ts b/packages/vitest/src/node/pools/vmThreads.ts
index 99f87df2ed3d..197f65201980 100644
--- a/packages/vitest/src/node/pools/vmThreads.ts
+++ b/packages/vitest/src/node/pools/vmThreads.ts
@@ -200,9 +200,7 @@ export function createVmThreadsPool(
     name: 'vmThreads',
     runTests: runWithFiles('run'),
     collectTests: runWithFiles('collect'),
-    close: async () => {
-      await pool.destroy()
-    },
+    close: () => pool.destroy(),
   }
 }
 

From 2bfa3ed7644188427bd7487217d085cbe4ad847c Mon Sep 17 00:00:00 2001
From: Vladimir Sheremet <sleuths.slews0s@icloud.com>
Date: Sat, 31 May 2025 11:32:56 +0200
Subject: [PATCH 30/30] chore: review

---
 packages/runner/src/fixture.ts              | 2 +-
 packages/vitest/src/node/pools/vmThreads.ts | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/runner/src/fixture.ts b/packages/runner/src/fixture.ts
index c57528044cc9..4a0130b2c3a8 100644
--- a/packages/runner/src/fixture.ts
+++ b/packages/runner/src/fixture.ts
@@ -97,7 +97,7 @@ export function mergeContextFixtures<T extends { fixtures?: FixtureItem[] }>(
       if (fixture.scope !== 'test') {
         fixture.deps?.forEach((dep) => {
           if (!dep.isFn) {
-            // non fn fixtures are always resolved an available to anyone
+            // non fn fixtures are always resolved and available to anyone
             return
           }
           // worker scope can only import from worker scope
diff --git a/packages/vitest/src/node/pools/vmThreads.ts b/packages/vitest/src/node/pools/vmThreads.ts
index 197f65201980..ba25f8c819af 100644
--- a/packages/vitest/src/node/pools/vmThreads.ts
+++ b/packages/vitest/src/node/pools/vmThreads.ts
@@ -150,8 +150,8 @@ export function createVmThreadsPool(
         }
       }
       finally {
-        port.unref()
-        workerPort.unref()
+        port.close()
+        workerPort.close()
       }
     }