dd-trace 5.110.0 → 5.112.0

package/packages/datadog-instrumentations/src/vitest-main.js

@@ -0,0 +1,1594 @@
+'use strict'
+
+const path = require('node:path')
+const { fileURLToPath } = require('node:url')
+const { MessagePort } = require('node:worker_threads')
+
+const shimmer = require('../../datadog-shimmer')
+const log = require('../../dd-trace/src/log')
+const {
+  VITEST_WORKER_TRACE_PAYLOAD_CODE,
+  VITEST_WORKER_LOGS_PAYLOAD_CODE,
+  getMaxEfdRetryCount,
+  collectTestOptimizationSummariesFromTraces,
+  logTestOptimizationSummary,
+  getTestOptimizationRequestResults,
+  getTestSuitePath,
+  isModifiedTest,
+} = require('../../dd-trace/src/plugins/util/test')
+const { addHook } = require('./helpers/instrument')
+const noWorkerInit = require('./vitest-main-no-worker-init')
+const {
+  testStartCh,
+  testPassCh,
+  testErrorCh,
+  testSkipCh,
+  testSuiteStartCh,
+  testSuiteFinishCh,
+  testSuiteErrorCh,
+  testSessionStartCh,
+  testSessionFinishCh,
+  testSessionConfigurationCh,
+  libraryConfigurationCh,
+  knownTestsCh,
+  isEarlyFlakeDetectionFaultyCh,
+  testManagementTestsCh,
+  modifiedFilesCh,
+  workerReportTraceCh,
+  workerReportLogsCh,
+  codeCoverageReportCh,
+  findExportByName,
+  getChannelPromise,
+  getTypeTasks,
+  getWorkspaceProject,
+  setProvidedContext,
+  getVitestTestProperties,
+} = require('./vitest-util')
+
+const newTestsWithDynamicNames = new Set()
+const attemptToFixExecutions = new Map()
+const workerProcesses = new WeakSet()
+const mainProcessSetupStates = new WeakMap()
+const coverageWrappedProviders = new WeakSet()
+const finishWrappedContexts = new WeakSet()
+let isFlakyTestRetriesEnabled = false
+let flakyTestRetriesCount = 0
+let isEarlyFlakeDetectionEnabled = false
+let earlyFlakeDetectionNumRetries = 0
+let earlyFlakeDetectionSlowTestRetries = {}
+let isEarlyFlakeDetectionFaulty = false
+let isKnownTestsEnabled = false
+let isTestManagementTestsEnabled = false
+let isImpactedTestsEnabled = false
+let testManagementAttemptToFixRetries = 0
+let isDiEnabled = false
+let testCodeCoverageLinesTotal
+let coverageRootDir
+let requestErrorTags = {}
+let isSessionStarted = false
+let isVitestNoWorkerInitActive = false
+let vitestPool = null
+let isMessagePortWrapped = false
+const tinyPoolClassWrappers = new WeakMap()
+
+function getConfiguredEfdRetryCount (slowTestRetries, fallbackRetryCount) {
+  if (!slowTestRetries || !Object.keys(slowTestRetries).length) {
+    return fallbackRetryCount
+  }
+  return getMaxEfdRetryCount(slowTestRetries)
+}
+
+function getTestCommand () {
+  return `vitest ${process.argv.slice(2).join(' ')}`
+}
+
+function isValidKnownTests (receivedKnownTests) {
+  return !!receivedKnownTests.vitest
+}
+
+function isReporterPackage (vitestPackage) {
+  return vitestPackage.B?.name === 'BaseSequencer'
+}
+
+function isReporterPackageNew (vitestPackage) {
+  return vitestPackage.e?.name === 'BaseSequencer'
+}
+
+function isReporterPackageNewest (vitestPackage) {
+  return vitestPackage.h?.name === 'BaseSequencer'
+}
+
+function getBaseSequencerExport (vitestPackage) {
+  return findExportByName(vitestPackage, 'BaseSequencer')
+}
+
+function isCliApiPackage (vitestPackage) {
+  return !!findExportByName(vitestPackage, 'startVitest')
+}
+
+function getVitestExport (vitestPackage) {
+  return findExportByName(vitestPackage, 'Vitest')
+}
+
+function getTypecheckerExport (vitestPackage) {
+  return findExportByName(vitestPackage, 'Typechecker')
+}
+
+function getForksPoolWorkerExport (vitestPackage) {
+  return findExportByName(vitestPackage, 'ForksPoolWorker')
+}
+
+function getThreadsPoolWorkerExport (vitestPackage) {
+  return findExportByName(vitestPackage, 'ThreadsPoolWorker')
+}
+
+function getSessionStatus (state) {
+  if (state.getCountOfFailedTests() > 0) {
+    return 'fail'
+  }
+  if (state.pathsSet.size === 0) {
+    return 'skip'
+  }
+  return 'pass'
+}
+
+function getTestFilepathsFromSpecifications (testSpecifications) {
+  if (!Array.isArray(testSpecifications) || !testSpecifications.length) {
+    return
+  }
+
+  return testSpecifications.map(testSpecification => {
+    const testFile = Array.isArray(testSpecification) ? testSpecification[1] : testSpecification
+    return testFile?.moduleId || testFile?.filepath || testFile
+  })
+}
+
+function getTestSpecificationsKey (testSpecifications) {
+  if (!Array.isArray(testSpecifications) || !testSpecifications.length) return
+
+  const keyParts = []
+  for (const testSpecification of testSpecifications) {
+    const testFile = Array.isArray(testSpecification) ? testSpecification[1] : testSpecification
+    const testFilepath = testFile?.moduleId || testFile?.filepath || testFile
+    if (!testFilepath) continue
+
+    const projectName = getProjectName(getTestSpecificationProject(testSpecification)) || ''
+    const pool = getTestSpecificationPool(testSpecification) || ''
+    keyParts.push(`${projectName}\0${pool}\0${testFilepath}`)
+  }
+
+  if (!keyParts.length) return
+
+  keyParts.sort()
+  return keyParts.join('\0')
+}
+
+function getTestFilepaths (ctx, testSpecifications) {
+  const testFilepaths = getTestFilepathsFromSpecifications(testSpecifications)
+  if (testFilepaths) {
+    return testFilepaths
+  }
+
+  const getFilePaths = ctx.getTestFilepaths || ctx._globTestFilepaths
+  return getFilePaths.call(ctx)
+}
+
+/**
+ * @typedef {{
+ *   isAttemptToFix?: boolean,
+ *   isDisabled?: boolean,
+ *   isQuarantined?: boolean
+ * }} VitestTestManagementProperties
+ *
+ * @typedef {{
+ *   testSuite?: string,
+ *   knownTests?: string[],
+ *   testManagementTests?: Record<string, VitestTestManagementProperties>,
+ *   isModified?: boolean
+ * }} VitestTestProperties
+ */
+
+/**
+ * Normalize a Vitest test file path to the test suite path used by Test Optimization APIs.
+ *
+ * @param {string} testFilepath
+ * @param {string} repositoryRoot
+ * @returns {string}
+ */
+function getNormalizedTestSuitePath (testFilepath, repositoryRoot) {
+  const testSuiteAbsolutePath = path.isAbsolute(testFilepath) ? testFilepath : path.join(repositoryRoot, testFilepath)
+  return getTestSuitePath(testSuiteAbsolutePath, repositoryRoot)
+}
+
+/**
+ * Build simplified Test Management metadata grouped by normalized test suite path.
+ *
+ * @param {{ vitest?: { suites?: Record<string, { tests?: Record<string, { properties?: {
+ *   attempt_to_fix?: boolean,
+ *   disabled?: boolean,
+ *   quarantined?: boolean
+ * } }> }> } }} testManagementTests
+ * @returns {Record<string, Record<string, VitestTestManagementProperties>>}
+ */
+function getTestManagementTestsBySuite (testManagementTests) {
+  const testManagementTestsBySuite = {}
+  const suites = testManagementTests?.vitest?.suites
+  if (!suites) return testManagementTestsBySuite
+
+  for (const [testSuite, suite] of Object.entries(suites)) {
+    const tests = suite?.tests
+    if (!tests) continue
+
+    const testsByName = {}
+    let hasTests = false
+    for (const [testName, test] of Object.entries(tests)) {
+      const properties = test?.properties
+      const testProperties = {
+        isAttemptToFix: properties?.attempt_to_fix,
+        isDisabled: properties?.disabled,
+        isQuarantined: properties?.quarantined,
+      }
+      testsByName[testName] = testProperties
+      hasTests = true
+    }
+    if (hasTests) {
+      testManagementTestsBySuite[testSuite] = testsByName
+    }
+  }
+
+  return testManagementTestsBySuite
+}
+
+/**
+ * Build a set-like object for test suites modified in the current pull request diff.
+ *
+ * @param {Record<string, number[]>|undefined} modifiedFiles
+ * @returns {Record<string, boolean>}
+ */
+function getImpactedTestSuites (modifiedFiles) {
+  const impactedTestSuites = {}
+  if (!modifiedFiles) return impactedTestSuites
+
+  for (const testSuite of Object.keys(modifiedFiles)) {
+    if (isModifiedTest(testSuite, 0, 0, modifiedFiles, 'vitest')) {
+      impactedTestSuites[testSuite] = true
+    }
+  }
+
+  return impactedTestSuites
+}
+
+/**
+ * Build the worker-ready test metadata map keyed by Vitest's absolute filepath.
+ *
+ * @param {string[]} testFilepaths
+ * @param {string} repositoryRoot
+ * @param {Record<string, string[]>|undefined} knownTestsBySuite
+ * @param {Record<string, Record<string, VitestTestManagementProperties>>|undefined} testManagementTestsBySuite
+ * @param {Record<string, boolean>|undefined} impactedTestSuites
+ * @returns {Record<string, VitestTestProperties>}
+ */
+function getTestPropertiesByFilepath (
+  testFilepaths,
+  repositoryRoot,
+  knownTestsBySuite,
+  testManagementTestsBySuite,
+  impactedTestSuites
+) {
+  const testPropertiesByFilepath = {}
+  if (!Array.isArray(testFilepaths)) return testPropertiesByFilepath
+
+  for (const testFilepath of testFilepaths) {
+    if (typeof testFilepath !== 'string') continue
+
+    const testSuite = getNormalizedTestSuitePath(testFilepath, repositoryRoot)
+    const testProperties = { testSuite }
+    const hasProperties = knownTestsBySuite !== undefined ||
+      testManagementTestsBySuite !== undefined ||
+      impactedTestSuites !== undefined
+
+    if (knownTestsBySuite) {
+      testProperties.knownTests = knownTestsBySuite[testSuite] || []
+    }
+    if (testManagementTestsBySuite) {
+      testProperties.testManagementTests = testManagementTestsBySuite[testSuite] || {}
+    }
+    if (impactedTestSuites?.[testSuite]) {
+      testProperties.isModified = true
+    }
+
+    if (hasProperties) {
+      testPropertiesByFilepath[testFilepath] = testProperties
+    }
+  }
+
+  return testPropertiesByFilepath
+}
+
+function wrapCoverageProvider (ctx) {
+  const { coverageProvider } = ctx
+  if (!coverageProvider?.generateCoverage || coverageWrappedProviders.has(coverageProvider)) {
+    return
+  }
+  coverageWrappedProviders.add(coverageProvider)
+
+  // Capture coverage root directory from config (default is 'coverage' in cwd)
+  try {
+    const coverageConfig = ctx.config?.coverage
+    const reportsDirectory = coverageConfig?.reportsDirectory || 'coverage'
+    const rootDir = ctx.config?.root || process.cwd()
+    coverageRootDir = path.isAbsolute(reportsDirectory) ? reportsDirectory : path.join(rootDir, reportsDirectory)
+  } catch {
+    // Fallback to cwd if we can't get config
+    coverageRootDir = process.cwd()
+  }
+
+  shimmer.wrap(coverageProvider, 'generateCoverage', generateCoverage => async function () {
+    const totalCodeCoverage = await generateCoverage.apply(this, arguments)
+
+    try {
+      testCodeCoverageLinesTotal = totalCodeCoverage.getCoverageSummary().lines.pct
+    } catch {
+      // ignore errors
+    }
+    return totalCodeCoverage
+  })
+}
+
+function wrapSessionFinish (ctx) {
+  if (finishWrappedContexts.has(ctx)) {
+    return
+  }
+  finishWrappedContexts.add(ctx)
+
+  shimmer.wrap(ctx, 'exit', getFinishWrapper)
+  shimmer.wrap(ctx, 'close', getFinishWrapper)
+}
+
+function resetLibraryConfig () {
+  isFlakyTestRetriesEnabled = false
+  flakyTestRetriesCount = 0
+  isEarlyFlakeDetectionEnabled = false
+  earlyFlakeDetectionNumRetries = 0
+  earlyFlakeDetectionSlowTestRetries = {}
+  isEarlyFlakeDetectionFaulty = false
+  isDiEnabled = false
+  isKnownTestsEnabled = false
+  isTestManagementTestsEnabled = false
+  isImpactedTestsEnabled = false
+  testManagementAttemptToFixRetries = 0
+}
+
+function applyLibraryConfig (libraryConfig) {
+  isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
+  flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
+  isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
+  earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+  earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
+  isEarlyFlakeDetectionFaulty = false
+  isDiEnabled = libraryConfig.isDiEnabled
+  isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
+  isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
+  testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
+  isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
+}
+
+function resetMainProcessProvidedContext (ctx) {
+  setProvidedContext(ctx, {
+    _ddIsDiEnabled: false,
+    _ddIsEarlyFlakeDetectionEnabled: false,
+    _ddEarlyFlakeDetectionNumRetries: 0,
+    _ddEarlyFlakeDetectionSlowTestRetries: {},
+    _ddIsFlakyTestRetriesEnabled: false,
+    _ddFlakyTestRetriesCount: 0,
+    _ddFlakyTestRetriesIncludesUnnamedProject: false,
+    _ddFlakyTestRetriesProjectNames: undefined,
+    _ddIsImpactedTestsEnabled: false,
+    _ddIsKnownTestsEnabled: false,
+    _ddIsTestManagementTestsEnabled: false,
+    _ddTestManagementAttemptToFixRetries: 0,
+    _ddTestPropertiesByFilepath: {},
+  }, 'Could not reset Test Optimization context for workers.')
+}
+
+/**
+ * Merges request error tags from a Test Optimization request response into the tags propagated by no-worker mode.
+ *
+ * @param {{ requestErrorTags?: Record<string, string> }|undefined} requestResponse - Request response.
+ */
+function mergeRequestErrorTags (requestResponse) {
+  if (requestResponse?.requestErrorTags) {
+    requestErrorTags = {
+      ...requestErrorTags,
+      ...requestResponse.requestErrorTags,
+    }
+  }
+}
+
+async function runMainProcessSetup (ctx, frameworkVersion, testSpecifications, shouldInstallNoWorkerInit) {
+  if (!testSessionFinishCh.hasSubscribers) {
+    return
+  }
+
+  let repositoryRoot = process.cwd()
+  let testSessionConfiguration
+  let testFilepaths
+  let shouldSendTestProperties = false
+  let testPropertiesByFilepath
+  let knownTests
+  let knownTestsBySuite
+  let testManagementTests
+  let testManagementTestsBySuite
+  let modifiedFiles
+  let impactedTestSuites
+  const getCurrentTestFilepaths = async () => {
+    if (testFilepaths === undefined) {
+      testFilepaths = await getTestFilepaths(ctx, testSpecifications)
+    }
+    return testFilepaths
+  }
+
+  try {
+    const {
+      err,
+      libraryConfig,
+      requestErrorTags: receivedRequestErrorTags = {},
+    } = await getChannelPromise(libraryConfigurationCh, frameworkVersion, {
+      isVitestNoWorkerInitActive: shouldInstallNoWorkerInit,
+    })
+    requestErrorTags = receivedRequestErrorTags
+    if (err) {
+      resetLibraryConfig()
+    } else {
+      applyLibraryConfig(libraryConfig)
+    }
+  } catch {
+    requestErrorTags = {}
+    resetLibraryConfig()
+  }
+
+  resetMainProcessProvidedContext(ctx)
+
+  if (testSessionConfigurationCh.hasSubscribers) {
+    testSessionConfiguration = await getChannelPromise(testSessionConfigurationCh, frameworkVersion)
+    const {
+      testSessionId,
+      testModuleId,
+      testCommand,
+      repositoryRoot: receivedRepositoryRoot,
+      codeOwnersEntries,
+      testEnvironmentMetadata,
+    } = testSessionConfiguration
+    repositoryRoot = receivedRepositoryRoot || repositoryRoot
+    if (!shouldInstallNoWorkerInit) {
+      setProvidedContext(ctx, {
+        _ddTestSessionId: testSessionId,
+        _ddTestModuleId: testModuleId,
+        _ddTestCommand: testCommand,
+        _ddRepositoryRoot: repositoryRoot,
+        _ddCodeOwnersEntries: codeOwnersEntries,
+        _ddTestEnvironmentMetadata: testEnvironmentMetadata,
+      }, 'Could not send test session configuration to workers.')
+    }
+  }
+
+  const {
+    knownTestsResponse,
+    testManagementTestsResponse,
+  } = await getTestOptimizationRequestResults({
+    isKnownTestsEnabled,
+    isTestManagementTestsEnabled,
+    getKnownTests: () => getChannelPromise(knownTestsCh),
+    getTestManagementTests: () => getChannelPromise(testManagementTestsCh),
+  })
+  mergeRequestErrorTags(knownTestsResponse)
+  mergeRequestErrorTags(testManagementTestsResponse)
+
+  const flakyTestRetriesConfiguration = configureFlakyTestRetries(ctx, testSpecifications)
+  if (flakyTestRetriesConfiguration) {
+    setProvidedContext(ctx, {
+      _ddIsFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled,
+      _ddFlakyTestRetriesCount: flakyTestRetriesCount,
+      _ddFlakyTestRetriesIncludesUnnamedProject: flakyTestRetriesConfiguration.includesUnnamedProject,
+      _ddFlakyTestRetriesProjectNames: flakyTestRetriesConfiguration.projectNames,
+    }, 'Could not send library configuration to workers.')
+  }
+
+  if (isKnownTestsEnabled) {
+    const currentKnownTestsResponse = knownTestsResponse || await getChannelPromise(knownTestsCh)
+    if (currentKnownTestsResponse.err) {
+      isEarlyFlakeDetectionEnabled = false
+    } else {
+      knownTests = currentKnownTestsResponse.knownTests
+      const currentTestFilepaths = await getCurrentTestFilepaths()
+
+      if (isValidKnownTests(knownTests)) {
+        isEarlyFlakeDetectionFaultyCh.publish({
+          knownTests: knownTests.vitest,
+          testFilepaths: currentTestFilepaths,
+          onDone: (isFaulty) => {
+            isEarlyFlakeDetectionFaulty = isFaulty
+          },
+        })
+        if (isEarlyFlakeDetectionFaulty) {
+          isEarlyFlakeDetectionEnabled = false
+          log.warn('New test detection is disabled because the number of new tests is too high.')
+        } else {
+          knownTestsBySuite = knownTests.vitest
+          shouldSendTestProperties = true
+          if (!shouldInstallNoWorkerInit) {
+            setProvidedContext(ctx, {
+              _ddIsKnownTestsEnabled: isKnownTestsEnabled,
+              _ddIsEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionEnabled,
+              _ddEarlyFlakeDetectionNumRetries:
+                getConfiguredEfdRetryCount(earlyFlakeDetectionSlowTestRetries, earlyFlakeDetectionNumRetries),
+              _ddEarlyFlakeDetectionSlowTestRetries: earlyFlakeDetectionSlowTestRetries,
+            }, 'Could not send known tests to workers so Early Flake Detection will not work.')
+          }
+        }
+      } else {
+        isEarlyFlakeDetectionFaulty = true
+        isEarlyFlakeDetectionEnabled = false
+      }
+    }
+  }
+
+  if (!shouldInstallNoWorkerInit && isDiEnabled) {
+    setProvidedContext(ctx, {
+      _ddIsDiEnabled: isDiEnabled,
+    }, 'Could not send Dynamic Instrumentation configuration to workers.')
+  }
+
+  if (isTestManagementTestsEnabled) {
+    const { err, testManagementTests: receivedTestManagementTests } =
+      testManagementTestsResponse || await getChannelPromise(testManagementTestsCh)
+    if (err) {
+      isTestManagementTestsEnabled = false
+      log.error('Could not get test management tests.')
+    } else {
+      testManagementTests = receivedTestManagementTests
+      testManagementTestsBySuite = getTestManagementTestsBySuite(receivedTestManagementTests)
+      shouldSendTestProperties = true
+      if (!shouldInstallNoWorkerInit) {
+        setProvidedContext(ctx, {
+          _ddIsTestManagementTestsEnabled: isTestManagementTestsEnabled,
+          _ddTestManagementAttemptToFixRetries: testManagementAttemptToFixRetries,
+        }, 'Could not send test management tests to workers so Test Management will not work.')
+      }
+    }
+  }
+
+  if (isImpactedTestsEnabled) {
+    const modifiedFilesResponse = await getChannelPromise(modifiedFilesCh)
+    const { err } = modifiedFilesResponse
+    if (err) {
+      log.error('Could not get modified tests.')
+    } else {
+      modifiedFiles = modifiedFilesResponse.modifiedFiles
+      impactedTestSuites = getImpactedTestSuites(modifiedFiles)
+      shouldSendTestProperties = true
+      if (!shouldInstallNoWorkerInit) {
+        setProvidedContext(ctx, {
+          _ddIsImpactedTestsEnabled: isImpactedTestsEnabled,
+        }, 'Could not send modified tests to workers so Impacted Tests will not work.')
+      }
+    }
+  }
+
+  if (shouldSendTestProperties) {
+    testPropertiesByFilepath = getTestPropertiesByFilepath(
+      await getCurrentTestFilepaths(),
+      repositoryRoot,
+      knownTestsBySuite,
+      testManagementTestsBySuite,
+      impactedTestSuites
+    )
+    if (!shouldInstallNoWorkerInit) {
+      setProvidedContext(ctx, {
+        _ddTestPropertiesByFilepath: testPropertiesByFilepath,
+      }, 'Could not send test properties to workers so some Test Optimization features will not work.')
+    }
+  }
+
+  if (shouldInstallNoWorkerInit) {
+    noWorkerInit.configure(ctx, frameworkVersion, testSpecifications, {
+      knownTests,
+      knownTestsBySuite,
+      modifiedFiles,
+      repositoryRoot,
+      flakyTestRetriesConfiguration,
+      testManagementTests,
+      testManagementTestsBySuite,
+      testPropertiesByFilepath: testPropertiesByFilepath || {},
+      testSessionConfiguration,
+    }, {
+      getConfiguredEfdRetryCount,
+      state: getNoWorkerInitState(),
+    })
+  }
+
+  wrapCoverageProvider(ctx)
+  wrapSessionFinish(ctx)
+  return shouldInstallNoWorkerInit
+}
+
+function getNoWorkerInitState () {
+  return {
+    attemptToFixExecutions,
+    earlyFlakeDetectionNumRetries,
+    earlyFlakeDetectionSlowTestRetries,
+    isEarlyFlakeDetectionEnabled,
+    isEarlyFlakeDetectionFaulty,
+    isFlakyTestRetriesEnabled,
+    isKnownTestsEnabled,
+    newTestsWithDynamicNames,
+    requestErrorTags,
+    testManagementAttemptToFixRetries,
+  }
+}
+
+function ensureMainProcessSetup (ctx, frameworkVersion, testSpecifications, shouldDeactivateOnFallback = false) {
+  const shouldInstallNoWorkerInit = shouldUseNoWorkerInit(ctx, frameworkVersion, testSpecifications)
+  const specificationsKey = getTestSpecificationsKey(testSpecifications)
+  let setupState = mainProcessSetupStates.get(ctx)
+  if (shouldDeactivateOnFallback && setupState?.shouldInstallNoWorkerInit && !shouldInstallNoWorkerInit) {
+    noWorkerInit.deactivate(ctx)
+  }
+  if (
+    !setupState ||
+    setupState.specificationsKey !== specificationsKey ||
+    setupState.shouldInstallNoWorkerInit !== shouldInstallNoWorkerInit
+  ) {
+    setupState = {
+      setupPromise: runMainProcessSetup(ctx, frameworkVersion, testSpecifications, shouldInstallNoWorkerInit),
+      shouldInstallNoWorkerInit,
+      specificationsKey,
+    }
+    mainProcessSetupStates.set(ctx, setupState)
+  }
+  return setupState.setupPromise
+}
+
+function shouldUseNoWorkerInit (ctx, frameworkVersion, testSpecifications) {
+  return noWorkerInit.shouldUse(ctx, frameworkVersion, testSpecifications, {
+    hasVitestWorkerPoolTestSpecification,
+    isVitestWorkerPool,
+  })
+}
+
+function configureFlakyTestRetries (ctx, testSpecifications) {
+  if (!isFlakyTestRetriesEnabled || flakyTestRetriesCount <= 0) return
+
+  let configured = false
+  let includesUnnamedProject = false
+  const projectNames = []
+  for (const { config, projectName } of getVitestProjectConfigs(ctx, testSpecifications)) {
+    if (!config.retry) {
+      config.retry = flakyTestRetriesCount
+      configured = true
+      if (projectName) {
+        projectNames.push(projectName)
+      } else {
+        includesUnnamedProject = true
+      }
+    }
+  }
+
+  if (!configured) return
+
+  return {
+    includesUnnamedProject,
+    projectNames,
+  }
+}
+
+function getVitestProjectConfigs (ctx, testSpecifications) {
+  const entries = []
+
+  addTestSpecificationConfigs(entries, testSpecifications)
+  if (entries.length > 0) {
+    return entries
+  }
+
+  const selectedProjectNames = getSelectedProjectNames()
+  addSelectedInlineProjectConfigs(entries, safeConfig(ctx), selectedProjectNames)
+  addSelectedRuntimeProjectConfigs(entries, ctx?.projects, selectedProjectNames)
+  if (entries.length > 0) {
+    return entries
+  }
+
+  if (Array.isArray(ctx?.projects)) {
+    for (const project of ctx.projects) {
+      addConfig(entries, safeConfig(project), getProjectName(project))
+    }
+    if (entries.length > 0) {
+      return entries
+    }
+  }
+
+  addConfig(entries, safeConfig(ctx))
+  addConfig(entries, safeConfig(safeWorkspaceProject(ctx)))
+
+  return entries
+}
+
+function addTestSpecificationConfigs (entries, testSpecifications) {
+  if (!Array.isArray(testSpecifications)) return
+
+  for (const testSpecification of testSpecifications) {
+    const project = getTestSpecificationProject(testSpecification)
+    addConfig(entries, safeConfig(project), getProjectName(project))
+  }
+}
+
+function addSelectedInlineProjectConfigs (entries, rootConfig, selectedProjectNames) {
+  if (selectedProjectNames.length === 0 || !Array.isArray(rootConfig?.projects)) return
+
+  for (const project of rootConfig.projects) {
+    const config = getInlineProjectConfig(project)
+    const projectName = getProjectName(project)
+    if (selectedProjectNames.includes(projectName)) {
+      addConfig(entries, config, projectName)
+    }
+  }
+}
+
+function addSelectedRuntimeProjectConfigs (entries, projects, selectedProjectNames) {
+  if (selectedProjectNames.length === 0 || !Array.isArray(projects)) return
+
+  for (const project of projects) {
+    const projectName = getProjectName(project)
+    if (selectedProjectNames.includes(projectName)) {
+      addConfig(entries, safeConfig(project), projectName)
+    }
+  }
+}
+
+function getSelectedProjectNames () {
+  const names = []
+  for (let index = 0; index < process.argv.length; index++) {
+    const argument = process.argv[index]
+    if (argument === '--project' && process.argv[index + 1]) {
+      names.push(process.argv[index + 1])
+      index++
+    } else if (argument.startsWith('--project=')) {
+      names.push(argument.slice('--project='.length))
+    }
+  }
+  return names
+}
+
+function getInlineProjectConfig (project) {
+  return project?.test || project
+}
+
+function getProjectName (project) {
+  return normalizeProjectName(project?.name || project?.config?.name || project?.test?.name)
+}
+
+function normalizeProjectName (name) {
+  if (typeof name === 'string') return name
+
+  const label = name?.label
+  return typeof label === 'string' ? label : undefined
+}
+
+function addConfig (entries, config, projectName) {
+  if (config && !entries.some(entry => entry.config === config || (projectName && entry.projectName === projectName))) {
+    entries.push({ config, projectName })
+  }
+}
+
+function safeConfig (project) {
+  let config
+  try {
+    config = project?.config
+  } catch {}
+  return config
+}
+
+function safeWorkspaceProject (ctx) {
+  let project
+  try {
+    project = getWorkspaceProject(ctx)
+  } catch {}
+  return project
+}
+
+function getSortWrapper (sort, frameworkVersion) {
+  return async function () {
+    await ensureMainProcessSetup(this.ctx, frameworkVersion, arguments[0])
+    return sort.apply(this, arguments)
+  }
+}
+
+function getFinishWrapper (exitOrClose) {
+  let isClosed = false
+  return async function () {
+    if (isClosed) { // needed because exit calls close
+      return exitOrClose.apply(this, arguments)
+    }
+    isClosed = true
+
+    if (!testSessionFinishCh.hasSubscribers) {
+      return exitOrClose.apply(this, arguments)
+    }
+
+    let onFinish
+
+    const flushPromise = new Promise(resolve => {
+      onFinish = resolve
+    })
+    const failedSuites = this.state.getFailedFilepaths()
+    let error
+    if (failedSuites.length) {
+      error = new Error(`Test suites failed: ${failedSuites.length}.`)
+    }
+
+    testSessionFinishCh.publish({
+      status: getSessionStatus(this.state),
+      testCodeCoverageLinesTotal,
+      error,
+      isEarlyFlakeDetectionEnabled,
+      isEarlyFlakeDetectionFaulty,
+      isTestManagementTestsEnabled,
+      requestErrorTags,
+      vitestPool,
+      isVitestNoWorkerInitActive,
+      onFinish,
+    })
+
+    logTestOptimizationSummary({ attemptToFixExecutions, newTestsWithDynamicNames })
+
+    await flushPromise
+
+    // If coverage was generated, publish coverage report channel for upload
+    if (coverageRootDir && codeCoverageReportCh.hasSubscribers) {
+      await new Promise((resolve) => {
+        codeCoverageReportCh.publish({ rootDir: coverageRootDir, onDone: resolve })
+      })
+    }
+
+    return exitOrClose.apply(this, arguments)
+  }
+}
+
+function getCliOrStartVitestWrapper (frameworkVersion) {
+  return function (oldCliOrStartVitest) {
+    return function (...args) {
+      if (!testSessionStartCh.hasSubscribers || isSessionStarted) {
+        return oldCliOrStartVitest.apply(this, args)
+      }
+      isSessionStarted = true
+      testSessionStartCh.publish({ command: getTestCommand(), frameworkVersion })
+      return oldCliOrStartVitest.apply(this, args)
+    }
+  }
+}
+
+function isForkPool (pool) {
+  return pool === 'forks' || pool === 'vmForks'
+}
+
+function isThreadPool (pool) {
+  return pool === 'threads' || pool === 'vmThreads'
+}
+
+function isVitestWorkerPool (pool) {
+  return isForkPool(pool) || isThreadPool(pool)
+}
+
+function getTestSpecificationProject (testSpecification) {
+  if (Array.isArray(testSpecification)) {
+    return testSpecification[0]
+  }
+  return testSpecification?.project
+}
+
+function getTestSpecificationOptions (testSpecification) {
+  if (Array.isArray(testSpecification)) {
+    return testSpecification[2]
+  }
+  return testSpecification
+}
+
+function getTestSpecificationPool (testSpecification) {
+  const options = getTestSpecificationOptions(testSpecification)
+  const project = getTestSpecificationProject(testSpecification)
+  return options?.pool || project?.config?.pool || project?.serializedConfig?.pool || project?.pool ||
+    testSpecification?.pool
+}
+
+function hasVitestWorkerPoolTestSpecification (testSpecifications) {
+  if (!Array.isArray(testSpecifications)) {
+    return false
+  }
+
+  for (const testSpecification of testSpecifications) {
+    if (isVitestWorkerPool(getTestSpecificationPool(testSpecification))) {
+      return true
+    }
+  }
+
+  return false
+}
+
+function shouldMarkVitestWorkerEnv (pool, testSpecifications, shouldSkipWorkerInit) {
+  if (!shouldSkipWorkerInit) {
+    return isVitestWorkerPool(pool) || hasVitestWorkerPoolTestSpecification(testSpecifications) ||
+      (!testSpecifications && pool === undefined)
+  }
+
+  return isVitestWorkerPool(pool) || pool === undefined || hasVitestWorkerPoolTestSpecification(testSpecifications)
+}
+
+function markVitestWorkerEnv (ctx, testSpecifications, shouldSkipWorkerInit = false) {
+  const config = ctx?.config
+  isVitestNoWorkerInitActive = shouldSkipWorkerInit
+  if (!config || !shouldMarkVitestWorkerEnv(config.pool, testSpecifications, shouldSkipWorkerInit)) {
+    return
+  }
+  config.env = getVitestWorkerEnv(config.env, shouldSkipWorkerInit)
+}
+
+function wrapVitestRunFiles (Vitest, frameworkVersion) {
+  if (!Vitest?.prototype?.runFiles) {
+    return
+  }
+
+  shimmer.wrap(Vitest.prototype, 'runFiles', runFiles => async function (testSpecifications) {
+    const shouldSkipWorkerInit = await ensureMainProcessSetup(this, frameworkVersion, testSpecifications, true)
+    markVitestWorkerEnv(this, testSpecifications, shouldSkipWorkerInit)
+    return runFiles.apply(this, arguments)
+  })
+
+  if (Vitest.prototype.collectTests) {
+    shimmer.wrap(Vitest.prototype, 'collectTests', collectTests => function (testSpecifications) {
+      const shouldSkipWorkerInit = shouldUseNoWorkerInit(this, frameworkVersion, testSpecifications)
+      markVitestWorkerEnv(this, testSpecifications, shouldSkipWorkerInit)
+      return collectTests.apply(this, arguments)
+    })
+  }
+}
+
+function getTypecheckTaskStatus (task) {
+  const state = task.result?.state
+  if (state === 'fail') return 'fail'
+  if (state === 'skip' || task.mode === 'skip' || task.mode === 'todo') return 'skip'
+  return 'pass'
+}
+
+/**
+ * Return whether a typecheck suite name represents the synthetic file-level suite.
+ *
+ * @param {string|undefined} suiteName
+ * @param {string} testSuiteAbsolutePath
+ * @returns {boolean}
+ */
+function isTypecheckFileSuiteName (suiteName, testSuiteAbsolutePath) {
+  if (!suiteName || !testSuiteAbsolutePath) return false
+
+  const normalizedSuiteName = path.normalize(suiteName).replaceAll('\\', '/')
+  const normalizedSuitePath = path.normalize(testSuiteAbsolutePath).replaceAll('\\', '/')
+
+  return normalizedSuitePath === normalizedSuiteName || normalizedSuitePath.endsWith(`/${normalizedSuiteName}`)
+}
+
+/**
+ * Return a typecheck test name with describe/suite prefixes and without the file-level suite prefix.
+ *
+ * @param {object} task
+ * @param {string} testSuiteAbsolutePath
+ * @returns {string}
+ */
+function getTypecheckTestName (task, testSuiteAbsolutePath) {
+  let testName = task.name || task.fullTestName
+  let currentTask = task.suite
+
+  while (currentTask) {
+    if (currentTask.name && !isTypecheckFileSuiteName(currentTask.name, testSuiteAbsolutePath)) {
+      testName = `${currentTask.name} ${testName}`
+    }
+    currentTask = currentTask.suite
+  }
+
+  return testName
+}
+
+/**
+ * Return Test Optimization metadata prepared in Vitest's main process setup.
+ *
+ * @param {object|undefined} ctx
+ * @returns {{ testPropertiesByFilepath: object }}
+ */
+function getMainProcessProvidedContext (ctx) {
+  try {
+    const workspaceProject = getWorkspaceProject(ctx)
+    const providedContext = workspaceProject.getProvidedContext?.() || workspaceProject._provided || {}
+
+    return {
+      testPropertiesByFilepath: providedContext._ddTestPropertiesByFilepath || {},
+    }
+  } catch {
+    return {
+      testPropertiesByFilepath: {},
+    }
+  }
+}
+
+/**
+ * Return the Vitest context that owns a Typechecker instance.
+ *
+ * @param {object} typechecker
+ * @returns {object|undefined}
+ */
+function getTypecheckerVitestContext (typechecker) {
+  return typechecker.ctx || typechecker.project?.vitest
+}
+
+/**
+ * Apply Test Management result semantics to Vitest's returned typecheck task result.
+ *
+ * @param {object} task
+ * @param {string} status
+ * @param {{
+ *   isAttemptToFix: boolean,
+ *   isDisabled: boolean,
+ *   isQuarantined: boolean
+ * }} testManagement
+ */
+function updateTypecheckTaskResultForTestManagement (task, status, testManagement) {
+  const { isAttemptToFix, isDisabled, isQuarantined } = testManagement
+  if (isAttemptToFix || !task.result) return
+
+  if (isDisabled) {
+    task.mode = 'skip'
+    task.result.state = 'skip'
+    task.result.errors = []
+    return
+  }
+
+  if (isQuarantined && status === 'fail') {
+    task.result.state = 'pass'
+    task.result.errors = []
+  }
+}
+
+/**
+ * Recompute suite/file typecheck results after Test Management rewrites child test results.
+ *
+ * @param {object} task
+ * @returns {string}
+ */
+function updateTypecheckTaskTreeResult (task) {
+  if (!Array.isArray(task.tasks)) return getTypecheckTaskStatus(task)
+
+  let hasPassedTest = false
+  let hasSkippedTest = false
+  for (const childTask of task.tasks) {
+    const status = updateTypecheckTaskTreeResult(childTask)
+    if (status === 'fail') {
+      task.result = {
+        ...task.result,
+        state: 'fail',
+      }
+      return 'fail'
+    }
+    if (status === 'skip') {
+      hasSkippedTest = true
+    } else {
+      hasPassedTest = true
+    }
+  }
+
+  if (task.result?.errors?.length) return 'fail'
+  if (!hasPassedTest && !hasSkippedTest) return getTypecheckTaskStatus(task)
+
+  task.result = {
+    ...task.result,
+    state: hasPassedTest ? 'pass' : 'skip',
+    errors: [],
+  }
+  return task.result.state
+}
+
+/**
+ * Recompute the aggregate typecheck result after Test Management rewrites file results.
+ *
+ * @param {{
+ *   files?: object[],
+ *   errors?: object[],
+ *   diagnostics?: object[],
+ *   sourceErrors?: object[],
+ *   state?: string
+ * }} result
+ * @returns {boolean}
+ */
+function updateTypecheckResult (result) {
+  if (result.sourceErrors?.length) return false
+
+  let hasPassedFile = false
+  let hasSkippedFile = false
+  for (const file of result.files) {
+    const status = getTypecheckTaskStatus(file)
+    if (status === 'fail') return false
+    if (status === 'skip') {
+      hasSkippedFile = true
+    } else {
+      hasPassedFile = true
+    }
+  }
+
+  if (!hasPassedFile && !hasSkippedFile) return false
+
+  result.state = hasPassedFile ? 'pass' : 'skip'
+  result.errors = []
+  result.diagnostics = []
+  result.sourceErrors = []
+  return true
+}
+
+/**
+ * Clear Vitest's typechecker exit code after all typecheck failures were handled by Test Management.
+ *
+ * @param {{ process?: { exitCode?: number|null } }} typechecker
+ */
+function clearTypecheckerExitCode (typechecker) {
+  if (typechecker?.process?.exitCode == null) return
+
+  typechecker.process.exitCode = 0
+}
+
+function reportTypecheckTest (task, testSuiteAbsolutePath, providedContext) {
+  const testName = getTypecheckTestName(task, testSuiteAbsolutePath)
+  const testProperties = getVitestTestProperties(providedContext, testSuiteAbsolutePath, testName)
+  const isAttemptToFix = testProperties.isAttemptToFix === true
+  const isDisabled = testProperties.isDisabled === true
+  const isQuarantined = testProperties.isQuarantined === true
+  const isModified = testProperties.isModified === true
+  const isSkippedByTestManagement = !isAttemptToFix && isDisabled
+  const status = getTypecheckTaskStatus(task)
+
+  if (status === 'skip' || isSkippedByTestManagement) {
+    testSkipCh.publish({
+      testName,
+      testSuiteAbsolutePath,
+      isNew: testProperties.isNew,
+      isDisabled,
+    })
+    updateTypecheckTaskResultForTestManagement(task, status, { isAttemptToFix, isDisabled, isQuarantined })
+    return
+  }
+
+  const ctx = {
+    testName,
+    testSuiteAbsolutePath,
+    isRetry: false,
+    isNew: testProperties.isNew,
+    hasDynamicName: false,
+    mightHitProbe: false,
+    isAttemptToFix,
+    isDisabled,
+    isQuarantined,
+    isModified,
+  }
+  testStartCh.runStores(ctx, () => {})
+
+  const finalStatus = !isAttemptToFix && isQuarantined ? 'skip' : undefined
+  if (status === 'fail') {
+    testErrorCh.publish({
+      error: task.result?.errors?.[0],
+      finalStatus,
+      ...ctx.currentStore,
+    })
+  } else {
+    testPassCh.publish({
+      task,
+      finalStatus,
+      ...ctx.currentStore,
+    })
+  }
+  updateTypecheckTaskResultForTestManagement(task, status, { isAttemptToFix, isDisabled, isQuarantined })
+}
+
+async function reportTypecheckFile (file, sessionConfiguration, frameworkVersion, providedContext) {
+  const testSuiteAbsolutePath = file.filepath
+  const testSuiteCtx = {
+    testSuiteAbsolutePath,
+    frameworkVersion,
+    testSessionId: sessionConfiguration.testSessionId,
+    testModuleId: sessionConfiguration.testModuleId,
+    testCommand: sessionConfiguration.testCommand,
+    repositoryRoot: sessionConfiguration.repositoryRoot,
+    codeOwnersEntries: sessionConfiguration.codeOwnersEntries,
+  }
+  testSuiteStartCh.runStores(testSuiteCtx, () => {})
+
+  for (const task of getTypeTasks(file.tasks)) {
+    reportTypecheckTest(task, testSuiteAbsolutePath, providedContext)
+  }
+  updateTypecheckTaskTreeResult(file)
+
+  const testSuiteError = file.result?.errors?.[0]
+  if (testSuiteError) {
+    testSuiteCtx.error = testSuiteError
+    testSuiteErrorCh.runStores(testSuiteCtx, () => {})
+  }
+
+  let onFinish
+  const onFinishPromise = new Promise(resolve => {
+    onFinish = resolve
+  })
+  testSuiteFinishCh.publish({
+    status: getTypecheckTaskStatus(file),
+    onFinish,
+    ...testSuiteCtx.currentStore,
+  })
+  await onFinishPromise
+}
+
+async function reportTypecheckResults (result, frameworkVersion, ctx, typechecker) {
+  if (!testSuiteFinishCh.hasSubscribers) return
+  if (!Array.isArray(result?.files)) return
+
+  if (ctx) {
+    await ensureMainProcessSetup(ctx, frameworkVersion, result.files)
+  }
+  const providedContext = getMainProcessProvidedContext(ctx)
+  const sessionConfiguration = testSessionConfigurationCh.hasSubscribers
+    ? await getChannelPromise(testSessionConfigurationCh, frameworkVersion)
+    : {}
+
+  await Promise.all(result.files.map(file => reportTypecheckFile(
+    file,
+    sessionConfiguration,
+    frameworkVersion,
+    providedContext
+  )))
+  if (updateTypecheckResult(result)) {
+    clearTypecheckerExitCode(typechecker)
+  }
+}
+
+function wrapTypechecker (Typechecker, frameworkVersion) {
+  if (!Typechecker?.prototype?.prepareResults) return
+
+  shimmer.wrap(Typechecker.prototype, 'prepareResults', prepareResults => async function () {
+    const result = await prepareResults.apply(this, arguments)
+    await reportTypecheckResults(result, frameworkVersion, getTypecheckerVitestContext(this), this)
+    return result
+  })
+}
+
+function getTypecheckerWrapper (vitestPackage, frameworkVersion) {
+  const typechecker = getTypecheckerExport(vitestPackage)
+  if (typechecker) {
+    wrapTypechecker(typechecker.value, frameworkVersion)
+  }
+  return vitestPackage
+}
+
+function getCreateCliWrapper (vitestPackage, frameworkVersion) {
+  const createCliExport = findExportByName(vitestPackage, 'createCLI')
+  if (!createCliExport) {
+    return vitestPackage
+  }
+  shimmer.wrap(vitestPackage, createCliExport.key, getCliOrStartVitestWrapper(frameworkVersion))
+
+  return vitestPackage
+}
+
+function threadHandler (thread) {
+  const { runtime } = thread
+  let workerProcess
+  if (runtime === 'child_process') {
+    vitestPool = 'child_process'
+    workerProcess = thread.process
+  } else if (runtime === 'worker_threads') {
+    vitestPool = 'worker_threads'
+    workerProcess = thread.thread
+  } else {
+    vitestPool = 'unknown'
+  }
+  if (!workerProcess) {
+    log.error('Vitest error: could not get process or thread from TinyPool#run')
+    return
+  }
+
+  if (workerProcesses.has(workerProcess)) {
+    return
+  }
+  workerProcesses.add(workerProcess)
+  workerProcess.on('message', (message) => {
+    if (message.__tinypool_worker_message__ && message.data) {
+      handleWorkerReport(message.interprocessCode, message.data)
+    }
+  })
+}
+
+function isVitestTinypoolOptions (options) {
+  if (options?.env?.VITEST !== 'true' || typeof options.filename !== 'string') return false
+
+  let filename = options.filename
+  if (filename.startsWith('file:')) {
+    try {
+      filename = fileURLToPath(filename)
+    } catch {
+      return false
+    }
+  }
+
+  const workerPath = path.normalize(filename)
+  const workerDir = path.dirname(workerPath)
+  const packageDir = path.dirname(workerDir)
+
+  return path.basename(workerPath) === 'worker.js' &&
+    path.basename(workerDir) === 'dist' &&
+    path.basename(packageDir) === 'vitest'
+}
+
+function markVitestTinypoolOptions (options) {
+  if (!isVitestTinypoolOptions(options)) return
+
+  options.env = getVitestWorkerEnv(options.env, isVitestNoWorkerInitActive)
+}
+
+function getVitestWorkerEnv (env = {}, shouldSkipWorkerInit = false) {
+  return noWorkerInit.configureWorkerEnv({
+    ...env,
+    DD_VITEST_WORKER: '1',
+  }, shouldSkipWorkerInit)
+}
+
+function wrapTinyPoolRun (TinyPool) {
+  if (!TinyPool?.prototype?.run) return
+
+  shimmer.wrap(TinyPool.prototype, 'run', run => async function () {
+    // We have to do this before and after because the threads list gets recycled, that is, the processes are re-created
+    // eslint-disable-next-line unicorn/no-array-for-each
+    this.threads.forEach(threadHandler)
+    const runResult = await run.apply(this, arguments)
+    // eslint-disable-next-line unicorn/no-array-for-each
+    this.threads.forEach(threadHandler)
+    return runResult
+  })
+}
+
+function wrapTinyPoolClass (TinyPool) {
+  if (typeof TinyPool !== 'function') return TinyPool
+
+  const wrappedTinyPool = tinyPoolClassWrappers.get(TinyPool)
+  if (wrappedTinyPool) return wrappedTinyPool
+
+  class DatadogTinyPool extends TinyPool {
+    constructor (options) {
+      markVitestTinypoolOptions(options)
+      super(options)
+    }
+  }
+
+  tinyPoolClassWrappers.set(TinyPool, DatadogTinyPool)
+  wrapTinyPoolRun(DatadogTinyPool)
+
+  return DatadogTinyPool
+}
+
+function wrapTinyPool (TinyPool) {
+  if (typeof TinyPool === 'function') {
+    return wrapTinyPoolClass(TinyPool)
+  }
+
+  const defaultTinyPool = wrapTinyPoolClass(TinyPool?.default)
+  if (defaultTinyPool) {
+    TinyPool.default = defaultTinyPool
+  }
+
+  const namedTinyPool = TinyPool?.Tinypool === TinyPool?.default
+    ? defaultTinyPool
+    : wrapTinyPoolClass(TinyPool?.Tinypool)
+  if (namedTinyPool) {
+    TinyPool.Tinypool = namedTinyPool
+  }
+
+  return TinyPool
+}
+
+function getWrappedOn (on) {
+  return function (event, callback) {
+    if (event !== 'message') {
+      return on.apply(this, arguments)
+    }
+    // `arguments[1]` is the callback function, which
+    // we modify to intercept our messages to not interfere
+    // with vitest's own messages
+    arguments[1] = shimmer.wrapFunction(callback, callback => function (message) {
+      if (message.type !== 'Buffer' && Array.isArray(message)) {
+        const [interprocessCode, data] = message
+        if (handleWorkerReport(interprocessCode, data)) {
+          // If we execute the callback vitest crashes, as the message is not supported
+          return
+        }
+      }
+      return callback.apply(this, arguments)
+    })
+    return on.apply(this, arguments)
+  }
+}
+
+function handleWorkerReport (interprocessCode, data) {
+  if (interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
+    collectTestOptimizationSummariesFromTraces(data, {
+      newTestsWithDynamicNames,
+      attemptToFixExecutions,
+    })
+    workerReportTraceCh.publish(data)
+    return true
+  }
+
+  if (interprocessCode === VITEST_WORKER_LOGS_PAYLOAD_CODE) {
+    workerReportLogsCh.publish(data)
+    return true
+  }
+
+  return false
+}
+
+function wrapMessagePortOn () {
+  if (isMessagePortWrapped) return
+
+  isMessagePortWrapped = true
+  shimmer.wrap(MessagePort.prototype, 'on', getWrappedOn)
+  shimmer.wrap(MessagePort.prototype, 'addListener', getWrappedOn)
+}
+
+function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
+  if (!isCliApiPackage(cliApiPackage)) {
+    return cliApiPackage
+  }
+  const startVitestExport = findExportByName(cliApiPackage, 'startVitest')
+  shimmer.wrap(cliApiPackage, startVitestExport.key, getCliOrStartVitestWrapper(frameworkVersion))
+  wrapMessagePortOn()
+
+  const vitest = getVitestExport(cliApiPackage)
+  if (vitest) {
+    wrapVitestRunFiles(vitest.value, frameworkVersion)
+  }
+
+  const forksPoolWorker = getForksPoolWorkerExport(cliApiPackage)
+  if (forksPoolWorker) {
+    // function is async
+    shimmer.wrap(forksPoolWorker.value.prototype, 'start', start => function (...args) {
+      vitestPool = 'child_process'
+      this.env = getVitestWorkerEnv(this.env, isVitestNoWorkerInitActive)
+
+      return start.apply(this, args)
+    })
+    shimmer.wrap(forksPoolWorker.value.prototype, 'on', getWrappedOn)
+  }
+
+  const threadsPoolWorker = getThreadsPoolWorkerExport(cliApiPackage)
+  if (threadsPoolWorker) {
+    // function is async
+    shimmer.wrap(threadsPoolWorker.value.prototype, 'start', start => function (...args) {
+      vitestPool = 'worker_threads'
+      this.env = getVitestWorkerEnv(this.env, isVitestNoWorkerInitActive)
+      return start.apply(this, args)
+    })
+    shimmer.wrap(threadsPoolWorker.value.prototype, 'on', getWrappedOn)
+  }
+  return cliApiPackage
+}
+
+addHook({
+  name: 'tinypool',
+  // version from tinypool@0.8 was used in vitest@1.6.0
+  versions: ['>=0.8.0'],
+}, (TinyPool) => {
+  return wrapTinyPool(TinyPool)
+})
+
+// There are multiple index* files across different versions of vitest,
+// so we check for the existence of BaseSequencer to determine if we are in the right file
+addHook({
+  name: 'vitest',
+  versions: ['>=1.6.0 <2.0.0'],
+  filePattern: 'dist/vendor/index.*',
+}, (vitestPackage) => {
+  if (isReporterPackage(vitestPackage)) {
+    shimmer.wrap(vitestPackage.B.prototype, 'sort', getSortWrapper)
+  }
+
+  return vitestPackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=2.0.0 <2.0.5'],
+  filePattern: 'dist/vendor/index.*',
+}, (vitestPackage) => {
+  if (isReporterPackageNew(vitestPackage)) {
+    shimmer.wrap(vitestPackage.e.prototype, 'sort', getSortWrapper)
+  }
+
+  return vitestPackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=2.0.5 <2.1.0'],
+  filePattern: 'dist/chunks/index.*',
+}, (vitestPackage) => {
+  if (isReporterPackageNewest(vitestPackage)) {
+    shimmer.wrap(vitestPackage.h.prototype, 'sort', getSortWrapper)
+  }
+
+  return vitestPackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=3.2.0 <4.0.0'],
+  filePattern: 'dist/chunks/typechecker.*',
+}, getTypecheckerWrapper)
+
+addHook({
+  name: 'vitest',
+  versions: ['>=4.0.0'],
+  filePattern: 'dist/chunks/index.*',
+}, getTypecheckerWrapper)
+
+addHook({
+  name: 'vitest',
+  versions: ['>=2.1.0 <3.0.0'],
+  filePattern: 'dist/chunks/RandomSequencer.*',
+}, (randomSequencerPackage) => {
+  shimmer.wrap(randomSequencerPackage.B.prototype, 'sort', getSortWrapper)
+  return randomSequencerPackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=3.0.9'],
+  filePattern: 'dist/chunks/coverage.*',
+}, (coveragePackage) => {
+  const baseSequencer = getBaseSequencerExport(coveragePackage)
+  if (baseSequencer) {
+    shimmer.wrap(baseSequencer.value.prototype, 'sort', getSortWrapper)
+  }
+  return coveragePackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=3.0.0 <3.0.9'],
+  filePattern: 'dist/chunks/resolveConfig.*',
+}, (resolveConfigPackage) => {
+  shimmer.wrap(resolveConfigPackage.B.prototype, 'sort', getSortWrapper)
+  return resolveConfigPackage
+})
+
+// Can't specify file because compiled vitest includes hashes in their files
+// Following 3 wrappers are for test session start
+addHook({
+  name: 'vitest',
+  versions: ['>=1.6.0 <2.0.5'],
+  filePattern: 'dist/vendor/cac.*',
+}, getCreateCliWrapper)
+
+addHook({
+  name: 'vitest',
+  versions: ['>=2.0.5'],
+  filePattern: 'dist/chunks/cac.*',
+}, getCreateCliWrapper)
+
+addHook({
+  name: 'vitest',
+  versions: ['>=1.6.0 <2.0.5'],
+  filePattern: 'dist/vendor/cli-api.*',
+}, getStartVitestWrapper)
+
+addHook({
+  name: 'vitest',
+  versions: ['>=2.0.5'],
+  filePattern: 'dist/chunks/cli-api.*',
+}, getStartVitestWrapper)