jest.js

'use strict'

// Capture real timers at module load time, before any test can install fake timers.
const realClearTimeout = clearTimeout
const realSetTimeout = setTimeout

const { readFileSync } = require('node:fs')
const { builtinModules, createRequire } = require('node:module')
const { performance } = require('node:perf_hooks')
const path = require('path')
const satisfies = require('../../../vendor/dist/semifies')
const { DD_MAJOR } = require('../../../version')
const shimmer = require('../../datadog-shimmer')
const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
const log = require('../../dd-trace/src/log')
const {
  EMPTY_EFD_RETRY_POLICY,
  getEfdRetryCountForDuration,
  hasEfdRetries,
} = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
const {
  getCoveredFilesFromCoverage,
  getExecutableFilesFromCoverage,
  JEST_WORKER_TRACE_PAYLOAD_CODE,
  JEST_WORKER_COVERAGE_PAYLOAD_CODE,
  JEST_WORKER_TELEMETRY_PAYLOAD_CODE,
  JEST_WORKER_QUARANTINE_PAYLOAD_CODE,
  getTestLineStart,
  getTestSuitePath,
  getTestParametersString,
  getIsFaultyEarlyFlakeDetection,
  JEST_WORKER_LOGS_PAYLOAD_CODE,
  getTestEndLine,
  isModifiedTest,
  DYNAMIC_NAME_RE,
  collectDynamicNamesFromTraces,
  recordTestManagementExecution,
  recordAttemptToFixExecution,
  logAttemptToFixTestExecution,
  logTestOptimizationSummary,
  TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE,
  getTestCoverageLinesPercentage,
  applySkippedCoverageToCoverage,
  getTestOptimizationRequestResults,
} = require('../../dd-trace/src/plugins/util/test')
const {
  getFormattedJestTestParameters,
  getJestTestName,
  getRawJestTestName,
  getJestSuitesToRun,
  removeSeedSuffixFromTestName,
} = require('../../dd-trace/src/plugins/util/jest')
const {
  addCoverageBackfillUntestedFiles,
  getCoverageBackfillFiles,
} = require('./jest/coverage-backfill')
const {
  getChannelPromise,
  publishWithCompletion,
} = require('./helpers/channel')
const { addHook, channel } = require('./helpers/instrument')

const testSessionStartCh = channel('ci:jest:session:start')
const testSessionFinishCh = channel('ci:jest:session:finish')
const codeCoverageReportCh = channel('ci:jest:coverage-report')

const testSessionConfigurationCh = channel('ci:jest:session:configuration')

const testSuiteStartCh = channel('ci:jest:test-suite:start')
const testSuiteFinishCh = channel('ci:jest:test-suite:finish')
const testSuiteErrorCh = channel('ci:jest:test-suite:error')

const workerReportTraceCh = channel('ci:jest:worker-report:trace')
const workerReportCoverageCh = channel('ci:jest:worker-report:coverage')
const workerReportLogsCh = channel('ci:jest:worker-report:logs')
const workerReportTelemetryCh = channel('ci:jest:worker-report:telemetry')

const testSuiteCodeCoverageCh = channel('ci:jest:test-suite:code-coverage')

const testStartCh = channel('ci:jest:test:start')
const testSkippedCh = channel('ci:jest:test:skip')
const testFinishCh = channel('ci:jest:test:finish')
const testErrCh = channel('ci:jest:test:err')
const testFnCh = channel('ci:jest:test:fn')
const testSuiteHookFnCh = channel('ci:jest:test-suite:hook:fn')

const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
const libraryConfigurationCh = channel('ci:jest:library-configuration')
const knownTestsCh = channel('ci:jest:known-tests')
const testManagementTestsCh = channel('ci:jest:test-management-tests')
const modifiedFilesCh = channel('ci:jest:modified-files')

const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')

// Message sent by jest's main process to workers to run a test suite (=test file)
// https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/types.ts#L37
const CHILD_MESSAGE_CALL = 1

// Maximum time we'll wait for the tracer to flush
// The exporter has a 10-second bounded final-flush deadline. Leave enough time
// for its completion callback before Jest's --forceExit fallback takes over.
const FLUSH_TIMEOUT = 12_000
const JEST_SESSION_STATE = Symbol.for('dd-trace:jest:session')
const JEST_BAIL_REPORTER_PATH = require.resolve('./jest/bail-reporter')
const DD_JEST_HANDLE_TEST_EVENT_WRAPPED = Symbol('dd-trace:jest:handle-test-event-wrapped')
const DD_JEST_HANDLE_TEST_EVENT_DATADOG = Symbol('dd-trace:jest:handle-test-event-datadog')
const DD_JEST_CONCURRENT_TEST_ORIGINAL = Symbol('dd-trace:jest:concurrent-test-original')
const isJestWorker = !!getEnvironmentVariable('JEST_WORKER_ID')
const jestSessionState = (globalThis[JEST_SESSION_STATE] ||= {})

// https://github.com/jestjs/jest/blob/41f842a46bb2691f828c3a5f27fc1d6290495b82/packages/jest-circus/src/types.ts#L9C8-L9C54
const RETRY_TIMES = Symbol.for('RETRY_TIMES')

let skippableSuites = []
let skippableSuitesCoverage
let skippedSuitesCoverage = {}
let knownTests = {}
let isCodeCoverageEnabled = false
let isCoverageReportUploadEnabled = false
let isItrEnabled = false
let isSuitesSkippingEnabled = false
let isUserCodeCoverageEnabled = false
let isSuitesSkipped = false
let numSkippedSuites = 0
let hasUnskippableSuites = false
let hasForcedToRunSuites = false
let isEarlyFlakeDetectionEnabled = false
let earlyFlakeDetectionFaultyThreshold = 30
let isEarlyFlakeDetectionFaulty = false
let hasFilteredSkippableSuites = false
let isKnownTestsEnabled = false
let isTestManagementTestsEnabled = false
let testManagementTests = {}
let testManagementAttemptToFixRetries = 0
let isImpactedTestsEnabled = false
let modifiedFiles
let repositoryRoot
let lastCoverageMap
let lastCoverageMapRootDir
let coverageBackfillContexts
let coverageBackfillFiles
let coverageReporterClass
let coverageReporterRequire
let activeTestSuiteAbsolutePath
let isConsoleErrorWrapped = false

const testContexts = new WeakMap()
const originalTestFns = new WeakMap()
const originalHookFns = new WeakMap()
const concurrentHookContextQueues = new WeakMap()
const concurrentHookFns = new WeakMap()
const efdRetryMetadataByTest = new WeakMap()
const removedRetryTests = new WeakSet()
const retriedTestsToNumAttempts = new Map()
const efdTestStatuses = new Map()
const attemptToFixRetriedTestsStatuses = new Map()
const wrappedWorkerChannels = new WeakMap()
// New tests whose names contain likely dynamic data (timestamps, UUIDs, etc.)
// Populated in-process for runInBand, and via worker-report:trace for parallel mode.
const newTestsWithDynamicNames = new Set()
const loggedAttemptToFixTests = new Set()
const testSuiteMockedFiles = new Map()
const testsToBeRetried = new Set()
// Per-test: how many EFD retries were determined after the first execution.
const efdDeterminedRetries = new Map()
// Per-test: total executions to report, including retries Jest ran before the test they belong to.
const efdExpectedExecutions = new Map()
// Tests whose first run exceeded the 5-min threshold — tagged "slow".
const efdSlowAbortedTests = new Set()
// Tests whose first execution determines the duration-based EFD retry count.
const efdCandidates = new Set()
// Tests that are genuinely new (not in known tests list).
const newTests = new Set()
const testSuiteJestObjects = new Map()
const testSuiteDatadogEnvironments = new Map()
const wrappedJestGlobals = new WeakSet()
const wrappedJestObjects = new WeakSet()
const wrappedWorkerInitializers = new WeakSet()
const publishedRuntimeReferenceErrors = new WeakMap()
const wrappedCoverageReporters = new WeakSet()
const coverageReporterRequires = new WeakMap()
const handledJestEvents = new WeakSet()

/**
 * @typedef {object} ConcurrentTestOptions
 * @property {(...args: unknown[]) => unknown} [concurrentTest]
 * @property {unknown} [concurrentTestThisArg]
 * @property {EfdRetryGate[]} [efdRetryGates]
 * @property {boolean} [isAttemptToFixRetry]
 * @property {boolean} [isEfdRetry]
 * @property {number} [efdRetryIndex]
 * @property {boolean} [isModified]
 * @property {(...args: unknown[]) => unknown} [sourceTestFn]
 * @property {string} [testParameters]
 * @property {number} [timeout]
 */

/**
 * @typedef {object} JestRetryOptions
 * @property {object} [concurrentTestState]
 * @property {EfdRetryGate[]} [efdRetryGates]
 * @property {object} jestEvent
 * @property {object} state
 * @property {boolean} [isModified]
 * @property {number} retryCount
 * @property {string} retryType
 * @property {string} testFullName
 */

/**
 * @typedef {object} EfdRetryGate
 * @property {Promise<boolean>} promise
 * @property {(shouldRun: boolean) => void} resolve
 */

/**
 * @typedef {object} DetachedEfdRetry
 * @property {object} ctx
 * @property {() => void} resolve
 * @property {() => void} start
 */

const ATR_RETRY_SUPPRESSION_FLAG = '_ddDisableAtrRetry'
const MINIMUM_JEST_VERSION = DD_MAJOR >= 6 ? '>=28.0.0' : '>=24.8.0'
const MINIMUM_JEST_VERSION_BEFORE_30 = DD_MAJOR >= 6 ? '>=28.0.0 <30.0.0' : '>=24.8.0 <30.0.0'
const MINIMUM_JEST_WORKER_VERSION_BEFORE_30 = DD_MAJOR >= 6 ? '>=28.0.0 <30.0.0' : '>=24.9.0 <30.0.0'
const MINIMUM_JEST_CONFIG_ASYNC_VERSION = DD_MAJOR >= 6 ? '>=28.0.0' : '>=25.1.0'
const MINIMUM_JEST_TEST_SCHEDULER_VERSION = DD_MAJOR >= 6 ? '>=28.0.0' : '>=27.0.0'
const MINIMUM_JEST_COVERAGE_BACKFILL_VERSION = '>=28.0.0'
const atrSuppressedErrors = new Map()
let hasWarnedDeprecatedJestVersion = false
let isJestCoverageBackfillSupported = false
let hasFinishedTestSession = false
let jestEachBind

// Track quarantined tests whose errors were suppressed, keyed by "suite › testName"
const quarantinedFailingTests = new Set()

function getJestRepositoryRoot (readConfigsResult) {
  const configuredRepositoryRoot = readConfigsResult.configs
    ?.find(config => config.testEnvironmentOptions?._ddRepositoryRoot)
    ?.testEnvironmentOptions._ddRepositoryRoot

  return configuredRepositoryRoot || process.cwd()
}

/**
 * Sends suppressed quarantine test names from a worker process to the main process.
 * Supports both child_process (process.send) and worker_threads (parentPort.postMessage).
 * Returns true if the data was sent (worker mode), false if in main process (runInBand).
 *
 * @param {string[]} testNames
 * @returns {boolean}
 */
function sendQuarantineInfoToMainProcess (testNames) {
  const payload = [JEST_WORKER_QUARANTINE_PAYLOAD_CODE, JSON.stringify(testNames)]

  if (process.send) {
    process.send(payload)
    return true
  }

  try {
    const { isMainThread, parentPort } = require('node:worker_threads')
    if (!isMainThread && parentPort) {
      parentPort.postMessage(payload)
      return true
    }
  } catch {
    // Not in a worker context
  }

  return false
}

// based on https://github.com/facebook/jest/blob/main/packages/jest-circus/src/formatNodeAssertErrors.ts#L41
function formatJestError (errors) {
  let error
  if (Array.isArray(errors)) {
    const [originalError, asyncError] = errors
    if (originalError === null || !originalError.stack) {
      error = asyncError
      error.message = originalError
    } else {
      error = originalError
    }
  } else {
    error = errors
  }
  return error
}

function warnDeprecatedJestVersion (frameworkVersion) {
  if (DD_MAJOR >= 6 || hasWarnedDeprecatedJestVersion || !frameworkVersion ||
      !satisfies(frameworkVersion, '<28.0.0')) {
    return
  }

  hasWarnedDeprecatedJestVersion = true
  // eslint-disable-next-line no-console
  console.warn(
    'dd-trace support for Jest<28.0.0 is deprecated and will be removed in dd-trace v6. ' +
      'Please upgrade Jest to >=28.0.0.'
  )
}

function getTestEnvironmentOptions (config) {
  if (config.projectConfig && config.projectConfig.testEnvironmentOptions) { // newer versions
    return config.projectConfig.testEnvironmentOptions
  }
  if (config.testEnvironmentOptions) {
    return config.testEnvironmentOptions
  }
  return {}
}

const MAX_IGNORED_TEST_NAMES = 10

/**
 * @typedef {Parameters<typeof logTestOptimizationSummary>[0]} TestOptimizationSummary
 */

function getTestStats (testStatuses) {
  return testStatuses.reduce((acc, testStatus) => {
    acc[testStatus]++
    return acc
  }, { pass: 0, fail: 0 })
}

/**
 * Formats the ignored-failure section for the Test Optimization summary.
 *
 * @param {{
 *   efdNames: string[],
 *   quarantineNames: string[],
 *   totalCount: number,
 *   efdFailureCount: number
 * } | undefined} ignoredFailures
 * @returns {string}
 */
function formatIgnoredFailuresSummary (ignoredFailures) {
  if (!ignoredFailures?.efdFailureCount) return ''

  const items = ignoredFailures.efdNames.map(text => ({ text, suffix: 'Early Flake Detection' }))

  if (items.length === 0) return ''

  const shown = items.slice(0, MAX_IGNORED_TEST_NAMES)
  const more = items.length - shown.length
  const moreSuffix = more > 0 ? `\n  ... and ${more} more` : ''
  const formattedItems = shown
    .map(({ text, suffix }) => `  • ${text}${suffix ? ` (${suffix})` : ''}`)
    .join('\n') + moreSuffix

  return `${ignoredFailures.efdFailureCount} test failure(s) were ignored. Exit code set to 0.\n\n${formattedItems}`
}

/**
 * Logs a single "Datadog Test Optimization" summary at session end.
 *
 * @param {{
 *   efdNames: string[],
 *   quarantineNames: string[],
 *   totalCount: number,
 *   efdFailureCount: number
 * } | undefined} ignoredFailures
 * @param {NonNullable<TestOptimizationSummary['attemptToFixExecutions']>} attemptToFixExecutions
 * @param {boolean} allTestsSkipped
 */
function logSessionSummary (ignoredFailures, attemptToFixExecutions, allTestsSkipped) {
  logTestOptimizationSummary({
    attemptToFixExecutions,
    extraSections: [
      formatIgnoredFailuresSummary(ignoredFailures),
      allTestsSkipped ? TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE : '',
    ],
    newTestsWithDynamicNames,
  })
  loggedAttemptToFixTests.clear()
}

function getTestStatusFromJestResult (status) {
  if (status === 'failed') return 'fail'
  if (status === 'passed') return 'pass'
}

function getAttemptToFixExecutionsFromJestResults (result) {
  const executions = new Map()
  const rootDir = result.globalConfig?.rootDir || process.cwd()

  for (const { testResults, testFilePath } of result.results.testResults) {
    const testSuite = getTestSuitePath(testFilePath, rootDir)
    const testManagementTestsForSuite = testManagementTests
      ?.jest
      ?.suites
      ?.[testSuite]
      ?.tests
    if (!testManagementTestsForSuite) continue

    for (const { fullName, status } of testResults) {
      const testName = removeSeedSuffixFromTestName(fullName)
      const testManagementTest = testManagementTestsForSuite[testName]?.properties
      if (!testManagementTest?.attempt_to_fix) continue
      const testStatus = getTestStatusFromJestResult(status) ||
        (status === 'pending' || status === 'todo' ? 'skip' : undefined)
      if (!testStatus) continue

      recordAttemptToFixExecution(executions, {
        testSuite,
        testName,
        status: testStatus,
        isDisabled: testManagementTest.disabled,
        isQuarantined: testManagementTest.quarantined,
      })
    }
  }

  return executions
}

/**
 * Records test-management results reported by Jest after all retries have finished.
 *
 * @param {{
 *   globalConfig?: { rootDir?: string },
 *   results: {
 *     testResults: Array<{
 *       testResults: Array<{ fullName: string, status: string }>,
 *       testFilePath: string
 *     }>
 *   }
 * }} result
 * @param {string[]} quarantineFailureNames
 */
function recordTestManagementExecutionsFromJestResults (result, quarantineFailureNames) {
  const rootDir = result.globalConfig?.rootDir || process.cwd()
  const failedQuarantinedTests = new Set(quarantineFailureNames)

  for (const { testResults, testFilePath } of result.results.testResults) {
    const testSuite = getTestSuitePath(testFilePath, rootDir)
    const testManagementTestsForSuite = testManagementTests
      ?.jest
      ?.suites
      ?.[testSuite]
      ?.tests
    if (!testManagementTestsForSuite) continue

    for (const { fullName, status } of testResults) {
      const testName = removeSeedSuffixFromTestName(fullName)
      const testManagementTest = testManagementTestsForSuite[testName]?.properties
      if (!testManagementTest) continue

      const name = `${testSuite} › ${testName}`
      recordTestManagementExecution({
        testSuite,
        testName,
        status: failedQuarantinedTests.has(name) ? 'fail' : getTestStatusFromJestResult(status),
        isAttemptToFix: testManagementTest.attempt_to_fix,
        isDisabled: testManagementTest.disabled,
        isQuarantined: testManagementTest.quarantined,
      })
    }
  }
}

function wrapConsoleErrorForJestReferenceErrors () {
  if (isConsoleErrorWrapped) return

  isConsoleErrorWrapped = true
  // eslint-disable-next-line no-console
  const originalConsoleError = console.error
  // eslint-disable-next-line no-console
  console.error = function () {
    const [message] = arguments
    if (
      typeof message === 'string' &&
      message.includes('Jest environment has been torn down') &&
      activeTestSuiteAbsolutePath
    ) {
      publishRuntimeReferenceError({ _testPath: activeTestSuiteAbsolutePath }, message)
    }
    return originalConsoleError.apply(this, arguments)
  }
}

