fix: rename trackProcessAndWorker to autoAttachWorkers

AriPerkkio · AriPerkkio · commit 2eb5e8d5d042 · 2026-04-21T08:47:01.000+03:00
diff --git a/docs/config/coverage.md b/docs/config/coverage.md
@@ -459,12 +459,12 @@ Note that setting this option does not change where coverage HTML report is gene
 
 Collect coverage only for files changed since a specified commit or branch. When set to `true`, it uses staged and unstaged changes.
 
-## coverage.trackProcessAndWorker
+## coverage.autoAttachWorkers <Version type="experimental">4.1.5</Version> {#coverage-autoattachworkers}
 
 - **Type:** `boolean`
 - **Default:** `false`
 - **Available for providers:** `'v8'`
-- **CLI:** `--coverage.trackProcessAndWorker`
+- **CLI:** `--coverage.autoAttachWorkers`
 
 Track coverage of the `node:child_process` and `node:worker_threads` spawned during test run.
 
diff --git a/docs/guide/cli-generated.md b/docs/guide/cli-generated.md
@@ -299,10 +299,10 @@ Apply exclusions again after coverage has been remapped to original sources. (de
 
 Directory of HTML coverage output to be served in UI mode and HTML reporter.
 
-### coverage.trackProcessAndWorker
+### coverage.autoAttachWorkers
 
-- **CLI:** `--coverage.trackProcessAndWorker`
-- **Config:** [coverage.trackProcessAndWorker](/config/coverage#coverage-trackprocessandworker)
+- **CLI:** `--coverage.autoAttachWorkers`
+- **Config:** [coverage.autoAttachWorkers](/config/coverage#coverage-autoattachworkers)
 
 Track coverage of the `node:child_process` and `node:worker_threads` spawned during test run. Supported only by `v8` provider. (default: false)
 
diff --git a/packages/coverage-v8/src/index.ts b/packages/coverage-v8/src/index.ts
@@ -20,14 +20,14 @@ const mod: CoverageProviderModule & {
   extendedContextCoverageDir: undefined,
   session: null,
 
-  async startCoverage({ isolate, trackProcessAndWorker, reportsDirectory }) {
+  async startCoverage({ isolate, autoAttachWorkers, reportsDirectory }) {
     if (isolate === false && enabled) {
       return
     }
 
     enabled = true
 
-    if (trackProcessAndWorker) {
+    if (autoAttachWorkers) {
       this.extendedContextCoverageDir = resolve(reportsDirectory, 'tmp', randomUUID())
       process.env.NODE_V8_COVERAGE = this.extendedContextCoverageDir
     }
diff --git a/packages/coverage-v8/src/provider.ts b/packages/coverage-v8/src/provider.ts
@@ -38,7 +38,7 @@ export class V8CoverageProvider extends BaseCoverageProvider implements Coverage
   initialize(ctx: Vitest): void {
     this._initialize(ctx)
 
-    if (this.options.trackProcessAndWorker) {
+    if (this.options.autoAttachWorkers) {
       const isAnyThreadsPools = ctx.projects.some(p => p.config.pool === 'threads' || p.config.pool === 'vmThreads')
 
       if (isAnyThreadsPools) {
@@ -61,14 +61,14 @@ export class V8CoverageProvider extends BaseCoverageProvider implements Coverage
     const coverageMap = this.createCoverageMap()
     let merged: RawCoverage = { result: [] }
 
-    const trackProcessAndWorker = this.options.trackProcessAndWorker
+    const autoAttachWorkers = this.options.autoAttachWorkers
 
     await this.readCoverageFiles<RawCoverage>({
       onFileRead(coverage) {
         merged = mergeProcessCovs([merged, coverage])
 
-        // mergeProcessCovs sometimes loses trackProcessAndWorker
-        const fromExtendedContext = trackProcessAndWorker ? coverage.result.filter(r => r.isExtendedContext) : []
+        // mergeProcessCovs sometimes loses autoAttachWorkers
+        const fromExtendedContext = autoAttachWorkers ? coverage.result.filter(r => r.isExtendedContext) : []
 
         // mergeProcessCovs sometimes loses startOffset, e.g. in vue
         merged.result.forEach((result) => {
@@ -77,7 +77,7 @@ export class V8CoverageProvider extends BaseCoverageProvider implements Coverage
             result.startOffset = original?.startOffset || 0
           }
 
-          if (trackProcessAndWorker && !result.isExtendedContext) {
+          if (autoAttachWorkers && !result.isExtendedContext) {
             const actual = fromExtendedContext.find(r => r.url === result.url)
             result.isExtendedContext = actual?.isExtendedContext
           }
diff --git a/packages/vitest/src/defaults.ts b/packages/vitest/src/defaults.ts
@@ -53,7 +53,7 @@ export const coverageConfigDefaults: Required<Pick<CoverageOptions, FieldsWithDe
     branches: [50, 80],
     lines: [50, 80],
   },
-  trackProcessAndWorker: false,
+  autoAttachWorkers: false,
 }
 
 export const fakeTimersDefaults: NonNullable<UserConfig['fakeTimers']> = {
diff --git a/packages/vitest/src/integrations/coverage.ts b/packages/vitest/src/integrations/coverage.ts
@@ -12,7 +12,7 @@ export async function startCoverageInsideWorker(
   if (coverageModule) {
     return coverageModule.startCoverage?.({
       ...runtimeOptions,
-      trackProcessAndWorker: options.trackProcessAndWorker,
+      autoAttachWorkers: options.autoAttachWorkers,
       reportsDirectory: options.reportsDirectory,
     })
   }
diff --git a/packages/vitest/src/node/cli/cli-config.ts b/packages/vitest/src/node/cli/cli-config.ts
@@ -326,7 +326,7 @@ export const cliOptionsConfig: VitestCLIOptions = {
         description: 'Directory of HTML coverage output to be served in UI mode and HTML reporter.',
         argument: '<path>',
       },
-      trackProcessAndWorker: {
+      autoAttachWorkers: {
         description: 'Track coverage of the `node:child_process` and `node:worker_threads` spawned during test run. Supported only by `v8` provider. (default: false)',
       },
     },
diff --git a/packages/vitest/src/node/config/serializeConfig.ts b/packages/vitest/src/node/config/serializeConfig.ts
@@ -61,7 +61,7 @@ export function serializeConfig(project: TestProject): SerializedConfig {
           ? coverage.customProviderModule
           : undefined,
         htmlDir: coverage.htmlDir,
-        trackProcessAndWorker: coverage.trackProcessAndWorker ?? false,
+        autoAttachWorkers: coverage.autoAttachWorkers ?? false,
       }
     })(config.coverage),
     fakeTimers: config.fakeTimers,
diff --git a/packages/vitest/src/node/types/coverage.ts b/packages/vitest/src/node/types/coverage.ts
@@ -111,7 +111,7 @@ export type FieldsWithDefaultValues
     | 'ignoreClassMethods'
     | 'skipFull'
     | 'watermarks'
-    | 'trackProcessAndWorker'
+    | 'autoAttachWorkers'
 
 export type ResolvedCoverageOptions
   = CoverageOptions
@@ -271,7 +271,7 @@ export interface CoverageOptions {
    *
    * @default false
    */
-  trackProcessAndWorker?: boolean
+  autoAttachWorkers?: boolean
 
   /**
    * Set to array of class method names to ignore for coverage
diff --git a/packages/vitest/src/runtime/config.ts b/packages/vitest/src/runtime/config.ts
@@ -158,7 +158,7 @@ export interface SerializedCoverageConfig {
   htmlDir: string | undefined
   enabled: boolean
   customProviderModule: string | undefined
-  trackProcessAndWorker: boolean
+  autoAttachWorkers: boolean
 }
 
 export interface SerializedRootConfig extends SerializedConfig {
diff --git a/packages/vitest/src/utils/coverage.ts b/packages/vitest/src/utils/coverage.ts
@@ -18,7 +18,7 @@ export interface RuntimeCoverageProviderModule {
   startCoverage?: (runtimeOptions: {
     isolate: boolean
     /** @internal */
-    trackProcessAndWorker: boolean
+    autoAttachWorkers: boolean
     /** @internal */
     reportsDirectory: string
   }) => unknown | Promise<unknown>
diff --git a/test/coverage-test/test/configuration-options.test-d.ts b/test/coverage-test/test/configuration-options.test-d.ts
@@ -100,7 +100,7 @@ test('provider module', () => {
               branches: [80, 95],
               lines: [80, 95],
             },
-            trackProcessAndWorker: false,
+            autoAttachWorkers: false,
           }
         },
         clean(_?: boolean) {},
diff --git a/test/coverage-test/test/extended-run-context.v8.test.ts b/test/coverage-test/test/extended-run-context.v8.test.ts
@@ -8,15 +8,15 @@ describe.each(['child process', 'worker thread'] as const)('%s', (runtime) => {
   /* See {@link file://./../fixtures/test/worker-thread.test.ts} */
   const filename = `fixtures/test/${runtime.replace(' ', '-')}.test.ts`
 
-  test('{ trackProcessAndWorker: true } typescript source file', async ({ skip }) => {
+  test('{ autoAttachWorkers: true } typescript source file', async ({ skip }) => {
     skip(isTypeStrippingSupported === false, `Type stripping is not supported in Node ${process.version}`)
 
     await runVitest({
       include: [filename],
       testNamePattern: `${runtime} typescript`,
       pool: 'forks',
       coverage: {
-        trackProcessAndWorker: true,
+        autoAttachWorkers: true,
         reporter: 'json',
       },
     })
@@ -42,13 +42,13 @@ describe.each(['child process', 'worker thread'] as const)('%s', (runtime) => {
     assertMath(coverageMap)
   })
 
-  test('{ trackProcessAndWorker: true } javascript source file', async () => {
+  test('{ autoAttachWorkers: true } javascript source file', async () => {
     await runVitest({
       include: [filename],
       testNamePattern: `${runtime} javascript source file`,
       pool: 'forks',
       coverage: {
-        trackProcessAndWorker: true,
+        autoAttachWorkers: true,
         reporter: 'json',
       },
     })
@@ -76,13 +76,13 @@ describe.each(['child process', 'worker thread'] as const)('%s', (runtime) => {
     assertMath(coverageMap, 'math-in-js.js')
   })
 
-  test('{ trackProcessAndWorker: true } pre-transpiled file', async () => {
+  test('{ autoAttachWorkers: true } pre-transpiled file', async () => {
     await runVitest({
       include: [filename],
       testNamePattern: `(${runtime} transpiled javascript with source maps)`,
       pool: 'forks',
       coverage: {
-        trackProcessAndWorker: true,
+        autoAttachWorkers: true,
         reporter: 'json',
       },
     })
@@ -107,13 +107,13 @@ describe.each(['child process', 'worker thread'] as const)('%s', (runtime) => {
     expect.soft(lines[17]).toBe(1)
   })
 
-  test(`{ trackProcessAndWorker: true } nested ${runtime}'s`, async () => {
+  test(`{ autoAttachWorkers: true } nested ${runtime}'s`, async () => {
     await runVitest({
       include: [filename],
       testNamePattern: `(${runtime} inside ${runtime})`,
       pool: 'forks',
       coverage: {
-        trackProcessAndWorker: true,
+        autoAttachWorkers: true,
         reporter: 'json',
       },
     })
@@ -131,12 +131,12 @@ describe.each(['child process', 'worker thread'] as const)('%s', (runtime) => {
     assertMath(coverageMap, 'math-in-js.js')
   })
 
-  test('{ trackProcessAndWorker: false }', async () => {
+  test('{ autoAttachWorkers: false }', async () => {
     await runVitest({
       include: [filename],
       pool: 'forks',
       coverage: {
-        trackProcessAndWorker: false,
+        autoAttachWorkers: false,
         reporter: 'json',
       },
     })

Original file line number	Diff line number	Diff line change
`@@ -20,14 +20,14 @@ const mod: CoverageProviderModule & {`
`20`	`20`	`extendedContextCoverageDir: undefined,`
`21`	`21`	`session: null,`
`22`	`22`
`23`		`- async startCoverage({ isolate, trackProcessAndWorker, reportsDirectory }) {`
	`23`	`+ async startCoverage({ isolate, autoAttachWorkers, reportsDirectory }) {`
`24`	`24`	`if (isolate === false && enabled) {`
`25`	`25`	`return`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`enabled = true`
`29`	`29`
`30`		`- if (trackProcessAndWorker) {`
	`30`	`+ if (autoAttachWorkers) {`
`31`	`31`	`this.extendedContextCoverageDir = resolve(reportsDirectory, 'tmp', randomUUID())`
`32`	`32`	`process.env.NODE_V8_COVERAGE = this.extendedContextCoverageDir`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ export const coverageConfigDefaults: Required<Pick<CoverageOptions, FieldsWithDe`
`53`	`53`	`branches: [50, 80],`
`54`	`54`	`lines: [50, 80],`
`55`	`55`	`},`
`56`		`- trackProcessAndWorker: false,`
	`56`	`+ autoAttachWorkers: false,`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`export const fakeTimersDefaults: NonNullable<UserConfig['fakeTimers']> = {`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ export async function startCoverageInsideWorker(`
`12`	`12`	`if (coverageModule) {`
`13`	`13`	`return coverageModule.startCoverage?.({`
`14`	`14`	`...runtimeOptions,`
`15`		`- trackProcessAndWorker: options.trackProcessAndWorker,`
	`15`	`+ autoAttachWorkers: options.autoAttachWorkers,`
`16`	`16`	`reportsDirectory: options.reportsDirectory,`
`17`	`17`	`})`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ export function serializeConfig(project: TestProject): SerializedConfig {`
`61`	`61`	`? coverage.customProviderModule`
`62`	`62`	`: undefined,`
`63`	`63`	`htmlDir: coverage.htmlDir,`
`64`		`- trackProcessAndWorker: coverage.trackProcessAndWorker ?? false,`
	`64`	`+ autoAttachWorkers: coverage.autoAttachWorkers ?? false,`
`65`	`65`	`}`
`66`	`66`	`})(config.coverage),`
`67`	`67`	`fakeTimers: config.fakeTimers,`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ export interface SerializedCoverageConfig {`
`158`	`158`	`htmlDir: string \| undefined`
`159`	`159`	`enabled: boolean`
`160`	`160`	`customProviderModule: string \| undefined`
`161`		`- trackProcessAndWorker: boolean`
	`161`	`+ autoAttachWorkers: boolean`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`export interface SerializedRootConfig extends SerializedConfig {`