function isDatadogJestEventHandled (event) {
  return event && typeof event === 'object' && handledJestEvents.has(event)
}

function markDatadogJestEventHandled (event) {
  if (event && typeof event === 'object') {
    handledJestEvents.add(event)
  }
}

/**
 * Gets the original Jest concurrent registration function behind a Datadog wrapper.
 *
 * @param {(...args: unknown[]) => unknown} concurrentTest
 * @returns {(...args: unknown[]) => unknown}
 */
function getOriginalConcurrentTest (concurrentTest) {
  return concurrentTest[DD_JEST_CONCURRENT_TEST_ORIGINAL] || concurrentTest
}

/**
 * Marks a Datadog concurrent registration wrapper with its original Jest function.
 *
 * @param {(...args: unknown[]) => unknown} wrappedConcurrentTest
 * @param {(...args: unknown[]) => unknown} originalConcurrentTest
 * @returns {void}
 */
function setOriginalConcurrentTest (wrappedConcurrentTest, originalConcurrentTest) {
  Object.defineProperty(wrappedConcurrentTest, DD_JEST_CONCURRENT_TEST_ORIGINAL, {
    configurable: true,
    value: originalConcurrentTest,
  })
}

/**
 * Wraps a custom Jest environment handler so Datadog still observes events even
 * when the custom environment does not call `super.handleTestEvent`.
 *
 * @param {(event: object, state: object) => Promise<void>|void} handleTestEvent
 * @param {(event: object, state: object) => Promise<void>|void} datadogHandleTestEvent
 * @returns {(event: object, state: object) => Promise<void>|void}
 */
function getWrappedCustomHandleTestEvent (handleTestEvent, datadogHandleTestEvent) {
  if (
    !handleTestEvent ||
    handleTestEvent === datadogHandleTestEvent ||
    handleTestEvent[DD_JEST_HANDLE_TEST_EVENT_WRAPPED]
  ) {
    return handleTestEvent || datadogHandleTestEvent
  }

  const wrappedHandleTestEvent = function (event, state) {
    const result = handleTestEvent.call(this, event, state)
    const runDatadogHandler = value => {
      if (isDatadogJestEventHandled(event)) return value

      const datadogResult = datadogHandleTestEvent.call(this, event, state)
      if (typeof datadogResult?.then === 'function') {
        return datadogResult.then(() => value)
      }
      return value
    }

    if (event.name === 'add_test') {
      runDatadogHandler(result)
      return result
    }

    if (typeof result?.then === 'function') {
      return result.then(runDatadogHandler)
    }
    return runDatadogHandler(result)
  }
  wrappedHandleTestEvent[DD_JEST_HANDLE_TEST_EVENT_WRAPPED] = true
  return wrappedHandleTestEvent
}

/**
 * Mirrors the test selection checks Jest Circus performs after publishing `test_start`.
 *
 * @param {object} test
 * @param {boolean} hasFocusedTests
 * @param {RegExp|undefined} testNamePattern
 * @returns {boolean}
 */
function isJestTestSkipped (test, hasFocusedTests, testNamePattern) {
  if (
    test.mode === 'skip' ||
    (hasFocusedTests && test.mode !== 'only') ||
    (testNamePattern && !testNamePattern.test(getRawJestTestName(test)))
  ) {
    return true
  }

  let parent = test.parent
  while (parent) {
    if (parent.mode === 'skip') return true
    parent = parent.parent
  }
  return false
}

function getWrappedEnvironment (BaseEnvironment, jestVersion) {
  const hasConcurrentTestsStartEvent = satisfies(jestVersion, '>=30.0.0')
  const hasTestsInChildren = satisfies(jestVersion, '>=26.0.0')

  /**
   * @param {object} describeBlock
   * @returns {object[]|undefined}
   */
  function getTestEntries (describeBlock) {
    return hasTestsInChildren ? describeBlock?.children : describeBlock?.tests
  }

  return class DatadogEnvironment extends BaseEnvironment {
    #activeDetachedEfdRetries
    #detachedEfdRetryConcurrency
    #detachedEfdRetryQueue
    #discardedEfdRetryTests
    #earlyFlakeDetectionRetryPolicy
    #efdRetryGatesByName
    #pendingPre30ConcurrentTests

    constructor (config, context) {
      super(config, context)
      const rootDir = config.globalConfig ? config.globalConfig.rootDir : config.rootDir
      this.rootDir = rootDir
      this.nameToParams = {}
      this.global._ddtrace = global._ddtrace
      this.hasSnapshotTests = undefined
      this.testSuiteAbsolutePath = context.testPath
      activeTestSuiteAbsolutePath = this.testSuiteAbsolutePath
      testSuiteDatadogEnvironments.set(this.testSuiteAbsolutePath, this)
      wrapConsoleErrorForJestReferenceErrors()
      this.globalConfig = config.globalConfig

      this.displayName = config.projectConfig?.displayName?.name || config.displayName
      this.testEnvironmentOptions = getTestEnvironmentOptions(config)

      const repositoryRoot = this.testEnvironmentOptions._ddRepositoryRoot
      this.testSuite = getTestSuitePath(context.testPath, rootDir)

      // TODO: could we grab testPath from `this.getVmContext().expect.getState()` instead?
      // so we don't rely on context being passed (some custom test environment do not pass it)
      if (repositoryRoot) {
        this.testSourceFile = getTestSuitePath(context.testPath, repositoryRoot)
        this.repositoryRoot = repositoryRoot
      }

      this.isEarlyFlakeDetectionEnabled = this.testEnvironmentOptions._ddIsEarlyFlakeDetectionEnabled
      this.isFlakyTestRetriesEnabled = this.testEnvironmentOptions._ddIsFlakyTestRetriesEnabled
      this.flakyTestRetriesCount = this.testEnvironmentOptions._ddFlakyTestRetriesCount
      this.isDiEnabled = this.testEnvironmentOptions._ddIsDiEnabled
      this.isKnownTestsEnabled = this.testEnvironmentOptions._ddIsKnownTestsEnabled
      this.isTestManagementTestsEnabled = this.testEnvironmentOptions._ddIsTestManagementTestsEnabled
      this.isImpactedTestsEnabled = this.testEnvironmentOptions._ddIsImpactedTestsEnabled
      this.hasConcurrentTests = false
      this.concurrentTestContexts = new Map()
      this.concurrentTestStates = new WeakMap()
      this.concurrentTestSourceFns = new WeakMap()
      this.testParametersByFunction = new WeakMap()
      this.wrappedConcurrentTestFunctions = new WeakSet()
      this.jestEachBind = undefined
      this.#activeDetachedEfdRetries = 0
      this.#detachedEfdRetryConcurrency = 1
      this.#pendingPre30ConcurrentTests = 0
      this.#earlyFlakeDetectionRetryPolicy =
        this.testEnvironmentOptions._ddEarlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY

      if (this.isKnownTestsEnabled) {
        try {
          this.knownTestsForThisSuite = this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)

          if (!Array.isArray(this.knownTestsForThisSuite)) {
            log.warn('this.knownTestsForThisSuite is not an array so new test and Early Flake detection is disabled.')
            this.isEarlyFlakeDetectionEnabled = false
            this.isKnownTestsEnabled = false
          }
        } catch {
          // If there has been an error parsing the tests, we'll disable Early Flake Deteciton
          this.isEarlyFlakeDetectionEnabled = false
          this.isKnownTestsEnabled = false
        }
      }

      if (this.isFlakyTestRetriesEnabled) {
        const currentNumRetries = this.global[RETRY_TIMES]
        if (!currentNumRetries) {
          this.global[RETRY_TIMES] = this.flakyTestRetriesCount
        }
      }

      if (this.isTestManagementTestsEnabled) {
        try {
          const hasTestManagementTests = !!testManagementTests?.jest
          testManagementAttemptToFixRetries = this.testEnvironmentOptions._ddTestManagementAttemptToFixRetries
          this.testManagementTestsForThisSuite = hasTestManagementTests
            ? this.getTestManagementTestsForSuite(testManagementTests?.jest?.suites?.[this.testSuite]?.tests)
            : this.getTestManagementTestsForSuite(this.testEnvironmentOptions._ddTestManagementTests)
        } catch (e) {
          log.error('Error parsing test management tests', e)
          this.isTestManagementTestsEnabled = false
        }
      }

      if (this.isImpactedTestsEnabled) {
        try {
          this.modifiedFiles = modifiedFiles ?? this.testEnvironmentOptions._ddModifiedFiles
        } catch (e) {
          log.error('Error parsing impacted tests', e)
          this.isImpactedTestsEnabled = false
        }
      }

      this[DD_JEST_HANDLE_TEST_EVENT_DATADOG] = DatadogEnvironment.prototype.handleTestEvent
      this.wrapCustomHandleTestEvent(DatadogEnvironment.prototype.handleTestEvent)
    }

    /**
     * Rechecks custom `handleTestEvent` implementations after subclass instance fields
     * and constructors have run.
     *
     * @returns {Promise<void>|void}
     */
    setup () {
      this.wrapCustomHandleTestEvent(DatadogEnvironment.prototype.handleTestEvent)

      if (super.setup) {
        const result = super.setup()
        if (typeof result?.then === 'function') {
          return result.then(() => {
            this.wrapCustomHandleTestEvent(DatadogEnvironment.prototype.handleTestEvent)
          })
        }
        this.wrapCustomHandleTestEvent(DatadogEnvironment.prototype.handleTestEvent)
        return result
      }
    }

    /**
     * Rebuilds serial `test.each` so every generated row function keeps its parameters.
     *
     * @param {Function|undefined} test
     * @returns {void}
     */
    bindTestEach (test) {
      if (typeof test?.each !== 'function') return

      const bind = this.getJestEachBind()
      if (typeof bind !== 'function') {
        const environment = this
        shimmer.wrap(test, 'each', each => function (...args) {
          const testParameters = getFormattedJestTestParameters(args)
          const eachBind = each.apply(this, args)
          return function (...args) {
            const [testName] = args
            environment.setNameToParams(testName, testParameters)
            return eachBind.apply(this, args)
          }
        })
        return
      }

      // Jest creates each row function at runtime, so Orchestrion cannot associate parameters statically.
      const environment = this
      test.each = function wrappedTestEach (...eachArgs) {
        const testParameters = getFormattedJestTestParameters(eachArgs)
        return function (...testArgs) {
          let parameterIndex = 0
          const eachTest = function (testName, testFn, ...callArgs) {
            const parameters = testParameters?.[parameterIndex++]
            if (parameters !== undefined && typeof testFn === 'function') {
              environment.appendNameToParams(testName, parameters)
              environment.testParametersByFunction.set(
                testFn,
                getTestParametersString(environment.nameToParams, testName)
              )
            }
            return test.call(this, testName, testFn, ...callArgs)
          }
          const eachBind = bind(eachTest).apply(this, eachArgs)
          return eachBind.apply(this, testArgs)
        }
      }
    }

    /**
     * Wraps Jest's concurrent test registration methods so eager concurrent bodies
     * in older Jest versions execute inside their test span context.
     *
     * @param {object} state
     * @returns {void}
     */
    wrapConcurrentTest (state) {
      this.concurrentTestState = state
      this.wrapConcurrentTestGlobals(this.global.test, state)
    }

    /**
     * Wraps one Jest `test` function object's concurrent registration methods.
     *
     * @param {Function|undefined} test
     * @param {object} state
     * @returns {void}
     */
    wrapConcurrentTestGlobals (test, state) {
      if (!state) return

      const concurrentTest = test?.concurrent
      if (typeof concurrentTest !== 'function') return

      this.wrapConcurrentTestFunction(test, 'concurrent', state)
      this.wrapConcurrentTestFunction(test.concurrent, 'only', state)
      this.wrapConcurrentTestFunction(test.concurrent, 'failing', state)
      this.wrapConcurrentTestFunction(test.concurrent.only, 'failing', state)
    }

    /**
     * Wraps one concurrent test function variant.
     *
     * @param {object} target
     * @param {string} methodName
     * @param {object} state
     * @returns {void}
     */
    wrapConcurrentTestFunction (target, methodName, state) {
      let concurrentTest = target?.[methodName]
      if (typeof concurrentTest !== 'function') return
      if (this.wrappedConcurrentTestFunctions.has(concurrentTest)) return

      const originalConcurrentTest = getOriginalConcurrentTest(concurrentTest)
      if (originalConcurrentTest !== concurrentTest) {
        target[methodName] = originalConcurrentTest
        concurrentTest = originalConcurrentTest
      }
      if (typeof concurrentTest !== 'function') return

      const environment = this
      shimmer.wrap(target, methodName, concurrentTest => {
        return function wrappedConcurrentTest (testName, testFn, ...args) {
          if (typeof testFn !== 'function') {
            return concurrentTest.apply(this, arguments)
          }

          environment.hasConcurrentTests = true
          const asyncError = environment.isImpactedTestsEnabled
            ? new Error('Datadog concurrent test registration')
            : undefined
          const wrappedTestFn = environment.createConcurrentTestFn(testName, testFn, asyncError, state, {
            concurrentTest,
            concurrentTestThisArg: this,
            sourceTestFn: environment.concurrentTestSourceFns.get(testFn),
            timeout: args[0],
          })
          return concurrentTest.call(this, testName, wrappedTestFn, ...args)
        }
      })

      const wrappedConcurrentTest = target[methodName]
      setOriginalConcurrentTest(wrappedConcurrentTest, concurrentTest)
      this.wrappedConcurrentTestFunctions.add(wrappedConcurrentTest)
      this.bindConcurrentEach(wrappedConcurrentTest, methodName === 'failing')
    }

    /**
     * Rebuilds a concurrent `.each` helper so each generated row calls the wrapped test function.
     *
     * @param {Function} concurrentTest
     * @param {boolean} needsEachError
     * @returns {void}
     */
    bindConcurrentEach (concurrentTest, needsEachError) {
      if (typeof concurrentTest?.each !== 'function') return

      const bind = this.getJestEachBind()
      if (typeof bind !== 'function') return

      const environment = this
      concurrentTest.each = function wrappedConcurrentEach (...eachArgs) {
        const testParameters = getFormattedJestTestParameters(eachArgs)
        return function (...testArgs) {
          let parameterIndex = 0
          const sourceTestFn = testArgs[1]
          const concurrentEachTest = function (testName, testFn, ...callArgs) {
            const parameters = testParameters?.[parameterIndex++]
            if (parameters !== undefined) {
              environment.appendNameToParams(testName, parameters)
            }
            if (typeof testFn === 'function' && typeof sourceTestFn === 'function') {
              environment.concurrentTestSourceFns.set(testFn, sourceTestFn)
            }
            return concurrentTest.call(this, testName, testFn, ...callArgs)
          }
          const eachBind = bind(concurrentEachTest, false, needsEachError).apply(this, eachArgs)
          return eachBind.apply(this, testArgs)
        }
      }
    }

    /**
     * Creates a Jest test function wrapper and stores its concurrent execution state.
     *
     * @param {string} testName
     * @param {(...args: unknown[]) => unknown} testFn
     * @param {Error|undefined} asyncError
     * @param {object} state
     * @param {ConcurrentTestOptions|undefined} options
     * @returns {(...args: unknown[]) => unknown}
     */
    createConcurrentTestFn (testName, testFn, asyncError, state, options) {
      const concurrentTestState = {
        concurrentTest: options?.concurrentTest,
        concurrentTestThisArg: options?.concurrentTestThisArg,
        ctx: this.createConcurrentTestContext(testName, testFn, asyncError, state, options),
        numExecutions: 0,
        state,
        testFn,
      }
      concurrentTestState.ctx.concurrentTestState = concurrentTestState
      const environment = this
      const wrappedTestFn = shimmer.wrapFunction(testFn, testFn => function (...args) {
        return environment.runConcurrentTestFn(concurrentTestState, testFn, this, args)
      })
      this.concurrentTestStates.set(wrappedTestFn, concurrentTestState)
      return wrappedTestFn
    }

    /**
     * Gets Jest's table-driven test binder from the user's Jest installation.
     *
     * @returns {Function|undefined}
     */
    getJestEachBind () {
      if (this.jestEachBind !== undefined) return this.jestEachBind

      if (typeof jestEachBind === 'function') {
        this.jestEachBind = jestEachBind
        return this.jestEachBind
      }

      let jestEach
      try {
        jestEach = createRequire(path.join(this.rootDir, 'package.json'))('jest-each')
      } catch {
        try {
          jestEach = createRequire(path.join(process.cwd(), 'package.json'))('jest-each')
        } catch {
          jestEach = undefined
        }
      }
      this.jestEachBind = jestEach?.bind
      return this.jestEachBind
    }

    /**
     * Creates the context used to start and finish a concurrent test span.
     *
     * @param {string} testName
     * @param {(...args: unknown[]) => unknown} testFn
     * @param {Error|undefined} asyncError
     * @param {object} state
     * @param {ConcurrentTestOptions|undefined} options
     * @returns {object}
     */
    createConcurrentTestContext (testName, testFn, asyncError, state, options) {
      const testFullName = this.getTestNameFromAddTestEvent({ testName }, state)
      const isNewTest = this.isKnownTestsEnabled && !this.knownTestsForThisSuite?.includes(testFullName)
      const isAttemptToFix = this.isTestManagementTestsEnabled &&
        this.testManagementTestsForThisSuite?.attemptToFix?.includes(testFullName)
      const sourceTestFn = options?.sourceTestFn || testFn
      const ctx = {
        name: testFullName,
        suite: this.testSuite,
        testSourceFile: this.testSourceFile,
        displayName: this.displayName,
        testParameters: options?.testParameters || getTestParametersString(this.nameToParams, testName),
        frameworkVersion: jestVersion,
        isNew: isNewTest,
        isEfdRetry: options?.isEfdRetry === true,
        efdRetryGates: options?.efdRetryGates,
        efdRetryIndex: options?.efdRetryIndex,
        isAttemptToFix,
        isAttemptToFixRetry: options?.isAttemptToFixRetry === true,
        isJestRetry: false,
        isDisabled: this.testManagementTestsForThisSuite?.disabled?.includes(testFullName),
        isQuarantined: this.testManagementTestsForThisSuite?.quarantined?.includes(testFullName),
        isModified: options?.isModified ?? this.isTestModified(asyncError, sourceTestFn),
        hasDynamicName: isNewTest && DYNAMIC_NAME_RE.test(testFullName),
        testSuiteAbsolutePath: this.testSuiteAbsolutePath,
        testTimeout: options?.timeout || state.testTimeout,
      }
      let contexts = this.concurrentTestContexts.get(testFullName)
      if (contexts) {
        contexts.push(ctx)
      } else {
        contexts = [ctx]
        this.concurrentTestContexts.set(testFullName, contexts)
      }
      return ctx
    }

    /**
     * Checks if a test overlaps modified lines for impacted-test detection.
     *
     * @param {Error|undefined} asyncError
     * @param {Function|undefined} testFn
     * @returns {boolean}
     */
    isTestModified (asyncError, testFn) {
      if (!this.isImpactedTestsEnabled || !asyncError || typeof testFn !== 'function') return false

      const testStartLine = getTestLineStart(asyncError, this.testSuite)
      const testEndLine = getTestEndLine(testFn, testStartLine)
      return isModifiedTest(
        this.testSourceFile,
        testStartLine,
        testEndLine,
        this.modifiedFiles,
        'jest'
      )
    }

    /**
     * Gets the next registered concurrent test context for a full Jest test name.
     *
     * @param {string} testName
     * @returns {object|undefined}
     */
    getNextConcurrentTestContext (testName) {
      const contexts = this.concurrentTestContexts.get(testName)
      if (!contexts?.length) return

      const ctx = contexts.shift()
      if (contexts.length === 0) {
        this.concurrentTestContexts.delete(testName)
      }
      return ctx
    }

    /**
     * Removes one registered concurrent test context from the name fallback queue.
     *
     * @param {string} testName
     * @param {object} ctx
     * @returns {void}
     */
    removeConcurrentTestContext (testName, ctx) {
      const contexts = this.concurrentTestContexts.get(testName)
      if (!contexts?.length) return

      const contextIndex = contexts.indexOf(ctx)
      if (contextIndex === -1) return

      contexts.splice(contextIndex, 1)
      if (contexts.length === 0) {
        this.concurrentTestContexts.delete(testName)
      }
    }

    /**
     * Records formatted parameters for one table-driven Jest test declaration.
     *
     * @param {string} name
     * @param {unknown[]} params
     * @returns {void}
     */
    setNameToParams (name, params) {
      this.nameToParams[name] = [...params]
    }

    /**
     * Appends formatted parameters for one table-driven Jest test row.
     *
     * @param {string} name
     * @param {unknown[]|object} params
     * @returns {void}
     */
    appendNameToParams (name, params) {
      if (this.nameToParams[name]) {
        this.nameToParams[name].push(params)
      } else {
        this.nameToParams[name] = [params]
      }
    }

    /**
     * @param {object} concurrentTestState
     * @param {number|undefined} startedAt
     * @returns {void}
     */
    completePre30ConcurrentTest (concurrentTestState, startedAt) {
      if (!concurrentTestState.trackEfdCompletion) return

      concurrentTestState.trackEfdCompletion = false
      const { ctx } = concurrentTestState
      if (startedAt !== undefined) {
        ctx.efdDurationMs = performance.now() - startedAt
        this.determineEfdRetries(ctx.name, ctx.efdDurationMs)
      }
      this.#pendingPre30ConcurrentTests--
      this.drainDetachedEfdRetries()
    }

    /**
     * @param {object} concurrentTestState
     * @param {unknown} result
     * @param {number|undefined} startedAt
     * @returns {unknown}
     */
    trackPre30ConcurrentTest (concurrentTestState, result, startedAt) {
      if (typeof result?.then !== 'function') {
        this.completePre30ConcurrentTest(concurrentTestState, startedAt)
        return result
      }

      return Promise.resolve(result).finally(() => {
        this.completePre30ConcurrentTest(concurrentTestState, startedAt)
      })
    }

    /**
     * @param {EfdRetryGate} retryGate
     * @param {object} ctx
     * @param {() => unknown} run
     * @returns {Promise<void>}
     */
    enqueueDetachedEfdRetry (retryGate, ctx, run) {
      /**
       * @param {() => void} resolve
       * @returns {void}
       */
      const enqueue = (resolve) => {
        /**
         * @param {boolean} shouldRun
         * @returns {void}
         */
        const onDecision = (shouldRun) => {
          if (!shouldRun) {
            ctx.isDiscardedEfdRetry = true
            resolve()
            return
          }

          /**
           * @type {() => void}
           */
          let start
          const startPromise = new Promise(resolve => {
            start = resolve
          })
          const retry = { ctx, resolve, start }
          /**
           * @param {unknown} error
           * @returns {void}
           */
          const onRejected = (error) => {
            retry.ctx.detachedEfdRetryError = error
            this.finishDetachedEfdRetry(retry)
          }
          startPromise.then(() => this.runDetachedEfdRetryWithTimeout(ctx, run)).then(
            () => this.finishDetachedEfdRetry(retry),
            onRejected
          )
          this.#detachedEfdRetryQueue ??= []
          this.#detachedEfdRetryQueue.push(retry)
          this.drainDetachedEfdRetries()
        }
        retryGate.promise.then(onDecision)
      }
      return new Promise(enqueue)
    }

    /**
     * Applies the timeout Jest 28/29 cannot start around a detached concurrent retry body.
     *
     * @param {object} ctx
     * @param {() => unknown} run
     * @returns {Promise<void>}
     */
    runDetachedEfdRetryWithTimeout (ctx, run) {
      return new Promise((resolve, reject) => {
        let completed = false
        const timeoutId = realSetTimeout(() => {
          if (completed) return

          completed = true
          reject(new Error(`Exceeded timeout of ${ctx.testTimeout} ms for a test.`))
        }, ctx.testTimeout)

        const settle = (callback, value) => {
          if (completed) return

          completed = true
          timeoutId.unref?.()
          realClearTimeout(timeoutId)
          callback(value)
        }

        let result
        try {
          result = run()
        } catch (error) {
          settle(reject, error)
          return
        }
        Promise.resolve(result).then(
          () => settle(resolve),
          error => settle(reject, error)
        )
      })
    }

    /**
     * @returns {void}
     */
    drainDetachedEfdRetries () {
      const queue = this.#detachedEfdRetryQueue
      if (!queue) return

      while (
        this.#pendingPre30ConcurrentTests === 0 &&
        this.#activeDetachedEfdRetries < this.#detachedEfdRetryConcurrency &&
        queue.length > 0
      ) {
        this.#activeDetachedEfdRetries++
        queue.shift().start()
      }
    }

    /**
     * @param {DetachedEfdRetry} retry
     * @returns {void}
     */
    finishDetachedEfdRetry (retry) {
      this.#activeDetachedEfdRetries--
      retry.resolve()
      this.drainDetachedEfdRetries()
    }

    /**
     * Preserves Jest's immediate error when a callback test also returns a value.
     *
     * @param {() => unknown} run
     * @param {(error?: Error) => void} done
     * @returns {void}
     */
    runCallbackEfdRetry (run, done) {
      let result
      try {
        result = run()
      } catch (error) {
        done(error)
        return
      }
      if (result !== undefined) {
        done(new Error(
          "Test functions cannot both take a 'done' callback and return something. " +
          "Either use a 'done' callback, or return a promise."
        ))
      }
    }

    /**
     * Runs a concurrent test function inside its test span context.
     *
     * @param {{ ctx: object, numExecutions: number }} concurrentTestState
     * @param {(...args: unknown[]) => unknown} testFn
     * @param {object} thisArg
     * @param {unknown[]} args
     * @returns {unknown|void}
     */
    runConcurrentTestFn (concurrentTestState, testFn, thisArg, args) {
      const ctx = concurrentTestState.ctx
      if (ctx.isDisabled && !ctx.isAttemptToFix) {
        const done = args[0]
        if (typeof done === 'function') {
          done()
        }
        this.completePre30ConcurrentTest(concurrentTestState)
        return
      }

      const runTest = () => testFn.apply(thisArg, args)
      const runTestInContext = () => {
        if (!ctx.isAttemptToFixRetry && !ctx.isEfdRetry) {
          ctx.isJestRetry = concurrentTestState.numExecutions > 0
        }
        concurrentTestState.numExecutions++

        if (ctx.currentStore) {
          return testFnCh.runStores(ctx, runTest)
        }

        let result
        testStartCh.runStores(ctx, () => {
          result = testFnCh.runStores(ctx, runTest)
        })
        return result
      }

      const retryGate = ctx.efdRetryGates?.[ctx.efdRetryIndex - 1]
      if (retryGate && !hasConcurrentTestsStartEvent) {
        ctx.detachedEfdRetryPromise = this.enqueueDetachedEfdRetry(retryGate, ctx, runTestInContext)
        return
      }
      if (retryGate && typeof args[0] === 'function') {
        this.runCallbackEfdRetry(runTestInContext, args[0])
        return
      }

      if (!concurrentTestState.trackEfdCompletion) {
        return runTestInContext()
      }

      const startedAt = efdCandidates.has(ctx.name) ? performance.now() : undefined
      let result
      try {
        result = runTestInContext()
      } catch (error) {
        this.completePre30ConcurrentTest(concurrentTestState, startedAt)
        throw error
      }
      return this.trackPre30ConcurrentTest(concurrentTestState, result, startedAt)
    }

    /**
     * Ensures Datadog handles Jest circus events even when a custom environment overrides
     * `handleTestEvent` without calling `super.handleTestEvent`.
     *
     * @param {(event: object, state: object) => Promise<void>|void} datadogHandleTestEvent
     * @returns {void}
     */
    wrapCustomHandleTestEvent (datadogHandleTestEvent) {
      const descriptor = Object.getOwnPropertyDescriptor(this, 'handleTestEvent')
      let handleTestEvent = getWrappedCustomHandleTestEvent(this.handleTestEvent, datadogHandleTestEvent)

      Object.defineProperty(this, 'handleTestEvent', {
        configurable: true,
        enumerable: descriptor?.enumerable ?? false,
        get () {
          return handleTestEvent
        },
        set (value) {
          handleTestEvent = getWrappedCustomHandleTestEvent(value, datadogHandleTestEvent)
        },
      })
    }

    /**
     * Jest snapshot counter issue during test retries
     *
     * Problem:
     * - Jest tracks snapshot calls using an internal counter per test name
     * - Each `toMatchSnapshot()` call increments this counter
     * - When a test is retried, it keeps the same name but the counter continues from where it left off
     *
     * Example Issue:
     * Original test run creates: `exports["test can do multiple snapshots 1"] = "hello"`
     * Retried test expects:      `exports["test can do multiple snapshots 2"] = "hello"`
     *
     * This mismatch causes snapshot tests to fail on retry because Jest is looking
     * for the wrong snapshot number. The solution is to reset the snapshot state.
     */
    resetSnapshotState () {
      try {
        const expectGlobal = this.getVmContext().expect
        const { snapshotState: { _counters: counters } } = expectGlobal.getState()
        if (counters) {
          counters.clear()
        }
      } catch (e) {
        log.warn('Error resetting snapshot state', e)
      }
    }

    /**
     * Jest mock state issue during test retries
     *
     * Problem:
     * - Jest tracks mock function calls using internal state (call count, call arguments, etc.)
     * - When a test is retried, the mock state is not automatically reset
     * - This causes assertions like `toHaveBeenCalledTimes(1)` to fail because the call count
     *   accumulates across retries
     *
     * The solution is to clear all mocks before each retry attempt.
     */
    resetMockState () {
      try {
        if (this.moduleMocker?.clearAllMocks) {
          this.moduleMocker.clearAllMocks()
          return
        }
        const jestObject = testSuiteJestObjects.get(this.testSuiteAbsolutePath)
        if (jestObject?.clearAllMocks) {
          jestObject.clearAllMocks()
        }
      } catch (e) {
        log.warn('Error resetting mock state', e)
      }
    }

    // This function returns an array if the known tests are valid and null otherwise.
    getKnownTestsForSuite (suiteKnownTests) {
      // `suiteKnownTests` is `this.testEnvironmentOptions._ddKnownTests`,
      // which is only set if jest is configured to run in parallel.
      if (suiteKnownTests) {
        return suiteKnownTests
      }
      // Global variable `knownTests` is set only in the main process.
      // If jest is configured to run serially, the tests run in the same process, so `knownTests` is set.
      // The assumption is that if the key `jest` is defined in the dictionary, the response is valid.
      if (knownTests?.jest) {
        return knownTests.jest[this.testSuite] || []
      }
      return null
    }

    getTestManagementTestsForSuite (testManagementTests) {
      if (this.testManagementTestsForThisSuite) {
        return this.testManagementTestsForThisSuite
      }
      if (!testManagementTests) {
        return {
          attemptToFix: [],
          disabled: [],
          quarantined: [],
        }
      }
      let testManagementTestsForSuite = testManagementTests
      // If jest is using workers, test management tests are serialized to json.
      // If jest runs in band, they are not.
      if (typeof testManagementTestsForSuite === 'string') {
        testManagementTestsForSuite = JSON.parse(testManagementTestsForSuite)
      }

      const result = {
        attemptToFix: [],
        disabled: [],
        quarantined: [],
      }

      for (const [testName, { properties }] of Object.entries(testManagementTestsForSuite)) {
        if (properties?.attempt_to_fix) {
          result.attemptToFix.push(testName)
        }
        if (properties?.disabled) {
          result.disabled.push(testName)
        }
        if (properties?.quarantined) {
          result.quarantined.push(testName)
        }
      }

      return result
    }

    /**
     * @param {number} retryCount
     * @returns {EfdRetryGate[]}
     */
    createEfdRetryGates (retryCount) {
      const gates = []
      for (let retryIndex = 0; retryIndex < retryCount; retryIndex++) {
        /** @type {(shouldRun: boolean) => void} */
        let resolveGate
        const promise = new Promise(resolve => {
          resolveGate = resolve
        })
        gates.push({ promise, resolve: resolveGate })
      }
      return gates
    }

    /**
     * Registers retry tests while Jest still accepts additions to the test tree.
     *
     * @param {JestRetryOptions} options
     * @returns {number}
     */
    retryTest ({
      concurrentTestState: registeredConcurrentTestState,
      efdRetryGates,
      jestEvent,
      state,
      isModified,
      retryCount,
      retryType,
    }) {
      const { testName, fn, mode, timeout } = jestEvent
      const isAttemptToFixRetry = retryType === 'Test Management (Attempt to Fix)'
      const isEfdRetry = retryType === 'Impacted tests' || retryType === 'Early flake detection'
      const concurrentTestState = registeredConcurrentTestState || this.concurrentTestStates.get(fn)
      let originalTest
      if (isEfdRetry && !efdRetryGates) {
        originalTest = getTestEntries(state.currentDescribeBlock)?.at(-1)
        if (originalTest?.fn !== fn) {
          log.error('%s could not retain its original Jest test', retryType)
          return 0
        }
      }
      let registeredRetryCount = 0
      for (let retryIndex = 1; retryIndex <= retryCount; retryIndex++) {
        const testEntries = getTestEntries(state.currentDescribeBlock)
        const initialTestCount = testEntries?.length
        let retryFn
        if (concurrentTestState) {
          const test = concurrentTestState.concurrentTest ??
            getOriginalConcurrentTest(this.global.test?.concurrent)
          if (typeof test !== 'function') {
            log.error('%s could not retry concurrent test because test is undefined', retryType)
            continue
          }
          retryFn = this.createConcurrentTestFn(
            testName,
            concurrentTestState.testFn,
            undefined,
            concurrentTestState.state,
            {
              concurrentTest: concurrentTestState.concurrentTest,
              concurrentTestThisArg: concurrentTestState.concurrentTestThisArg,
              efdRetryGates,
              efdRetryIndex: retryIndex,
              isAttemptToFixRetry,
              isEfdRetry,
              isModified: isModified ?? concurrentTestState.ctx.isModified,
              testParameters: concurrentTestState.ctx.testParameters,
              timeout,
            }
          )
          test.call(concurrentTestState.concurrentTestThisArg, testName, retryFn, timeout)
        } else if (this.global.test) {
          const test = mode === 'only' ? this.global.test.only : this.global.test
          // The child-count check below proves Jest added a node, so retries can share the test
          // function instead of retaining one wrapper per scheduled execution.
          retryFn = fn
          test(testName, retryFn, timeout)
        } else {
          log.error('%s could not retry test because global.test is undefined', retryType)
          continue
        }

        if (isEfdRetry) {
          const retryTest = testEntries?.length === initialTestCount + 1 ? testEntries.at(-1) : undefined
          if (retryTest?.fn !== retryFn) {
            log.error('%s could not retain its pre-registered Jest retry', retryType)
            continue
          }
          efdRetryMetadataByTest.set(retryTest, {
            isModified: Boolean(isModified),
            originalTest,
            retryIndex,
          })
        }
        registeredRetryCount++
      }
      return registeredRetryCount
    }

    /**
     * Registers retries for the test Jest just added, keeping a registration failure out of the
     * `add_test` dispatch, where Jest would report it as a test file error.
     *
     * @param {JestRetryOptions} retryOptions
     * @returns {boolean}
     */
    registerRetryTests (retryOptions) {
      // Jest turns later additions into "Cannot add a test after tests have started running".
      if (retryOptions.state.hasStarted) {
        log.error('%s could not register retries after Jest started', retryOptions.retryType)
        return false
      }

      const testEntries = getTestEntries(retryOptions.state.currentDescribeBlock)
      const initialTestCount = testEntries?.length
      try {
        const registeredRetryCount = this.retryTest(retryOptions)
        if (registeredRetryCount === retryOptions.retryCount) return true
      } catch (error) {
        log.error('%s could not register retries', retryOptions.retryType, error)
      }

      if (testEntries && initialTestCount !== undefined) {
        const retryTests = testEntries.splice(initialTestCount)
        for (const retryTest of retryTests) {
          removedRetryTests.add(retryTest)
          const retryCtx = this.concurrentTestStates.get(retryTest.fn)?.ctx
          if (retryCtx) {
            this.removeConcurrentTestContext(retryOptions.testFullName, retryCtx)
          }
        }
        const tests = retryOptions.state.currentDescribeBlock?.tests
        if (tests) {
          let writeIndex = 0
          for (const test of tests) {
            if (!removedRetryTests.has(test)) {
              tests[writeIndex++] = test
            }
          }
          tests.length = writeIndex
        }
      }
      this.#efdRetryGatesByName?.delete(retryOptions.testFullName)
      log.error('%s did not register every retry', retryOptions.retryType)
      return false
    }

    /**
     * Drops the pre-registered EFD retries that exceed the retry count Jest may still run.
     *
     * @param {string} testName
     * @param {object} executedTest The Jest test node that selected the retry count.
     * @param {number} [retryCount] Retries to keep. Every retry is dropped when omitted.
     * @returns {number} Retries left to run.
     */
    discardEfdRetries (testName, executedTest, retryCount = 0) {
      const siblings = getTestEntries(executedTest.parent)
      const executedTestIndex = siblings ? siblings.indexOf(executedTest) : -1
      if (executedTestIndex === -1) return 0

      const originalTest = efdRetryMetadataByTest.get(executedTest)?.originalTest ?? executedTest

      // Circus iterates children live, so only entries after the test that just ran may move.
      // Whichever pre-registered slot runs first is the original execution; the next retryCount
      // slots are its retries, independent of Jest's randomized physical node order.
      let runnableRetryCount = 0
      let writeIndex = executedTestIndex + 1
      for (let readIndex = writeIndex; readIndex < siblings.length; readIndex++) {
        const sibling = siblings[readIndex]
        const siblingOriginalTest = efdRetryMetadataByTest.get(sibling)?.originalTest
        if (sibling === originalTest || siblingOriginalTest === originalTest) {
          if (runnableRetryCount >= retryCount) {
            removedRetryTests.add(sibling)
            const discardedCtx = this.concurrentTestStates.get(sibling.fn)?.ctx
            if (discardedCtx) {
              this.removeConcurrentTestContext(testName, discardedCtx)
            }
            continue
          }
          runnableRetryCount++
        }
        siblings[writeIndex++] = sibling
      }
      siblings.length = writeIndex

      const tests = executedTest.parent?.tests
      if (tests) {
        writeIndex = 0
        for (const test of tests) {
          if (!removedRetryTests.has(test)) {
            tests[writeIndex++] = test
          }
        }
        tests.length = writeIndex
      }
      return runnableRetryCount
    }

    /**
     * @param {object} describeBlock
     * @param {boolean} hasFocusedTests
     * @param {RegExp|undefined} testNamePattern
     * @returns {number}
     */
    markPre30ConcurrentTests (describeBlock, hasFocusedTests, testNamePattern) {
      if (describeBlock.mode === 'skip') return 0

      let testCount = 0
      for (const child of describeBlock.children) {
        if (child.type === 'describeBlock') {
          testCount += this.markPre30ConcurrentTests(child, hasFocusedTests, testNamePattern)
          continue
        }
        if (
          child.type !== 'test' ||
          !child.concurrent ||
          efdRetryMetadataByTest.has(child) ||
          isJestTestSkipped(child, hasFocusedTests, testNamePattern)
        ) {
          continue
        }

        const concurrentTestState = this.concurrentTestStates.get(child.fn)
        if (concurrentTestState) {
          concurrentTestState.trackEfdCompletion = true
          testCount++
        }
      }
      return testCount
    }

    /**
     * @param {object} describeBlock
     * @param {object} state
     * @returns {void}
     */
    preparePre30ConcurrentTests (describeBlock, state) {
      const testNamePattern = state.testNamePattern
        ? new RegExp(state.testNamePattern.source, state.testNamePattern.flags)
        : undefined
      this.#detachedEfdRetryConcurrency = state.maxConcurrency ?? 1
      this.#detachedEfdRetryQueue = []
      this.#pendingPre30ConcurrentTests = this.markPre30ConcurrentTests(
        describeBlock,
        state.hasFocusedTests,
        testNamePattern
      )
      this.drainDetachedEfdRetries()
    }

    /**
     * @param {object[]} tests
     * @returns {void}
     */
    orderConcurrentEfdRetries (tests) {
      if (!this.#efdRetryGatesByName) return

      const retryTests = []
      let originalTestIndex = 0
      for (const test of tests) {
        if (efdRetryMetadataByTest.has(test)) {
          retryTests.push(test)
        } else {
          tests[originalTestIndex++] = test
        }
      }
      for (const retryTest of retryTests) {
        tests[originalTestIndex++] = retryTest
      }
    }

    /**
     * @param {string} testName
     * @param {number} durationMs
     * @returns {void}
     */
    determineEfdRetries (testName, durationMs) {
      if (efdDeterminedRetries.has(testName)) return

      const retryCount = getEfdRetryCountForDuration(durationMs, this.#earlyFlakeDetectionRetryPolicy)
      efdDeterminedRetries.set(testName, retryCount)
      efdExpectedExecutions.set(testName, retryCount + 1)
      const retryGates = this.#efdRetryGatesByName?.get(testName)
      if (retryGates) {
        for (let retryIndex = 0; retryIndex < retryGates.length; retryIndex++) {
          retryGates[retryIndex].resolve(retryIndex < retryCount)
        }
      }
      if (retryCount === 0) {
        efdSlowAbortedTests.add(testName)
      }
    }

    /**
     * @returns {void}
     */
    removeDiscardedEfdRetries () {
      if (!this.#discardedEfdRetryTests) return

      for (const retryTest of this.#discardedEfdRetryTests) {
        const siblings = getTestEntries(retryTest.parent)
        const retryTestIndex = siblings?.indexOf(retryTest) ?? -1
        if (retryTestIndex !== -1) {
          siblings.splice(retryTestIndex, 1)
        }
      }
      this.#discardedEfdRetryTests = undefined
    }

    // The `add_test` payload has no test node, so derive its full name from the current describe block.
    getTestNameFromAddTestEvent (event, state) {
      const describeSuffix = getRawJestTestName(state.currentDescribeBlock)
      const testName = describeSuffix ? `${describeSuffix} ${event.testName}` : event.testName
      return removeSeedSuffixFromTestName(testName)
    }

    /**
     * Classifies a newly registered test and pre-registers every retry Jest may need.
     *
     * @param {object} event
     * @param {object} state
     * @returns {void}
     */
    handleAddTestEvent (event, state) {
      if (event.concurrent) {
        this.hasConcurrentTests = true
      }
      if (event.failing) {
        return
      }

      const testFullName = this.getTestNameFromAddTestEvent(event, state)
      const concurrentTestContexts = this.concurrentTestContexts.get(testFullName)
      const concurrentTestState = this.concurrentTestStates.get(event.fn) ||
        concurrentTestContexts?.at(-1)?.concurrentTestState
      const registeredTest = getTestEntries(state.currentDescribeBlock)?.at(-1)
      if (concurrentTestState && registeredTest?.fn === event.fn) {
        testContexts.set(registeredTest, concurrentTestState.ctx)
      }
      if (retriedTestsToNumAttempts.has(testFullName)) {
        return
      }
      const isSkipped = event.mode === 'todo' || event.mode === 'skip'
      const isAttemptToFix = this.isTestManagementTestsEnabled &&
        this.testManagementTestsForThisSuite?.attemptToFix?.includes(testFullName)
      const isDisabled = this.isTestManagementTestsEnabled &&
        this.testManagementTestsForThisSuite?.disabled?.includes(testFullName)
      if (isAttemptToFix && !isSkipped) {
        retriedTestsToNumAttempts.set(testFullName, 0)
        testsToBeRetried.add(testFullName)
        const retriesRegistered = this.registerRetryTests({
          concurrentTestState,
          jestEvent: event,
          state,
          retryCount: testManagementAttemptToFixRetries,
          retryType: 'Test Management (Attempt to Fix)',
          testFullName,
        })
        if (!retriesRegistered) {
          retriedTestsToNumAttempts.delete(testFullName)
          testsToBeRetried.delete(testFullName)
        }
      }

      const isModified = this.isImpactedTestsEnabled && (
        concurrentTestState?.ctx?.isModified ||
        this.isTestModified(event.asyncError, event.fn)
      )
      const isNew = this.isKnownTestsEnabled && !this.knownTestsForThisSuite.includes(testFullName)

      if (isNew && !isSkipped && !isAttemptToFix) {
        newTests.add(testFullName)
        if (DYNAMIC_NAME_RE.test(testFullName)) {
          // Populated directly for runInBand; for parallel workers the main process
          // collects these from the TEST_HAS_DYNAMIC_NAME span tag via worker-report:trace.
          newTestsWithDynamicNames.add(`${this.testSuite} › ${testFullName}`)
        }
      }

      if (
        isAttemptToFix ||
        isDisabled ||
        isSkipped ||
        !this.isEarlyFlakeDetectionEnabled ||
        !hasEfdRetries(this.#earlyFlakeDetectionRetryPolicy) ||
        (!isNew && !isModified)
      ) {
        return
      }

      retriedTestsToNumAttempts.set(testFullName, 0)
      testsToBeRetried.add(testFullName)
      const schedulingRetryCount = this.#earlyFlakeDetectionRetryPolicy.schedulingRetryCount
      const efdRetryGates = concurrentTestState
        ? this.createEfdRetryGates(schedulingRetryCount)
        : undefined
      if (efdRetryGates) {
        this.#efdRetryGatesByName ??= new Map()
        this.#efdRetryGatesByName.set(testFullName, efdRetryGates)
      }
      const retriesRegistered = this.registerRetryTests({
        concurrentTestState,
        efdRetryGates,
        isModified,
        jestEvent: event,
        state,
        retryCount: schedulingRetryCount,
        retryType: isModified ? 'Impacted tests' : 'Early flake detection',
        testFullName,
      })
      if (retriesRegistered) {
        efdCandidates.add(testFullName)
      } else {
        retriedTestsToNumAttempts.delete(testFullName)
        testsToBeRetried.delete(testFullName)
      }
    }

    async handleTestEvent (event, state) {
      if (isDatadogJestEventHandled(event)) return
      markDatadogJestEventHandled(event)

      if (event.name === 'add_test') {
        this.handleAddTestEvent(event, state)
      }

      if (super.handleTestEvent) {
        await super.handleTestEvent(event, state)
      }

      if (event.name === 'setup') {
        this.wrapConcurrentTest(state)
        this.bindTestEach(this.global.test)
      }
      if (
        event.name === 'run_describe_start' &&
        !hasConcurrentTestsStartEvent &&
        !event.describeBlock.parent &&
        this.#efdRetryGatesByName?.size > 0
      ) {
        this.preparePre30ConcurrentTests(event.describeBlock, state)
      }
      if (event.name === 'concurrent_tests_start') {
        this.orderConcurrentEfdRetries(event.tests)
      } else if (event.name === 'test_start') {
        const testName = getJestTestName(event.test)
        let isAttemptToFix = false
        let isDisabled = false
        let isQuarantined = false
        if (this.isTestManagementTestsEnabled) {
          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(testName)
          isDisabled = this.testManagementTestsForThisSuite?.disabled?.includes(testName)
          isQuarantined = this.testManagementTestsForThisSuite?.quarantined?.includes(testName)
          if (!isAttemptToFix && isDisabled) {
            event.test.mode = 'skip'
          }
        }
        if (
          event.test.mode === 'todo' ||
          isJestTestSkipped(event.test, state.hasFocusedTests, state.testNamePattern)
        ) {
          return
        }

        const registeredConcurrentTestState = testContexts.get(event.test)?.concurrentTestState
        const concurrentTestState = this.concurrentTestStates.get(event.test.fn) ||
          registeredConcurrentTestState
        let concurrentCtx = concurrentTestState?.ctx
        if (concurrentCtx) {
          this.removeConcurrentTestContext(testName, concurrentCtx)
        } else {
          concurrentCtx = this.getNextConcurrentTestContext(testName)
        }
        if (hasConcurrentTestsStartEvent && concurrentCtx?.efdRetryGates) {
          const retryGate = concurrentCtx.efdRetryGates[concurrentCtx.efdRetryIndex - 1]
          const shouldRun = await retryGate.promise
          if (!shouldRun) {
            concurrentCtx.isDiscardedEfdRetry = true
            event.test.mode = 'skip'
            return
          }
        }
        if (testsToBeRetried.has(testName)) {
          // This is needed because we're retrying tests with the same name
          this.resetSnapshotState()
          this.resetMockState()
        }

        let isNewTest = false
        let numEfdRetry = null
        let numOfAttemptsToFixRetries = null
        const testParameters = concurrentCtx?.testParameters ||
          concurrentTestState?.ctx?.testParameters ||
          this.testParametersByFunction.get(event.test.fn) ||
          getTestParametersString(this.nameToParams, event.test.name)

        if (isAttemptToFix) {
          numOfAttemptsToFixRetries = retriedTestsToNumAttempts.get(testName)
          retriedTestsToNumAttempts.set(testName, numOfAttemptsToFixRetries + 1)
        }

        const efdRetryMetadata = efdRetryMetadataByTest.get(event.test)
        let isModified = efdRetryMetadata?.isModified ||
          this.isTestModified(event.test.asyncError, event.test.fn)
        if (concurrentCtx?.isModified || concurrentTestState?.ctx?.isModified) {
          isModified = true
        }

        if (this.isKnownTestsEnabled) {
          isNewTest = newTests.has(testName)
        }

        const willRunEfd = this.isEarlyFlakeDetectionEnabled &&
          hasEfdRetries(this.#earlyFlakeDetectionRetryPolicy) &&
          (isNewTest || isModified)
        event.test[ATR_RETRY_SUPPRESSION_FLAG] = Boolean(isAttemptToFix || willRunEfd)

        if (!isAttemptToFix && willRunEfd) {
          numEfdRetry = retriedTestsToNumAttempts.get(testName)
          retriedTestsToNumAttempts.set(testName, numEfdRetry + 1)
        }

        const isJestRetry = event.test?.invocations > 1
        const hasDynamicName = isNewTest && DYNAMIC_NAME_RE.test(testName)
        const ctx = concurrentCtx || concurrentTestState?.ctx || {}
        ctx.name = testName
        ctx.suite = this.testSuite
        ctx.testSourceFile = this.testSourceFile
        ctx.displayName = this.displayName
        ctx.testParameters = testParameters
        ctx.frameworkVersion = jestVersion
        ctx.isNew = isNewTest
        ctx.isEfdRetry ||= numEfdRetry > 0
        ctx.efdRetryIndex ??= efdRetryMetadata?.retryIndex
        ctx.isAttemptToFix = isAttemptToFix
        ctx.isAttemptToFixRetry ||= numOfAttemptsToFixRetries > 0
        ctx.isJestRetry = isJestRetry
        ctx.isDisabled = isDisabled
        ctx.isQuarantined = isQuarantined
        ctx.isModified = isModified
        ctx.hasDynamicName = hasDynamicName
        ctx.testSuiteAbsolutePath = this.testSuiteAbsolutePath
        if (concurrentTestState) {
          ctx.concurrentTestState = concurrentTestState
          concurrentTestState.ctx = ctx
        }
        testContexts.set(event.test, ctx)

        if (isAttemptToFix) {
          logAttemptToFixTestExecution(this.testSuite, testName, loggedAttemptToFixTests)
        }

        const wrapTestAndHooks = () => {
          let p = event.test.parent
          const hooks = []
          while (p != null) {
            hooks.push(...p.hooks)
            p = p.parent
          }
          for (const hook of hooks) {
            let hookFn = hook.fn
            if (originalHookFns.has(hook)) {
              hookFn = originalHookFns.get(hook)
            } else {
              originalHookFns.set(hook, hookFn)
            }
            const newHookFn = shimmer.wrapFunction(hookFn, hookFn => function (...args) {
              return testFnCh.runStores(ctx, () => hookFn.apply(this, args))
            })
            hook.fn = newHookFn
          }

          const originalFn = event.test.fn
          originalTestFns.set(event.test, originalFn)

          const newFn = shimmer.wrapFunction(event.test.fn, testFn => function (...args) {
            return testFnCh.runStores(ctx, () => testFn.apply(this, args))
          })

          event.test.fn = newFn
        }

        const isConcurrentTest = event.test.concurrent || ctx.concurrentTestState
        if (isConcurrentTest) {
          if (!ctx.currentStore && event.test.errors?.length) {
            testStartCh.runStores(ctx, () => {})
          }
        } else if (ctx.currentStore) {
          wrapTestAndHooks()
        } else {
          testStartCh.runStores(ctx, wrapTestAndHooks)
        }
      }

      if (event.name === 'hook_start' && (event.hook.type === 'beforeEach' || event.hook.type === 'afterEach')) {
        const ctx = testContexts.get(event.test) || this.concurrentTestStates.get(event.test?.fn)?.ctx
        if (ctx?.concurrentTestState && (!ctx.isDisabled || ctx.isAttemptToFix)) {
          let hookFn = event.hook.fn
          if (originalHookFns.has(event.hook)) {
            hookFn = originalHookFns.get(event.hook)
          } else {
            originalHookFns.set(event.hook, hookFn)
          }
          let hookContexts = concurrentHookContextQueues.get(event.hook)
          if (!hookContexts) {
            hookContexts = []
            concurrentHookContextQueues.set(event.hook, hookContexts)
          }
          hookContexts.push(ctx)
          if (!ctx.currentStore) {
            testStartCh.runStores(ctx, () => {})
          }
          let concurrentHookFn = concurrentHookFns.get(event.hook)
          if (!concurrentHookFn) {
            concurrentHookFn = shimmer.wrapFunction(hookFn, hookFn => function (...args) {
              const hookContexts = concurrentHookContextQueues.get(event.hook)
              const [hookCtx] = hookContexts || []
              if (hookCtx) {
                hookContexts.shift()
                return testFnCh.runStores(hookCtx, () => hookFn.apply(this, args))
              }
              return hookFn.apply(this, args)
            })
            concurrentHookFns.set(event.hook, concurrentHookFn)
          }
          event.hook.fn = concurrentHookFn
        }
      }

      if (event.name === 'hook_start' && (event.hook.type === 'beforeAll' || event.hook.type === 'afterAll')) {
        const ctx = { testSuiteAbsolutePath: this.testSuiteAbsolutePath }
        let hookFn = event.hook.fn
        if (originalHookFns.has(event.hook)) {
          hookFn = originalHookFns.get(event.hook)
        } else {
          originalHookFns.set(event.hook, hookFn)
        }
        event.hook.fn = shimmer.wrapFunction(hookFn, hookFn => function (...args) {
          return testSuiteHookFnCh.runStores(ctx, () => hookFn.apply(this, args))
        })
      }

      if (event.name === 'test_done') {
        const retryCtx = testContexts.get(event.test)
        if (!hasConcurrentTestsStartEvent && retryCtx?.concurrentTestState) {
          this.completePre30ConcurrentTest(retryCtx.concurrentTestState)
        }
        if (retryCtx?.detachedEfdRetryPromise) {
          await retryCtx.detachedEfdRetryPromise
          if (retryCtx.detachedEfdRetryError !== undefined) {
            event.test.errors.push(retryCtx.detachedEfdRetryError)
          }
        }
        if (retryCtx?.isDiscardedEfdRetry) {
          this.#discardedEfdRetryTests ??= new Set()
          this.#discardedEfdRetryTests.add(event.test)
          return
        }

        const originalError = event.test?.errors?.[0]
        let status = 'pass'
        if (event.test.errors && event.test.errors.length) {
          status = 'fail'
        }
        // restore in case it is retried
        if (originalTestFns.has(event.test)) {
          event.test.fn = originalTestFns.get(event.test)
        }
        // If ATR retry is being suppressed for this test (due to EFD or Attempt to Fix taking precedence)
        // and the test has errors for this attempt, store the errors temporarily and clear them
        // so Jest won't treat this attempt as failed (the real status will be reported after retries).
        if (event.test?.[ATR_RETRY_SUPPRESSION_FLAG] && event.test.errors?.length) {
          atrSuppressedErrors.set(event.test, event.test.errors)
          event.test.errors = []
        }

        let attemptToFixPassed = false
        let attemptToFixFailed = false
        let failedAllTests = false
        let isAttemptToFix = false
        const testName = getJestTestName(event.test)
        if (this.isTestManagementTestsEnabled) {
          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(testName)
          if (isAttemptToFix) {
            if (attemptToFixRetriedTestsStatuses.has(testName)) {
              attemptToFixRetriedTestsStatuses.get(testName).push(status)
            } else {
              attemptToFixRetriedTestsStatuses.set(testName, [status])
            }
            const testStatuses = attemptToFixRetriedTestsStatuses.get(testName)
            // Check if this is the last attempt to fix.
            // If it is, we'll set the failedAllTests flag to true if all the tests failed
            // If all tests passed, we'll set the attemptToFixPassed flag to true
            if (testStatuses.length === testManagementAttemptToFixRetries + 1) {
              if (testStatuses.includes('fail')) {
                attemptToFixFailed = true
              }
              if (testStatuses.every(status => status === 'fail')) {
                failedAllTests = true
              } else if (testStatuses.every(status => status === 'pass')) {
                attemptToFixPassed = true
              }
            }
          }
        }

        // The first execution selects how many pre-registered EFD retries remain runnable.
        if (
          this.isEarlyFlakeDetectionEnabled &&
          efdCandidates.has(testName) &&
          event.test.invocations === 1 &&
          !efdDeterminedRetries.has(testName)
        ) {
          this.determineEfdRetries(testName, event.test.duration ?? 0)
          if (!this.#efdRetryGatesByName?.has(testName)) {
            this.discardEfdRetries(testName, event.test, efdDeterminedRetries.get(testName))
          }
        }

        const isEfdRetry = retryCtx?.isEfdRetry === true
        if (efdCandidates.has(testName)) {
          let testStatuses = efdTestStatuses.get(testName)
          if (testStatuses) {
            testStatuses.push(status)
          } else {
            testStatuses = [status]
            efdTestStatuses.set(testName, testStatuses)
          }
          const efdRetryCount = efdDeterminedRetries.get(testName) ?? 0
          if (efdRetryCount > 0 && testStatuses.length === efdExpectedExecutions.get(testName) &&
            testStatuses.every(status => status === 'fail')) {
            failedAllTests = true
          }
        }

        // ATR: set failedAllTests when all auto test retries were exhausted and every attempt failed
        if (this.isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry) {
          const maxRetries = Number(this.global[RETRY_TIMES]) || 0
          if (event.test?.invocations === maxRetries + 1 && status === 'fail') {
            failedAllTests = true
          }
        }

        const promises = {}
        const numRetries = this.global[RETRY_TIMES]
        const numTestExecutions = event.test?.invocations
        const willBeRetriedByAutoTestRetry = numRetries > 0 && numTestExecutions - 1 < numRetries
        const isFailedTestReplayAllowed = !this.hasConcurrentTests
        const willBeRetriedByFailedTestReplay = isFailedTestReplayAllowed && willBeRetriedByAutoTestRetry
        const mightHitBreakpoint = this.isDiEnabled && isFailedTestReplayAllowed && numTestExecutions >= 2

        // For quarantined tests, track failures so the session can be marked as passing later,
        // and suppress errors so Jest does not mark the test suite as failing.
        // The actual status ('fail') is already captured above for dd-trace reporting.
        // Only suppress on the final execution — not when ATR/EFD/ATF will retry the test.
        if (!event.test?.[ATR_RETRY_SUPPRESSION_FLAG] && !willBeRetriedByAutoTestRetry) {
          const quarantineCtx = testContexts.get(event.test)
          if (quarantineCtx?.isQuarantined && !quarantineCtx.isAttemptToFix && event.test.errors?.length) {
            quarantinedFailingTests.add(`${quarantineCtx.suite} › ${quarantineCtx.name}`)
            event.test.errors = []
          }
        }

        const ctx = testContexts.get(event.test)
        if (!ctx) {
          log.warn('"ci:jest:test_done": no context found for test "%s"', testName)
          return
        }
        if (!isJestWorker) {
          recordTestManagementExecution({
            testSuite: ctx.suite,
            testName: ctx.name,
            status,
            isAttemptToFix: ctx.isAttemptToFix,
            isDisabled: ctx.isDisabled,
            isQuarantined: ctx.isQuarantined,
          })
        }
        if (ctx.concurrentTestState && !ctx.currentStore && !ctx.isDisabled) {
          testStartCh.runStores(ctx, () => {})
        }

        const finalStatus = this.getFinalStatus(testName,
          status,
          !!ctx.isNew,
          !!ctx.isModified,
          isEfdRetry,
          isAttemptToFix,
          numTestExecutions)

        if (status === 'fail') {
          const shouldSetProbe = this.isDiEnabled && willBeRetriedByFailedTestReplay && numTestExecutions === 1
          testErrCh.publish({
            ...ctx.currentStore,
            error: formatJestError(originalError),
            shouldSetProbe,
            shouldWaitForHitProbe: mightHitBreakpoint,
            promises,
          })
        }

        if (promises.hitBreakpointPromise) {
          await promises.hitBreakpointPromise
        }

        let isAtrRetry = false
        if (this.isFlakyTestRetriesEnabled && event.test?.invocations > 1 && !isAttemptToFix && !isEfdRetry) {
          isAtrRetry = true
        }

        testFinishCh.publish({
          ...ctx.currentStore,
          status,
          testStartLine: getTestLineStart(event.test.asyncError, this.testSuite),
          attemptToFixPassed,
          failedAllTests,
          attemptToFixFailed,
          isAtrRetry,
          finalStatus,
          earlyFlakeAbortReason: efdSlowAbortedTests.has(testName) ? 'slow' : undefined,
          promises,
        })

        if (promises.hitBreakpointPromise) {
          await promises.hitBreakpointPromise
        }
        if (promises.isProbeReady) {
          await promises.isProbeReady
        }
        if (ctx.concurrentTestState) {
          ctx.currentStore = undefined
        }
      } else if (event.name === 'run_finish') {
        this.removeDiscardedEfdRetries()
        for (const [test, errors] of atrSuppressedErrors) {
          // Do not restore errors for non-ATF quarantined tests — they should stay suppressed
          // so Jest doesn't see the failure (prevents --bail from stopping the run).
          const ctx = testContexts.get(test)
          if (ctx?.isQuarantined && !ctx.isAttemptToFix) {
            const testName = getJestTestName(test)
            quarantinedFailingTests.add(`${ctx.suite} › ${testName}`)
          } else {
            test.errors = errors
          }
        }
        atrSuppressedErrors.clear()

        // In parallel mode, send suppressed quarantine info to the main process
        // so it can include them in the session summary.
        // In runInBand mode, keep the set — it will be consumed by the session-level code directly.
        if (quarantinedFailingTests.size > 0 && sendQuarantineInfoToMainProcess([...quarantinedFailingTests])) {
          quarantinedFailingTests.clear()
        }

        efdDeterminedRetries.clear()
        efdExpectedExecutions.clear()
        efdSlowAbortedTests.clear()
        efdCandidates.clear()
        newTests.clear()
        retriedTestsToNumAttempts.clear()
        attemptToFixRetriedTestsStatuses.clear()
        testsToBeRetried.clear()
        this.#efdRetryGatesByName = undefined
        this.#detachedEfdRetryQueue = undefined
        testSuiteDatadogEnvironments.delete(this.testSuiteAbsolutePath)
      } else if (event.name === 'test_skip' || event.name === 'test_todo') {
        const testName = getJestTestName(event.test)
        const retryGates = this.#efdRetryGatesByName?.get(testName)
        if (retryGates) {
          if (efdRetryMetadataByTest.has(event.test)) {
            this.#discardedEfdRetryTests ??= new Set()
            this.#discardedEfdRetryTests.add(event.test)
            return
          }
          for (const gate of retryGates) {
            gate.resolve(false)
          }
        } else {
          this.discardEfdRetries(testName, event.test)
        }
        testSkippedCh.publish({
          test: {
            name: testName,
            suite: this.testSuite,
            testSourceFile: this.testSourceFile,
            displayName: this.displayName,
            frameworkVersion: jestVersion,
            testStartLine: getTestLineStart(event.test.asyncError, this.testSuite),
          },
          isDisabled: this.testManagementTestsForThisSuite?.disabled?.includes(testName),
        })
      }
    }

    getEfdResult ({ testName, isNewTest, isModifiedTest }) {
      const isEfdEnabled = this.isEarlyFlakeDetectionEnabled
      const isEfdActive = isEfdEnabled &&
        hasEfdRetries(this.#earlyFlakeDetectionRetryPolicy) &&
        (isNewTest || isModifiedTest)
      const testStatuses = efdTestStatuses.get(testName)
      const isFinalEfdTestExecution = isEfdActive &&
        (efdSlowAbortedTests.has(testName) || testStatuses?.length === (efdExpectedExecutions.get(testName) ?? 0))

      let finalStatus
      if (isEfdActive && isFinalEfdTestExecution) {
        // For EFD: The framework reports 'pass' if ANY attempt passed (flaky but not failing)
        finalStatus = testStatuses && testStatuses.includes('pass') ? 'pass' : 'fail'
      }

      return { isEfdEnabled, isEfdActive, isFinalEfdTestExecution, finalStatus }
    }

    getAtrResult ({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations }) {
      const isAtrEnabled =
        this.isFlakyTestRetriesEnabled &&
        !isEfdRetry &&
        !isAttemptToFix &&
        Number.isFinite(this.global[RETRY_TIMES])
      const isLastAtrRetry =
        status === 'pass' || numberOfTestInvocations >= (Number(this.global[RETRY_TIMES]) + 1)
      const isFinalAtrTestExecution = isAtrEnabled && isLastAtrRetry

      // For ATR: The last execution's status is what the framework reports
      return { isAtrEnabled, isFinalAtrTestExecution, finalStatus: status }
    }

    getAttemptToFixResult ({ testName, isAttemptToFix, numberOfExecutedRetries }) {
      const isAttemptToFixEnabled =
        this.isTestManagementTestsEnabled &&
        isAttemptToFix &&
        Number.isFinite(testManagementAttemptToFixRetries)
      const isFinalAttemptToFixExecution = isAttemptToFixEnabled &&
        numberOfExecutedRetries >= (testManagementAttemptToFixRetries + 1)

      let finalStatus
      if (isAttemptToFixEnabled && isFinalAttemptToFixExecution) {
        // For Attempt to Fix: 'pass' only if ALL attempts passed, 'fail' if ANY failed
        const testStatuses = attemptToFixRetriedTestsStatuses.get(testName)
        finalStatus = testStatuses && testStatuses.every(status => status === 'pass') ? 'pass' : 'fail'
      }

      return { isAttemptToFixEnabled, isFinalAttemptToFixExecution, finalStatus }
    }

    getFinalStatus (
      testName,
      status,
      isNewTest,
      isModifiedTest,
      isEfdRetry,
      isAttemptToFix,
      numberOfTestInvocations
    ) {
      const numberOfExecutedRetries = retriedTestsToNumAttempts.get(testName) ?? 0

      const efdResult = this.getEfdResult({
        testName,
        isNewTest,
        isModifiedTest,
      })
      const atrResult = this.getAtrResult({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations })
      const attemptToFixResult = this.getAttemptToFixResult({
        testName,
        isAttemptToFix,
        numberOfExecutedRetries,
      })

      // When no retry features are active, every test execution is final
      const noRetryFeaturesActive =
        !efdResult.isEfdActive &&
        !atrResult.isAtrEnabled &&
        !attemptToFixResult.isAttemptToFixEnabled
      const isFinalTestExecution = noRetryFeaturesActive ||
        efdResult.isFinalEfdTestExecution ||
        atrResult.isFinalAtrTestExecution ||
        attemptToFixResult.isFinalAttemptToFixExecution

      if (!isFinalTestExecution) {
        return
      }

      // If the test is quarantined, regardless of its actual execution result,
      // the final status of its last execution should be reported as 'skip'.
      if (!attemptToFixResult.isAttemptToFixEnabled &&
        this.isTestManagementTestsEnabled &&
        this.testManagementTestsForThisSuite?.quarantined?.includes(testName)) {
        return 'skip'
      }

      return efdResult.finalStatus || attemptToFixResult.finalStatus || atrResult.finalStatus
    }

    teardown () {
      if (this._globalProxy?.propertyToValue) {
        for (const [key] of this._globalProxy.propertyToValue) {
          if (typeof key === 'string' && key.startsWith('_dd')) {
            this._globalProxy.propertyToValue.delete(key)
          }
        }
      }
      const clearActiveTestSuite = () => {
        realSetTimeout(() => {
          if (activeTestSuiteAbsolutePath === this.testSuiteAbsolutePath) {
            activeTestSuiteAbsolutePath = undefined
          }
        }, 0)
      }
      const result = super.teardown()
      if (result?.then) {
        return result.finally(clearActiveTestSuite)
      }
      clearActiveTestSuite()
      return result
    }
  }
}

function getTestEnvironment (pkg, jestVersion) {
  if (pkg.default) {
    const wrappedTestEnvironment = getWrappedEnvironment(pkg.default, jestVersion)
    return new Proxy(pkg, {
      get (target, prop) {
        if (prop === 'default') {
          return wrappedTestEnvironment
        }
        if (prop === 'TestEnvironment') {
          return wrappedTestEnvironment
        }
        return target[prop]
      },
    })
  }
  return getWrappedEnvironment(pkg, jestVersion)
}

function getRepositoryRootFromConfig (config, fallbackRootDir) {
  return config?.testEnvironmentOptions?._ddRepositoryRoot || repositoryRoot || fallbackRootDir || process.cwd()
}

function getRepositoryRootFromContexts (contexts, fallbackRootDir) {
  const [firstContext] = contexts || []
  return getRepositoryRootFromConfig(firstContext?.config, fallbackRootDir)
}

function getRepositoryRootFromTest (test, fallbackRootDir) {
  return getRepositoryRootFromConfig(test?.context?.config, fallbackRootDir)
}

function shouldCollectJestCoverageForTia () {
  return shouldReportJestSuiteCoverageForTia() ||
    (isJestCoverageBackfillSupported && isItrEnabled && isCoverageReportUploadEnabled)
}

function shouldReportJestSuiteCoverageForTia () {
  return isItrEnabled && isCodeCoverageEnabled
}

function hasJestCoverageMap () {
  return isUserCodeCoverageEnabled || shouldCollectJestCoverageForTia()
}

// TIA coverage backfill is part of Datadog Code Coverage, not the per-suite TIA coverage upload.
function isTiaCoverageBackfillEnabled () {
  return isJestCoverageBackfillSupported && isItrEnabled && isCoverageReportUploadEnabled && hasJestCoverageMap()
}

// Non-TIA Jest coverage keeps the legacy metric. TIA only reports it when Datadog Code Coverage is enabled and
// either the run is complete locally or the skipped suites can be backfilled.
function shouldReportCodeCoverageLinesPct () {
  if (!hasJestCoverageMap()) return false
  if (!isItrEnabled) return true
  if (!isCoverageReportUploadEnabled) return false

  // If no suites were actually skipped, the local Jest coverage map is complete and does not need backfill.
  return !isSuitesSkipped || isTiaCoverageBackfillEnabled()
}

function getHookRequire (hookMeta) {
  if (!hookMeta?.moduleBaseDir) return

  return createRequire(path.join(hookMeta.moduleBaseDir, 'package.json'))
}

function getCoverageBackfillRequire (CoverageReporter) {
  const hookedCoverageReporterRequire = CoverageReporter && coverageReporterRequires.get(CoverageReporter)
  if (hookedCoverageReporterRequire) return hookedCoverageReporterRequire
  if (coverageReporterRequire) return coverageReporterRequire

  const coverageReporterFilename = CoverageReporter?.filename || coverageReporterClass?.filename
  if (coverageReporterFilename) {
    return createRequire(`${path.join(path.dirname(coverageReporterFilename), 'CoverageWorker')}.js`)
  }

  return require
}

function addDatadogBailReporter (globalConfig) {
  if (!globalConfig.bail) return globalConfig

  const reporters = globalConfig.reporters || [['default', {}]]
  for (const [reporter] of reporters) {
    if (reporter === JEST_BAIL_REPORTER_PATH) {
      return globalConfig
    }
  }

  return {
    ...globalConfig,
    reporters: [
      ...reporters,
      [JEST_BAIL_REPORTER_PATH, {}],
    ],
  }
}

function getTestContexts (tests) {
  if (!tests?.length) return

  const contexts = new Set()
  for (const test of tests) {
    if (test.context) {
      contexts.add(test.context)
    }
  }
  return contexts.size ? contexts : undefined
}

function getCoverageBackfillContexts (contexts) {
  return contexts?.size ? contexts : coverageBackfillContexts || contexts
}

function resetSuiteSkippingRunState () {
  isSuitesSkipped = false
  numSkippedSuites = 0
  hasUnskippableSuites = false
  hasForcedToRunSuites = false
  hasFilteredSkippableSuites = false
  skippedSuitesCoverage = {}
  lastCoverageMap = undefined
  lastCoverageMapRootDir = undefined
  coverageBackfillContexts = undefined
  coverageBackfillFiles = undefined
}

function resetLibraryConfiguration () {
  knownTests = {}
  isCodeCoverageEnabled = false
  isCoverageReportUploadEnabled = false
  isItrEnabled = false
  isSuitesSkippingEnabled = false
  isEarlyFlakeDetectionEnabled = false
  earlyFlakeDetectionFaultyThreshold = 30
  isEarlyFlakeDetectionFaulty = false
  isKnownTestsEnabled = false
  isTestManagementTestsEnabled = false
  testManagementTests = {}
  testManagementAttemptToFixRetries = 0
  isImpactedTestsEnabled = false
  modifiedFiles = undefined
  repositoryRoot = undefined
}

function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
  if (!isItrEnabled || !isSuitesSkippingEnabled) return originalTests

  const repositoryRoot = getRepositoryRootFromTest(originalTests[0], rootDir)
  const jestSuitesToRun = getJestSuitesToRun(skippableSuites, originalTests, repositoryRoot, rootDir)
  hasFilteredSkippableSuites = true
  log.debug(
    'Jest discovered %d suites; skipped %d using %d skippable candidates; %d suites will run.',
    originalTests.length,
    jestSuitesToRun.skippedSuites.length,
    skippableSuites.length,
    jestSuitesToRun.suitesToRun.length
  )
  hasUnskippableSuites = jestSuitesToRun.hasUnskippableSuites
  hasForcedToRunSuites = jestSuitesToRun.hasForcedToRunSuites

  isSuitesSkipped ||= jestSuitesToRun.suitesToRun.length !== originalTests.length
  numSkippedSuites += jestSuitesToRun.skippedSuites.length
  const hasSkippableSuitesCoverage = skippableSuitesCoverage !== undefined
  skippedSuitesCoverage = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage
    ? skippableSuitesCoverage
    : {}
  coverageBackfillContexts = isSuitesSkipped && isTiaCoverageBackfillEnabled()
    ? getTestContexts(originalTests)
    : undefined
  coverageBackfillFiles = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage
    ? getCoverageBackfillFiles(skippableSuitesCoverage, repositoryRoot, getTestSuitePath)
    : undefined

  itrSkippedSuitesCh.publish({ skippedSuites: jestSuitesToRun.skippedSuites, frameworkVersion })

  return jestSuitesToRun.suitesToRun
}

function applySkippedCoverageToJestCoverageMap (coverageMap, rootDir) {
  if (!coverageMap || !isSuitesSkipped || !isTiaCoverageBackfillEnabled()) return
  applySkippedCoverageToCoverage(
    coverageMap,
    skippedSuitesCoverage,
    rootDir || process.cwd()
  )
}

function getSessionFinishError (results) {
  const numFailedTestSuites = results?.numFailedTestSuites || 0
  const numFailedTests = results?.numFailedTests || 0

  return new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
}

function getTestSessionCoveragePayload (results, fallbackRootDir) {
  const payload = {}
  if (!shouldReportCodeCoverageLinesPct()) return payload

  try {
    const coverageMap = results?.coverageMap || lastCoverageMap
    const coverageRootDir = lastCoverageMapRootDir ||
      repositoryRoot ||
      fallbackRootDir ||
      process.cwd()
    if (isSuitesSkipped) {
      applySkippedCoverageToJestCoverageMap(coverageMap, coverageRootDir)
    }
    payload.testCodeCoverageLinesTotal = getTestCoverageLinesPercentage(
      coverageMap,
      undefined,
      coverageRootDir
    )
    if (isTiaCoverageBackfillEnabled()) {
      payload.testSessionCoverageFiles = getExecutableFilesFromCoverage(coverageMap).map(({ filename, bitmap }) => ({
        filename: getTestSuitePath(filename, coverageRootDir),
        bitmap,
      }))
    }
  } catch {
    // ignore errors
  }

  return payload
}

function getNumBailFailures (results) {
  const numFailedTests = results?.numFailedTests || 0
  const numFailedSuites = results?.numRuntimeErrorTestSuites === undefined
    ? (numFailedTests === 0 ? results?.numFailedTestSuites || 0 : 0)
    : results.numRuntimeErrorTestSuites

  return numFailedTests + numFailedSuites
}

function shouldFinishBailTestSession (globalConfig, results) {
  return !!globalConfig?.bail && getNumBailFailures(results) >= globalConfig.bail
}

/**
 * @param {Record<string, unknown> & { onDone?: () => void }} payload
 */
async function waitForTestSessionFinish (payload) {
  if (!testSessionFinishCh.hasSubscribers || hasFinishedTestSession) return

  hasFinishedTestSession = true

  let timeoutId

  let onDone
  const flushPromise = new Promise((resolve) => {
    onDone = () => {
      clearTimeout(timeoutId)
      resolve()
    }
  })

  const timeoutPromise = new Promise((resolve) => {
    timeoutId = realSetTimeout(() => {
      resolve('timeout')
    }, FLUSH_TIMEOUT)
    timeoutId.unref?.()
  })

  publishWithCompletion(testSessionFinishCh, payload, onDone)

  const waitingResult = await Promise.race([flushPromise, timeoutPromise])

  if (waitingResult === 'timeout') {
    log.error('Timeout waiting for the tracer to flush')
  }
}

function getTestSessionFinishPayload (status, error, extra = {}) {
  return {
    status,
    isSuitesSkipped,
    isSuitesSkippingEnabled,
    isCodeCoverageEnabled,
    isCoverageReportUploadEnabled,
    numSkippedSuites,
    hasUnskippableSuites,
    hasForcedToRunSuites,
    error,
    isEarlyFlakeDetectionEnabled,
    isEarlyFlakeDetectionFaulty,
    isTestManagementTestsEnabled,
    ...extra,
  }
}

async function finishBailTestSession (results, fallbackRootDir) {
  await waitForTestSessionFinish(getTestSessionFinishPayload(
    'fail',
    getSessionFinishError(results),
    getTestSessionCoveragePayload(results, fallbackRootDir)
  ))
}

jestSessionState.finishBailTestSession = finishBailTestSession

function reporterDispatcherWrapper (reporterDispatcherPackage) {
  const ReporterDispatcher = reporterDispatcherPackage.default ?? reporterDispatcherPackage
  if (ReporterDispatcher?.prototype?.onRunComplete) {
    shimmer.wrap(ReporterDispatcher.prototype, 'onRunComplete', onRunComplete => function (contexts, results) {
      if (isSuitesSkipped && isTiaCoverageBackfillEnabled()) {
        applySkippedCoverageToJestCoverageMap(results?.coverageMap, getRepositoryRootFromContexts(contexts))
      }
      return onRunComplete.apply(this, arguments)
    })
  }

  return reporterDispatcherPackage
}

function wrapCoverageReporter (CoverageReporter, hookMeta) {
  if (!CoverageReporter?.prototype?.onRunComplete || wrappedCoverageReporters.has(CoverageReporter)) {
    return
  }

  coverageReporterRequire = getHookRequire(hookMeta) || coverageReporterRequire
  if (coverageReporterRequire) {
    coverageReporterRequires.set(CoverageReporter, coverageReporterRequire)
  }
  coverageReporterClass = CoverageReporter
  wrappedCoverageReporters.add(CoverageReporter)
  if (CoverageReporter.prototype._addUntestedFiles) {
    shimmer.wrap(CoverageReporter.prototype, '_addUntestedFiles', addUntestedFiles => function (...args) {
      const rootDir = repositoryRoot || this._globalConfig?.rootDir || process.cwd()
      args[0] = getCoverageBackfillContexts(args[0])
      const result = addUntestedFiles.apply(this, args)
      if (!isSuitesSkipped || !isTiaCoverageBackfillEnabled()) return result

      const addBackfillAndApplyCoverage = () => {
        return addCoverageBackfillUntestedFiles({
          coverageMap: this._coverageMap,
          testContexts: args[0],
          rootDir,
          CoverageReporter,
          coverageBackfillFiles,
          getCoverageBackfillRequire,
        }).then(() => {
          applySkippedCoverageToJestCoverageMap(this._coverageMap, rootDir)
        })
      }

      return Promise.resolve(result).then(value => {
        return addBackfillAndApplyCoverage().then(() => value)
      })
    })
  }

  shimmer.wrap(CoverageReporter.prototype, 'onRunComplete', onRunComplete => async function (contexts, results) {
    const coverageContexts = getCoverageBackfillContexts(contexts)
    const rootDir = getRepositoryRootFromContexts(coverageContexts, this._globalConfig?.rootDir)
    const coverageMap = results?.coverageMap || this._coverageMap
    if (isSuitesSkipped && isTiaCoverageBackfillEnabled()) {
      await addCoverageBackfillUntestedFiles({
        coverageMap,
        testContexts: coverageContexts,
        rootDir,
        CoverageReporter,
        coverageBackfillFiles,
        getCoverageBackfillRequire,
      })
      applySkippedCoverageToJestCoverageMap(coverageMap, rootDir)
    }
    lastCoverageMap = coverageMap
    lastCoverageMapRootDir = rootDir
    const result = await onRunComplete.call(this, coverageContexts, results)
    if (shouldFinishBailTestSession(this._globalConfig, results)) {
      await finishBailTestSession(results, rootDir)
    }
    return result
  })
}

function reportersWrapper (reportersPackage, _version, _isIitm, hookMeta) {
  wrapCoverageReporter(reportersPackage.CoverageReporter, hookMeta)
  return reportersPackage
}

function coverageReporterWrapper (coverageReporterPackage, _version, _isIitm, hookMeta) {
  wrapCoverageReporter(coverageReporterPackage.default ?? coverageReporterPackage, hookMeta)
  return coverageReporterPackage
}

addHook({
  name: 'jest-environment-node',
  versions: [MINIMUM_JEST_VERSION],
}, getTestEnvironment)

addHook({
  name: 'jest-environment-node',
  file: 'build/index.js',
  versions: [MINIMUM_JEST_VERSION],
}, getTestEnvironment)

addHook({
  name: 'jest-environment-jsdom',
  versions: [MINIMUM_JEST_VERSION],
}, getTestEnvironment)

addHook({
  name: 'jest-environment-jsdom',
  file: 'build/index.js',
  versions: [MINIMUM_JEST_VERSION],
}, getTestEnvironment)

addHook({
  name: '@happy-dom/jest-environment',
  versions: ['>=10.0.0'],
}, getTestEnvironment)

function getWrappedScheduleTests (scheduleTests, frameworkVersion) {
  // `scheduleTests` is an async function
  return function (tests) {
    if (!isSuitesSkippingEnabled || hasFilteredSkippableSuites) {
      return scheduleTests.apply(this, arguments)
    }
    const [test] = tests
    const rootDir = test?.context?.config?.rootDir

    arguments[0] = applySuiteSkipping(tests, rootDir, frameworkVersion)

    return scheduleTests.apply(this, arguments)
  }
}

function searchSourceWrapper (searchSourcePackage, frameworkVersion) {
  const SearchSource = searchSourcePackage.default ?? searchSourcePackage

  shimmer.wrap(SearchSource.prototype, 'getTestPaths', getTestPaths => async function () {
    const testPaths = await getTestPaths.apply(this, arguments)
    const [{ rootDir, shard }] = arguments

    if (isKnownTestsEnabled) {
      const projectSuites = testPaths.tests.map(test => {
        return getTestSuitePath(test.path, getRepositoryRootFromTest(test, test.context.config.rootDir))
      })

      // If the `jest` key does not exist in the known tests response, we consider the Early Flake detection faulty.
      const isFaulty = !knownTests?.jest ||
        getIsFaultyEarlyFlakeDetection(projectSuites, knownTests.jest, earlyFlakeDetectionFaultyThreshold)

      if (isFaulty) {
        log.error('Early flake detection is disabled because the number of new suites is too high.')
        isEarlyFlakeDetectionEnabled = false
        isKnownTestsEnabled = false
        const testEnvironmentOptions = testPaths.tests[0]?.context?.config?.testEnvironmentOptions
        // Project config is shared among all tests, so we can modify it here
        if (testEnvironmentOptions) {
          testEnvironmentOptions._ddIsEarlyFlakeDetectionEnabled = false
          testEnvironmentOptions._ddIsKnownTestsEnabled = false
        }
        isEarlyFlakeDetectionFaulty = true
      }
    }

    // When Jest sharding is enabled, filter after Jest picks this process's shard. Different shards usually run in
    // different CI jobs, so their skippable requests can happen at different times and receive different responses.
    // Filtering before Jest shards would make each job shard a different base test list, which can cause duplicate
    // suite execution across shards.
    if (shard?.shardCount > 1 || !isSuitesSkippingEnabled || !skippableSuites.length) {
      return testPaths
    }
    const { tests } = testPaths

    const suitesToRun = applySuiteSkipping(tests, rootDir, frameworkVersion)
    return { ...testPaths, tests: suitesToRun }
  })

  return searchSourcePackage
}

function getCliWrapper (isNewJestVersion) {
  return function cliWrapper (cli, jestVersion) {
    warnDeprecatedJestVersion(jestVersion)
    isJestCoverageBackfillSupported = !!jestVersion &&
      satisfies(jestVersion, MINIMUM_JEST_COVERAGE_BACKFILL_VERSION)

    if (isNewJestVersion) {
      cli = shimmer.wrap(
        cli,
        'SearchSource',
        searchSource => searchSourceWrapper(searchSource, jestVersion),
        { replaceGetter: true }
      )
    }
    return shimmer.wrap(cli, 'runCLI', runCLI => async function () {
      if (!libraryConfigurationCh.hasSubscribers) {
        return runCLI.apply(this, arguments)
      }

      resetSuiteSkippingRunState()
      hasFinishedTestSession = false

      let shouldResetLibraryConfiguration = true
      try {
        const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh, {
          frameworkVersion: jestVersion,
        })
        if (!err) {
          shouldResetLibraryConfiguration = false
          isCodeCoverageEnabled = libraryConfig.isCodeCoverageEnabled
          isCoverageReportUploadEnabled = libraryConfig.isCoverageReportUploadEnabled
          isItrEnabled = libraryConfig.isItrEnabled
          isSuitesSkippingEnabled = isItrEnabled && libraryConfig.isSuitesSkippingEnabled
          isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
          earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
          isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
          isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
          testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
          isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
        }
      } catch (err) {
        log.error('Jest library configuration error', err)
      } finally {
        if (shouldResetLibraryConfiguration) {
          resetLibraryConfiguration()
        }
      }

      const {
        knownTestsResponse,
        testManagementTestsResponse,
        skippableSuitesResponse,
      } = await getTestOptimizationRequestResults({
        isKnownTestsEnabled,
        isTestManagementTestsEnabled,
        isSuitesSkippingEnabled,
        getKnownTests: () => getChannelPromise(knownTestsCh),
        getTestManagementTests: () => getChannelPromise(testManagementTestsCh),
        getSkippableSuites: () => getChannelPromise(skippableSuitesCh),
      })

      if (isKnownTestsEnabled) {
        try {
          const { err, knownTests: receivedKnownTests } = knownTestsResponse || await getChannelPromise(knownTestsCh)
          if (err) {
            // We disable EFD if there has been an error in the known tests request
            isEarlyFlakeDetectionEnabled = false
            isKnownTestsEnabled = false
          } else {
            knownTests = receivedKnownTests
          }
        } catch (err) {
          log.error('Jest known tests error', err)
        }
      }

      if (isSuitesSkippingEnabled) {
        try {
          const {
            err,
            skippableSuites: receivedSkippableSuites,
            skippableSuitesCoverage: receivedSkippableSuitesCoverage,
          } = skippableSuitesResponse || await getChannelPromise(skippableSuitesCh)
          if (err) {
            skippableSuitesCoverage = undefined
          } else {
            skippableSuites = receivedSkippableSuites
            skippableSuitesCoverage = receivedSkippableSuitesCoverage
          }
          skippedSuitesCoverage = {}
        } catch (err) {
          log.error('Jest test-suite skippable error', err)
        }
      }

      if (isTestManagementTestsEnabled) {
        try {
          const { err, testManagementTests: receivedTestManagementTests } =
            testManagementTestsResponse || await getChannelPromise(testManagementTestsCh)
          if (err) {
            isTestManagementTestsEnabled = false
            testManagementTests = {}
          } else {
            testManagementTests = receivedTestManagementTests || {}
          }
        } catch (err) {
          log.error('Jest test management tests error', err)
          isTestManagementTestsEnabled = false
        }
      }

      if (isImpactedTestsEnabled) {
        try {
          const { err, modifiedFiles: receivedModifiedFiles } = await getChannelPromise(modifiedFilesCh)
          if (!err) {
            modifiedFiles = receivedModifiedFiles
          }
        } catch (err) {
          log.error('Jest impacted tests error', err)
        }
      }

      const processArgv = process.argv.slice(2).join(' ')
      testSessionStartCh.publish({
        command: `jest ${processArgv}`,
        frameworkVersion: jestVersion,
      })

      let result
      try {
        result = await runCLI.apply(this, arguments)
      } catch (error) {
        try {
          await waitForTestSessionFinish(getTestSessionFinishPayload('fail', error, {
            isTestSessionFinalizationError: true,
          }))
        } catch (finalizationError) {
          log.error('Jest test session finalization error: %s', finalizationError)
        }
        throw error
      }

      const {
        results: {
          numFailedTestSuites,
          numFailedTests,
          numRuntimeErrorTestSuites = 0,
          numTotalTests,
          numTotalTestSuites,
          runExecError,
          wasInterrupted,
        },
      } = result

      const hasSuiteLevelFailures = numRuntimeErrorTestSuites > 0
      const hasRunLevelFailure = runExecError != null || wasInterrupted === true
      const mustNotFlipSuccess = hasSuiteLevelFailures || hasRunLevelFailure

      /**
       * If Early Flake Detection (EFD) is enabled the logic is as follows:
       * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
       * - If just a single attempt passes, we will prevent the test process from failing.
       * The rationale behind is the following: you may still be able to block your CI pipeline by gating
       * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
       */
      let numEfdFailedTestsToIgnore = 0
      const efdIgnoredNames = []
      const quarantineIgnoredNames = []

      // Build fullName -> suite map from results (for EFD display)
      const fullNameToSuite = new Map()
      for (const { testResults, testFilePath } of result.results.testResults) {
        const suite = getTestSuitePath(testFilePath, result.globalConfig.rootDir)
        for (const { fullName } of testResults) {
          const name = removeSeedSuffixFromTestName(fullName)
          fullNameToSuite.set(name, suite)
        }
      }

      /**
       * @type {{
       *   efdNames: string[],
       *   quarantineNames: string[],
       *   totalCount: number,
       *   efdFailureCount: number
       * } | undefined}
       */
      let ignoredFailuresSummary
      if (isEarlyFlakeDetectionEnabled) {
        for (const [testName, testStatuses] of efdTestStatuses) {
          const { pass, fail } = getTestStats(testStatuses)
          if (pass > 0) { // as long as one passes, we'll consider the test passed
            numEfdFailedTestsToIgnore += fail
            if (fail > 0) {
              const suite = fullNameToSuite.get(testName)
              efdIgnoredNames.push(suite ? `${suite} › ${testName}` : testName)
            }
          }
        }
        // If every test that failed was an EFD retry, we'll consider the suite passed
        if (
          !mustNotFlipSuccess &&
          numEfdFailedTestsToIgnore !== 0 &&
          result.results.numFailedTests === numEfdFailedTestsToIgnore
        ) {
          result.results.success = true
          ignoredFailuresSummary = {
            efdNames: efdIgnoredNames,
            quarantineNames: [],
            totalCount: numEfdFailedTestsToIgnore,
            efdFailureCount: numEfdFailedTestsToIgnore,
          }
        }
      }

      let numFailedQuarantinedTests = 0
      let numSuppressedQuarantinedTests = 0
      if (isTestManagementTestsEnabled) {
        const failedTests = result
          .results
          .testResults.flatMap(({ testResults, testFilePath: testSuiteAbsolutePath }) => (
            testResults.map(({ fullName: testName, status }) => (
              {
                // Strip seed suffix so the name matches what was reported via TEST_NAME.
                testName: removeSeedSuffixFromTestName(testName),
                testSuiteAbsolutePath,
                status,
              }
            ))
          ))
          .filter(({ status }) => status === 'failed')

        for (const { testName, testSuiteAbsolutePath } of failedTests) {
          const testSuite = getTestSuitePath(testSuiteAbsolutePath, result.globalConfig.rootDir)
          const testManagementTest = testManagementTests
            ?.jest
            ?.suites
            ?.[testSuite]
            ?.tests
            ?.[testName]
            ?.properties
          if (testManagementTest?.quarantined && !testManagementTest?.attempt_to_fix) {
            numFailedQuarantinedTests++
            quarantineIgnoredNames.push(`${testSuite} › ${testName}`)
          }
        }

        // Include quarantined tests whose errors were suppressed at test_done time.
        // These tests don't appear as failed in Jest's results because their errors were cleared
        // to prevent --bail from stopping the run, but they should still be counted for the summary.
        for (const name of quarantinedFailingTests) {
          if (!quarantineIgnoredNames.includes(name)) {
            numSuppressedQuarantinedTests++
            quarantineIgnoredNames.push(name)
          }
        }
        quarantinedFailingTests.clear()

        // If every test that failed was quarantined, we'll consider the suite passed
        // Attempt-to-fix tests ignore quarantine/disabled suppression and keep their framework result.
        // Skip if EFD block already flipped (to avoid logging twice)
        // Only use visible failures (from Jest results) for the flip check.
        // Suppressed quarantine failures are not in numFailedTests.
        const visibleQuarantineFailures = numFailedQuarantinedTests
        if (
          !result.results.success &&
          !mustNotFlipSuccess &&
          visibleQuarantineFailures !== 0 &&
          result.results.numFailedTests === visibleQuarantineFailures
        ) {
          result.results.success = true
        }

        const totalQuarantineFailures = visibleQuarantineFailures + numSuppressedQuarantinedTests
        if (totalQuarantineFailures > 0) {
          if (ignoredFailuresSummary) {
            ignoredFailuresSummary.quarantineNames = quarantineIgnoredNames
            ignoredFailuresSummary.totalCount += totalQuarantineFailures
          } else {
            ignoredFailuresSummary = {
              efdNames: [],
              quarantineNames: quarantineIgnoredNames,
              totalCount: totalQuarantineFailures,
              efdFailureCount: 0,
            }
          }
        }
      }

      // Combined check: if all failed tests are accounted for by EFD (flaky retries) and/or quarantine,
      // we should consider the suite passed even when neither check alone covers all failures.
      // Only visible failures (in Jest results) are compared — suppressed quarantine failures
      // are already removed from numFailedTests at test_done time.
      if (
        !result.results.success &&
        !mustNotFlipSuccess &&
        (isEarlyFlakeDetectionEnabled || isTestManagementTestsEnabled)
      ) {
        const visibleIgnoredFailures =
          numEfdFailedTestsToIgnore + numFailedQuarantinedTests
        if (
          visibleIgnoredFailures !== 0 &&
          result.results.numFailedTests === visibleIgnoredFailures
        ) {
          result.results.success = true
          ignoredFailuresSummary = {
            efdNames: efdIgnoredNames,
            quarantineNames: quarantineIgnoredNames,
            totalCount: visibleIgnoredFailures + numSuppressedQuarantinedTests,
            efdFailureCount: numEfdFailedTestsToIgnore,
          }
        }
      }

      // Determine session status after EFD and quarantine checks have potentially modified success
      let status, error
      if (result.results.success) {
        status = numTotalTests === 0 && numTotalTestSuites === 0 ? 'skip' : 'pass'
      } else {
        status = 'fail'
        error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
      }

      await waitForTestSessionFinish(getTestSessionFinishPayload(status, error, {
        ...getTestSessionCoveragePayload(result.results, result.globalConfig?.rootDir),
      }))

      if (codeCoverageReportCh.hasSubscribers) {
        const rootDir = result.globalConfig?.rootDir || process.cwd()
        await getChannelPromise(codeCoverageReportCh, { rootDir })
      }

      recordTestManagementExecutionsFromJestResults(result, quarantineIgnoredNames)
      const allTestsSkipped = isSuitesSkipped && numTotalTests === 0 && numTotalTestSuites === 0
      logSessionSummary(
        ignoredFailuresSummary,
        getAttemptToFixExecutionsFromJestResults(result),
        allTestsSkipped
      )

      resetSuiteSkippingRunState()

      return result
    }, {
      replaceGetter: true,
    })
  }
}

function shouldWaitForTestSuiteFinish (environment) {
  return isJestWorker && environment.globalConfig?.workerIdleMemoryLimit !== undefined
}

/**
 * @param {Record<string, unknown>} payload
 * @param {boolean} waitForFinish
 */
function publishTestSuiteFinish (payload, waitForFinish) {
  if (!testSuiteFinishCh.hasSubscribers) return

  if (!waitForFinish) {
    testSuiteFinishCh.publish(payload)
    return
  }

  return getChannelPromise(testSuiteFinishCh, {
    ...payload,
    waitForFinish,
  })
}

function cleanupTestSuiteState (testSuiteAbsolutePath) {
  testSuiteMockedFiles.delete(testSuiteAbsolutePath)
  testSuiteJestObjects.delete(testSuiteAbsolutePath)
}

/**
 * Rechecks custom handlers after Jest has finished constructing the environment.
 *
 * @param {object} environment
 * @returns {void}
 */
function wrapEnvironmentCustomHandleTestEvent (environment) {
  const datadogHandleTestEvent = environment[DD_JEST_HANDLE_TEST_EVENT_DATADOG]
  if (typeof environment.wrapCustomHandleTestEvent === 'function' && datadogHandleTestEvent) {
    environment.wrapCustomHandleTestEvent(datadogHandleTestEvent)
  }
}

addHook({
  name: '@jest/core',
  file: 'build/TestScheduler.js',
  versions: [MINIMUM_JEST_TEST_SCHEDULER_VERSION],
}, (testSchedulerPackage, frameworkVersion) => {
  const oldCreateTestScheduler = testSchedulerPackage.createTestScheduler
  const newCreateTestScheduler = async function () {
    if (!isSuitesSkippingEnabled || hasFilteredSkippableSuites) {
      return oldCreateTestScheduler.apply(this, arguments)
    }
    // If suite skipping is enabled and has not filtered skippable suites yet, we'll attempt to do it
    const scheduler = await oldCreateTestScheduler.apply(this, arguments)
    shimmer.wrap(scheduler, 'scheduleTests', scheduleTests => getWrappedScheduleTests(scheduleTests, frameworkVersion))
    return scheduler
  }
  testSchedulerPackage.createTestScheduler = newCreateTestScheduler
  return testSchedulerPackage
})

if (DD_MAJOR < 6) {
  addHook({
    name: '@jest/core',
    file: 'build/TestScheduler.js',
    versions: ['>=24.8.0 <27.0.0'],
  }, (testSchedulerPackage, frameworkVersion) => {
    shimmer.wrap(
      testSchedulerPackage.default.prototype,
      'scheduleTests', scheduleTests => getWrappedScheduleTests(scheduleTests, frameworkVersion)
    )
    return testSchedulerPackage
  })
}

function testSequencerWrapper (sequencerPackage, frameworkVersion) {
  shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function (...args) {
    const shardedTests = shard.apply(this, args)

    if (!shardedTests.length || !isSuitesSkippingEnabled || !skippableSuites.length) {
      return shardedTests
    }
    const [test] = shardedTests
    const rootDir = test?.context?.config?.rootDir

    return applySuiteSkipping(shardedTests, rootDir, frameworkVersion)
  })
  return sequencerPackage
}

addHook({
  name: '@jest/test-sequencer',
  versions: ['>=28'],
}, testSequencerWrapper)

addHook({
  name: '@jest/test-sequencer',
  file: 'build/index.js',
  versions: ['>=28'],
}, testSequencerWrapper)

addHook({
  name: '@jest/core',
  file: 'build/cli/index.js',
  versions: [MINIMUM_JEST_VERSION_BEFORE_30],
}, getCliWrapper(false))

addHook({
  name: '@jest/core',
  versions: ['>=30.0.0'],
}, getCliWrapper(true))

addHook({
  name: '@jest/core',
  file: 'build/ReporterDispatcher.js',
  versions: [MINIMUM_JEST_VERSION],
}, reporterDispatcherWrapper)

if (DD_MAJOR < 6) {
  addHook({
    name: '@jest/reporters',
    file: 'build/coverage_reporter.js',
    versions: ['>=24.8.0 <26.6.2'],
  }, coverageReporterWrapper)
}

addHook({
  name: '@jest/reporters',
  versions: ['>=30.0.0'],
}, reportersWrapper)

addHook({
  name: '@jest/reporters',
  file: 'build/CoverageReporter.js',
  versions: [DD_MAJOR >= 6 ? '>=28.0.0' : '>=26.6.2'],
}, coverageReporterWrapper)

function jestAdapterWrapper (jestAdapter, jestVersion) {
  const adapter = jestAdapter.default ?? jestAdapter
  const newAdapter = shimmer.wrapFunction(adapter, adapter => function (...args) {
    const environment = args[2]
    if (!environment || !environment.testEnvironmentOptions) {
      return adapter.apply(this, args)
    }

    wrapEnvironmentCustomHandleTestEvent(environment)

    testSuiteStartCh.publish({
      testSuite: environment.testSuite,
      testEnvironmentOptions: environment.testEnvironmentOptions,
      testSourceFile: environment.testSourceFile,
      displayName: environment.displayName,
      frameworkVersion: jestVersion,
      testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
    })
    return adapter.apply(this, args).then(suiteResults => {
      const { numFailingTests, skipped, failureMessage: errorMessage } = suiteResults
      let status = 'pass'
      if (skipped) {
        status = 'skipped'
      } else if (numFailingTests !== 0) {
        status = 'fail'
      }

      /**
       * Child processes do not each request ITR configuration, so the jest's parent process
       * needs to pass them the configuration. This is done via _ddTestCodeCoverageEnabled, which
       * controls whether coverage is reported.
       */
      if (environment.testEnvironmentOptions?._ddTestCodeCoverageEnabled) {
        const root = environment.repositoryRoot || environment.rootDir

        const coverageFiles = getCoveredFilesFromCoverage(environment.global.__coverage__)
          .map(file => ({
            ...file,
            filename: getTestSuitePath(file.filename, root),
          }))
        const mockedFiles = getMockedFiles(environment.testSuiteAbsolutePath)
          .map(file => getTestSuitePath(file, root))

        testSuiteCodeCoverageCh.publish({
          coverageFiles,
          testSuite: environment.testSourceFile,
          mockedFiles,
          testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
        })
      }
      const waitForFinish = shouldWaitForTestSuiteFinish(environment)
      const finishPayload = {
        status,
        errorMessage,
        testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
      }
      if (waitForFinish) {
        const finishPromise = publishTestSuiteFinish(finishPayload, waitForFinish)
        if (finishPromise) {
          return finishPromise.then(() => {
            // Cleanup per-suite state to avoid memory leaks
            cleanupTestSuiteState(environment.testSuiteAbsolutePath)

            return suiteResults
          })
        }
      }
      publishTestSuiteFinish(finishPayload, waitForFinish)

      // Cleanup per-suite state to avoid memory leaks
      cleanupTestSuiteState(environment.testSuiteAbsolutePath)

      return suiteResults
    }).catch(error => {
      const waitForFinish = shouldWaitForTestSuiteFinish(environment)
      const finishPayload = {
        status: 'fail',
        error,
        testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
      }
      if (waitForFinish) {
        const finishPromise = publishTestSuiteFinish(finishPayload, waitForFinish)
        if (finishPromise) {
          return finishPromise.then(() => {
            // Cleanup per-suite state to avoid memory leaks
            cleanupTestSuiteState(environment.testSuiteAbsolutePath)

            throw error
          })
        }
      }
      publishTestSuiteFinish(finishPayload, waitForFinish)

      // Cleanup per-suite state to avoid memory leaks
      cleanupTestSuiteState(environment.testSuiteAbsolutePath)

      throw error
    })
  })
  if (jestAdapter.default) {
    jestAdapter.default = newAdapter
  } else {
    jestAdapter = newAdapter
  }

  return jestAdapter
}

addHook({
  name: 'jest-circus',
  file: 'build/runner.js',
  versions: ['>=30.0.0'],
}, jestAdapterWrapper)

addHook({
  name: 'jest-circus',
  file: 'build/legacy-code-todo-rewrite/jestAdapter.js',
  versions: [MINIMUM_JEST_VERSION],
}, jestAdapterWrapper)

function configureTestEnvironment (readConfigsResult) {
  repositoryRoot = getJestRepositoryRoot(readConfigsResult)
  isUserCodeCoverageEnabled = !!readConfigsResult.globalConfig.collectCoverage
  const isCodeCoverageEnabledBecauseOfUs = shouldCollectJestCoverageForTia() && !isUserCodeCoverageEnabled

  if (isCodeCoverageEnabledBecauseOfUs) {
    readConfigsResult.globalConfig = {
      ...readConfigsResult.globalConfig,
      collectCoverage: true,
      coverageReporters: ['none'],
    }
    readConfigsResult.configs = readConfigsResult.configs.map(config => ({
      ...config,
      coverageReporters: ['none'],
    }))
  }

  // We can't directly use the parent process flags when reporting suite coverage in `jestAdapterWrapper`
  // because `jestAdapterWrapper` runs in a different process. We have to go through `testEnvironmentOptions`.
  const configs = readConfigsResult.configs.map(config => {
    const testEnvironmentOptions = config.testEnvironmentOptions || {}
    testEnvironmentOptions._ddRepositoryRoot = repositoryRoot
    testEnvironmentOptions._ddTestCodeCoverageEnabled = shouldReportJestSuiteCoverageForTia()

    return {
      ...config,
      testEnvironmentOptions,
    }
  })
  readConfigsResult.configs = configs
  testSessionConfigurationCh.publish(readConfigsResult.configs.map(config => config.testEnvironmentOptions))
  repositoryRoot = getJestRepositoryRoot(readConfigsResult)

  if (readConfigsResult.globalConfig.forceExit) {
    log.warn("Jest's '--forceExit' flag has been passed. This may cause loss of data.")
  }

  readConfigsResult.globalConfig = addDatadogBailReporter(readConfigsResult.globalConfig)

  if (isSuitesSkippingEnabled) {
    // If suite skipping is enabled, we pass `passWithNoTests` in case every test gets skipped.
    const globalConfig = {
      ...readConfigsResult.globalConfig,
      passWithNoTests: true,
    }
    readConfigsResult.globalConfig = globalConfig
  }

  return readConfigsResult
}

function jestConfigAsyncWrapper (jestConfig) {
  return shimmer.wrap(jestConfig, 'readConfigs', readConfigs => async function () {
    const readConfigsResult = await readConfigs.apply(this, arguments)
    configureTestEnvironment(readConfigsResult)
    return readConfigsResult
  })
}

function jestConfigSyncWrapper (jestConfig) {
  return shimmer.wrap(jestConfig, 'readConfigs', readConfigs => function (...args) {
    const readConfigsResult = readConfigs.apply(this, args)
    configureTestEnvironment(readConfigsResult)
    return readConfigsResult
  })
}

const DD_TEST_ENVIRONMENT_OPTION_KEYS = [
  '_ddTestModuleId',
  '_ddTestSessionId',
  '_ddTestCommand',
  '_ddTestSessionName',
  '_ddForcedToRun',
  '_ddUnskippable',
  '_ddItrCorrelationId',
  '_ddKnownTests',
  '_ddIsEarlyFlakeDetectionEnabled',
  '_ddEarlyFlakeDetectionRetryPolicy',
  '_ddRepositoryRoot',
  '_ddTestCodeCoverageEnabled',
  '_ddIsFlakyTestRetriesEnabled',
  '_ddFlakyTestRetriesCount',
  '_ddItrSkippingEnabledTags',
  '_ddIsDiEnabled',
  '_ddIsKnownTestsEnabled',
  '_ddIsTestManagementTestsEnabled',
  '_ddTestManagementTests',
  '_ddTestManagementAttemptToFixRetries',
  '_ddModifiedFiles',
]

function removeDatadogTestEnvironmentOptions (testEnvironmentOptions) {
  const removedEntries = []

  for (const key of DD_TEST_ENVIRONMENT_OPTION_KEYS) {
    if (!Object.hasOwn(testEnvironmentOptions, key)) {
      continue
    }

    removedEntries.push([key, testEnvironmentOptions[key]])
    delete testEnvironmentOptions[key]
  }

  return function restoreDatadogTestEnvironmentOptions () {
    for (const [key, value] of removedEntries) {
      testEnvironmentOptions[key] = value
    }
  }
}

/**
 * Wrap `createScriptTransformer` to temporarily hide Datadog-specific
 * `testEnvironmentOptions` keys while Jest builds its transform config.
 *
 * @param {Function} createScriptTransformer
 * @returns {Function}
 */
function wrapCreateScriptTransformer (createScriptTransformer) {
  return function (config) {
    const testEnvironmentOptions = config?.testEnvironmentOptions

    if (!testEnvironmentOptions) {
      return createScriptTransformer.apply(this, arguments)
    }

    const restoreTestEnvironmentOptions = removeDatadogTestEnvironmentOptions(testEnvironmentOptions)

    try {
      const result = createScriptTransformer.apply(this, arguments)

      if (result?.then) {
        return result.finally(restoreTestEnvironmentOptions)
      }

      restoreTestEnvironmentOptions()
      return result
    } catch (e) {
      restoreTestEnvironmentOptions()
      throw e
    }
  }
}

addHook({
  name: '@jest/transform',
  versions: [MINIMUM_JEST_VERSION_BEFORE_30],
  file: 'build/ScriptTransformer.js',
}, transformPackage => {
  transformPackage.createScriptTransformer = wrapCreateScriptTransformer(transformPackage.createScriptTransformer)

  return transformPackage
})

addHook({
  name: '@jest/transform',
  versions: ['>=30.0.0'],
}, transformPackage => {
  return shimmer.wrap(transformPackage, 'createScriptTransformer', wrapCreateScriptTransformer, { replaceGetter: true })
})

/**
 * Hook to remove the test paths (test suite) that are part of `skippableSuites`
 */
addHook({
  name: '@jest/core',
  versions: [MINIMUM_JEST_VERSION_BEFORE_30],
  file: 'build/SearchSource.js',
}, searchSourceWrapper)

addHook({
  name: 'jest-each',
  versions: [MINIMUM_JEST_VERSION],
}, jestEach => {
  cacheJestEachBind(jestEach)
  return jestEach
})

// from 25.1.0 on, readConfigs becomes async
addHook({
  name: 'jest-config',
  versions: [MINIMUM_JEST_CONFIG_ASYNC_VERSION],
}, jestConfigAsyncWrapper)

if (DD_MAJOR < 6) {
  addHook({
    name: 'jest-config',
    versions: ['24.8.0 - 24.9.0'],
  }, jestConfigSyncWrapper)
}

const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
  'selenium-webdriver',
  'selenium-webdriver/chrome',
  'selenium-webdriver/edge',
  'selenium-webdriver/safari',
  'selenium-webdriver/firefox',
  'selenium-webdriver/ie',
  'selenium-webdriver/chromium',
  'winston',
])

function recordMockedFile (suiteFilePath, moduleName) {
  if (!suiteFilePath || typeof moduleName !== 'string') return

  const existingMockedFiles = testSuiteMockedFiles.get(suiteFilePath) || []
  const suiteDir = path.dirname(suiteFilePath)
  const mockPath = path.resolve(suiteDir, moduleName)
  existingMockedFiles.push(mockPath)
  testSuiteMockedFiles.set(suiteFilePath, existingMockedFiles)
}

const JEST_STATIC_MOCK_CALL_RE = /\bjest\.(?:mock|doMock|unstable_mockModule)\(\s*(['"`])([^'"`]+)\1/g

function getStaticMockedFiles (suiteFilePath) {
  if (!suiteFilePath) return []

  const mockedFiles = []
  try {
    const source = readFileSync(suiteFilePath, 'utf8')
    let match
    JEST_STATIC_MOCK_CALL_RE.lastIndex = 0
    while ((match = JEST_STATIC_MOCK_CALL_RE.exec(source)) !== null) {
      mockedFiles.push(path.resolve(path.dirname(suiteFilePath), match[2]))
    }
  } catch {
    // ignore errors
  }

  return mockedFiles
}

function getMockedFiles (suiteFilePath) {
  const mockedFiles = testSuiteMockedFiles.get(suiteFilePath)
  const staticMockedFiles = getStaticMockedFiles(suiteFilePath)

  if (mockedFiles?.length) {
    return [...new Set([...mockedFiles, ...staticMockedFiles])]
  }
  return staticMockedFiles
}

function wrapJestObject (jestObject, suiteFilePath) {
  if (!jestObject || !suiteFilePath || wrappedJestObjects.has(jestObject)) return

  testSuiteJestObjects.set(suiteFilePath, jestObject)
  wrappedJestObjects.add(jestObject)

  shimmer.wrap(jestObject, 'mock', mock => function (moduleName) {
    // If the library is mocked with `jest.mock`, we don't want to bypass jest's own require engine
    LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.delete(moduleName)
    recordMockedFile(suiteFilePath, moduleName)
    return mock.apply(this, arguments)
  })
}

function wrapJestGlobalsForRuntime (runtime) {
  const jestGlobals = runtime?.jestGlobals
  if (!jestGlobals || wrappedJestGlobals.has(jestGlobals) || typeof jestGlobals.jestObjectFor !== 'function') {
    return
  }

  wrappedJestGlobals.add(jestGlobals)
  shimmer.wrap(jestGlobals, 'jestObjectFor', jestObjectFor => function (from) {
    const jestObject = jestObjectFor.apply(this, arguments)
    wrapJestObject(jestObject, from)
    return jestObject
  })
}

function wrapConcurrentJestGlobalsForRuntime (runtime, jestGlobals) {
  const environment = testSuiteDatadogEnvironments.get(runtime?._testPath)
  environment?.wrapConcurrentTestGlobals(jestGlobals?.test, environment.concurrentTestState)
}

function cacheJestEachBind (jestEach) {
  if (typeof jestEach?.bind === 'function') {
    jestEachBind = jestEach.bind
  }
}

function getLastLoggedReferenceError (runtime) {
  const loggedReferenceErrors = runtime?.loggedReferenceErrors
  if (!loggedReferenceErrors?.size) return
  return [...loggedReferenceErrors].pop()
}

function publishRuntimeReferenceError (runtime, errorMessage) {
  if (!errorMessage || !runtime?._testPath) return

  let publishedErrors = publishedRuntimeReferenceErrors.get(runtime)
  if (!publishedErrors) {
    publishedErrors = new Set()
    publishedRuntimeReferenceErrors.set(runtime, publishedErrors)
  }
  if (publishedErrors.has(errorMessage)) return

  publishedErrors.add(errorMessage)
  testSuiteErrorCh.publish({
    errorMessage,
    testSuiteAbsolutePath: runtime._testPath,
  })
}

function isBetweenTestsReferenceError (error) {
  return error?.name === 'ReferenceError' &&
    typeof error.message === 'string' &&
    error.message.includes('outside of the scope of the test code')
}

function reportBetweenTestsReferenceError (runtime, moduleName, originalErrorMessage) {
  if (typeof moduleName !== 'string') return false

  const fallbackErrorMessage = moduleName.startsWith('node:') || builtinModules.includes(moduleName)
    ? 'You are trying to access a Node.js module outside of the scope of the test code.'
    : 'You are trying to `require` a file after the Jest environment has been torn down.'
  const errorMessage = originalErrorMessage || fallbackErrorMessage

  if (typeof runtime._logFormattedReferenceError === 'function') {
    runtime._logFormattedReferenceError(errorMessage)
  }
  publishRuntimeReferenceError(runtime, getLastLoggedReferenceError(runtime) || errorMessage)
  process.exitCode = 1
  return true
}

function requireOutsideJestRequireEngine (runtime, moduleName) {
  if (typeof runtime._requireCoreModule === 'function') {
    return runtime._requireCoreModule(moduleName)
  }
  return require(moduleName)
}

function formatDefaultStackTrace (error, structuredStackTrace) {
  const errorString = Error.prototype.toString.call(error)
  if (structuredStackTrace.length === 0) return errorString

  return `${errorString}\n    at ${structuredStackTrace.join('\n    at ')}`
}

addHook({
  name: 'jest-runtime',
  versions: [MINIMUM_JEST_VERSION],
}, (runtimePackage) => {
  const Runtime = runtimePackage.default ?? runtimePackage

  if (typeof Runtime.prototype._createJestObjectFor === 'function') {
    shimmer.wrap(Runtime.prototype, '_createJestObjectFor', _createJestObjectFor => function (from) {
      const result = _createJestObjectFor.apply(this, arguments)
      const suiteFilePath = this._testPath || from

      wrapJestObject(result, suiteFilePath)
      return result
    })
  }

  shimmer.wrap(Runtime.prototype, 'requireModule', requireModule => function (from, moduleName) {
    wrapJestGlobalsForRuntime(this)
    try {
      const returnedValue = requireModule.apply(this, arguments)
      if (moduleName === '@jest/globals') {
        wrapConcurrentJestGlobalsForRuntime(this, returnedValue)
      }
      return returnedValue
    } catch (error) {
      if (isBetweenTestsReferenceError(error)) {
        reportBetweenTestsReferenceError(this, moduleName, error.message)
      }
      throw error
    }
  })

  shimmer.wrap(Runtime.prototype, 'requireModuleOrMock', requireModuleOrMock => function (from, moduleName) {
    wrapJestGlobalsForRuntime(this)
    // `requireModuleOrMock` may log errors to the console. If we don't remove ourselves
    // from the stack trace, the user might see a useless stack trace rather than the error
    // that `jest` tries to show.
    const originalPrepareStackTrace = Error.prepareStackTrace
    Error.prepareStackTrace = function (error, structuredStackTrace) {
      const filteredStackTrace = structuredStackTrace
        .filter(callSite => !callSite.getFileName()?.includes('datadog-instrumentations/src/jest.js'))

      if (typeof originalPrepareStackTrace === 'function') {
        return originalPrepareStackTrace(error, filteredStackTrace)
      }
      return formatDefaultStackTrace(error, filteredStackTrace)
    }
    try {
      // TODO: do this for every library that we instrument
      if (LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {
        // To bypass jest's own require engine
        return requireOutsideJestRequireEngine(this, moduleName)
      }
      let returnedValue
      try {
        returnedValue = requireModuleOrMock.apply(this, arguments)
        if (moduleName === '@jest/globals') {
          wrapConcurrentJestGlobalsForRuntime(this, returnedValue)
        }
      } catch (error) {
        if (isBetweenTestsReferenceError(error)) {
          reportBetweenTestsReferenceError(this, moduleName, error.message)
        }
        throw error
      }
      if (process.exitCode === 1) {
        publishRuntimeReferenceError(
          this,
          getLastLoggedReferenceError(this) || 'An error occurred while importing a module'
        )
      }
      return returnedValue
    } finally {
      // Restore original prepareStackTrace
      Error.prepareStackTrace = originalPrepareStackTrace
    }
  })

  if (Runtime.prototype._logFormattedReferenceError) {
    shimmer.wrap(Runtime.prototype, '_logFormattedReferenceError', logFormattedReferenceError => function () {
      // eslint-disable-next-line no-console
      const originalConsoleError = console.error
      let loggedReferenceError
      // eslint-disable-next-line no-console
      console.error = function () {
        loggedReferenceError = arguments[0]
        return originalConsoleError.apply(this, arguments)
      }
      try {
        const result = logFormattedReferenceError.apply(this, arguments)
        publishRuntimeReferenceError(this, getLastLoggedReferenceError(this) || loggedReferenceError)
        return result
      } finally {
        // eslint-disable-next-line no-console
        console.error = originalConsoleError
      }
    })
  }

  return runtimePackage
})

function onMessageWrapper (onMessage) {
  return function (...args) {
    const response = args[0]
    if (!Array.isArray(response)) {
      return onMessage.apply(this, args)
    }

    const [code, data] = response
    if (code === JEST_WORKER_TRACE_PAYLOAD_CODE) { // datadog trace payload
      collectDynamicNamesFromTraces(data, newTestsWithDynamicNames)
      workerReportTraceCh.publish(data)
      return
    }
    if (code === JEST_WORKER_COVERAGE_PAYLOAD_CODE) { // datadog coverage payload
      workerReportCoverageCh.publish(data)
      return
    }
    if (code === JEST_WORKER_LOGS_PAYLOAD_CODE) { // datadog logs payload
      workerReportLogsCh.publish(data)
      return
    }
    if (code === JEST_WORKER_TELEMETRY_PAYLOAD_CODE) { // datadog telemetry payload
      workerReportTelemetryCh.publish(data)
      return
    }
    if (code === JEST_WORKER_QUARANTINE_PAYLOAD_CODE) { // quarantined test failures suppressed in worker
      for (const name of JSON.parse(data)) {
        quarantinedFailingTests.add(name)
      }
      return
    }
    return onMessage.apply(this, args)
  }
}

function sendWrapper (send) {
  return function (request) {
    if (!isKnownTestsEnabled && !isTestManagementTestsEnabled && !isImpactedTestsEnabled) {
      return send.apply(this, arguments)
    }
    const [type] = request

    // https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/workers/ChildProcessWorker.ts#L424
    if (type === CHILD_MESSAGE_CALL) {
      // This is the message that the main process sends to the worker to run a test suite (=test file).
      // In here we modify the `config.testEnvironmentOptions` to include the known tests for the suite.
      // This way the suite only knows about the tests that are part of it.
      const args = request.at(-1)
      if (args.length > 1) {
        return send.apply(this, arguments)
      }
      if (!args[0]?.config) {
        return send.apply(this, arguments)
      }
      const [{ globalConfig, config, path: testSuiteAbsolutePath }] = args
      const testSuite = getTestSuitePath(testSuiteAbsolutePath, globalConfig.rootDir || process.cwd())
      const suiteKnownTests = knownTests?.jest?.[testSuite] || []

      const suiteTestManagementTests = testManagementTests?.jest?.suites?.[testSuite]?.tests || {}

      args[0].config = {
        ...config,
        testEnvironmentOptions: {
          ...config.testEnvironmentOptions,
          _ddKnownTests: suiteKnownTests,
          _ddTestManagementTests: suiteTestManagementTests,
          // TODO: figure out if we can reduce the size of the modified files object
          // Can we use `testSuite` (it'd have to be relative to repository root though)
          _ddModifiedFiles: modifiedFiles,
        },
      }
    }
    return send.apply(this, arguments)
  }
}

function wrapWorkerChannel (worker) {
  const workerChannel = worker._child || worker._worker
  if (!workerChannel) return

  shimmer.wrap(workerChannel, worker._child ? 'send' : 'postMessage', sendWrapper)
}

function wrapWorkerInitializer (worker) {
  if (wrappedWorkerInitializers.has(worker) || typeof worker.initialize !== 'function') return

  wrappedWorkerInitializers.add(worker)
  shimmer.wrap(worker, 'initialize', initialize => function () {
    const result = initialize.apply(this, arguments)
    wrapWorkerChannel(this)
    return result
  })
}

function wrapWorker (worker) {
  // ChildProcessWorker uses _child (child_process), ExperimentalWorker uses _worker (worker_threads)
  const workerChannel = worker._child || worker._worker
  if (!workerChannel) return

  wrapWorkerInitializer(worker)
  wrapWorkerChannel(worker)
  shimmer.wrap(worker, '_onMessage', onMessageWrapper)
  workerChannel.removeAllListeners('message')
  workerChannel.on('message', worker._onMessage.bind(worker))
}

function enqueueWrapper (enqueue) {
  return function (...args) {
    shimmer.wrap(args[0], 'onStart', onStart => function (worker) {
      if (worker) {
        const currentChannel = worker._child || worker._worker
        const previousChannel = wrappedWorkerChannels.get(worker)
        if (currentChannel !== previousChannel) {
          if (previousChannel) {
            // Worker restarted — only re-wrap the new child's send/postMessage
            wrapWorkerChannel(worker)
          } else {
            // First time seeing this worker — full setup
            wrapWorker(worker)
          }
          wrappedWorkerChannels.set(worker, currentChannel)
        }
      }
      return onStart.apply(this, arguments)
    })
    return enqueue.apply(this, args)
  }
}

/*
* This hook does three things:
* - Pass known tests to the workers.
* - Pass test management tests to the workers.
* - Receive trace, coverage and logs payloads from the workers.
*/
addHook({
  name: 'jest-worker',
  versions: [MINIMUM_JEST_WORKER_VERSION_BEFORE_30],
  file: 'build/workers/ChildProcessWorker.js',
}, (childProcessWorker) => {
  const ChildProcessWorker = childProcessWorker.default
  shimmer.wrap(ChildProcessWorker.prototype, 'send', sendWrapper)
  if (ChildProcessWorker.prototype._onMessage) {
    shimmer.wrap(ChildProcessWorker.prototype, '_onMessage', onMessageWrapper)
  } else if (ChildProcessWorker.prototype.onMessage) {
    shimmer.wrap(ChildProcessWorker.prototype, 'onMessage', onMessageWrapper)
  }
  return childProcessWorker
})

addHook({
  name: 'jest-worker',
  versions: [MINIMUM_JEST_WORKER_VERSION_BEFORE_30],
  file: 'build/workers/NodeThreadsWorker.js',
}, (nodeThreadsWorker) => {
  const ExperimentalWorker = nodeThreadsWorker.default
  shimmer.wrap(ExperimentalWorker.prototype, 'send', sendWrapper)
  if (ExperimentalWorker.prototype._onMessage) {
    shimmer.wrap(ExperimentalWorker.prototype, '_onMessage', onMessageWrapper)
  } else if (ExperimentalWorker.prototype.onMessage) {
    shimmer.wrap(ExperimentalWorker.prototype, 'onMessage', onMessageWrapper)
  }
  return nodeThreadsWorker
})

addHook({
  name: 'jest-worker',
  versions: ['>=30.0.0'],
}, (jestWorkerPackage) => {
  shimmer.wrap(jestWorkerPackage.FifoQueue.prototype, 'enqueue', enqueueWrapper)
  shimmer.wrap(jestWorkerPackage.PriorityQueue.prototype, 'enqueue', enqueueWrapper)
  return jestWorkerPackage
})