dd-trace 6.13.0 → 6.14.0

package/packages/datadog-instrumentations/src/playwright.js

@@ -70,6 +70,7 @@ const createRootSuiteCh = tracingChannel('orchestrion:playwright:createRootSuite
 const artifactsRecorderScreenshotPathCh =
   tracingChannel('orchestrion:playwright:ArtifactsRecorder_createScreenshotAttachmentPath')
 const snapshotRecorderScreenshotPathCh = tracingChannel('orchestrion:playwright:SnapshotRecorder_createAttachmentPath')
+const saveAutomaticVideoCh = tracingChannel('orchestrion:playwright:saveAutomaticVideo')
 const pageGotoCh = tracingChannel('orchestrion:playwright-core:Page_goto')
 
 const testToCtx = new WeakMap()
@@ -83,6 +84,8 @@ const RUM_FLUSH_WAIT_TIME = getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WA
 const DD_PROPERTIES_TIMEOUT = 5000
 const isFailureScreenshotUploadEnabled =
   getValueFromEnvSources('DD_TEST_FAILURE_SCREENSHOTS_ENABLED') === true
+const isFailureVideoUploadEnabled =
+  getValueFromEnvSources('DD_TEST_FAILURE_VIDEOS_ENABLED') === true
 
 let applyRepeatEachIndex = null
 let reporterError
@@ -91,7 +94,7 @@ let hasReporterError = false
 let startedSuites = []
 
 // Browser-side callbacks live in a coverage-excluded file so coverage counters can't reach chromium.
-const { detectRum, stopRumSession } = require('./playwright-browser-scripts')
+const { detectRum, stopRumSession } = require('./rum-browser-scripts')
 
 const STATUS_TO_TEST_STATUS = {
   passed: 'pass',
@@ -134,18 +137,22 @@ let rootDir = ''
 let sessionProjects = []
 
 const MINIMUM_SUPPORTED_VERSION_RANGE_EFD = '>=1.38.0' // TODO: remove this once we drop support for v5
+const MINIMUM_FAILURE_VIDEO_UPLOAD_VERSION_RANGE = '>=1.38.0'
 const EFD_RETRY_COUNT_REQUEST = 'ddEfdRetryCountRequest'
 const EFD_RETRY_COUNT_RESPONSE = 'ddEfdRetryCountResponse'
 const DD_PROPERTIES_REQUEST = 'ddPropertiesRequest'
 const DD_PROPERTIES_RESPONSE = 'ddProperties'
 const kDdPlaywrightDisabledTestIds = Symbol('ddPlaywrightDisabledTestIds')
 const kDdPlaywrightFailureScreenshots = Symbol('ddPlaywrightFailureScreenshots')
+const kDdPlaywrightFailureVideos = Symbol('ddPlaywrightFailureVideos')
 const kDdPlaywrightReporterConfigured = Symbol('ddPlaywrightReporterConfigured')
 const kDdPlaywrightWorkerHostInstrumented = Symbol('ddPlaywrightWorkerHostInstrumented')
 const kDdPlaywrightWorkerInstrumented = Symbol('ddPlaywrightWorkerInstrumented')
 const instrumentedPlaywrightReporters = new WeakSet()
 const PLAYWRIGHT_FAILURE_SCREENSHOT_PATH_RE = /(?:^|[\\/])test-failed-\d+\.png$/
+const PLAYWRIGHT_FAILURE_VIDEO_PATH_RE = /(?:^|[\\/])video(?:-\d+)?\.webm$/
 const automaticFailureScreenshotPaths = new Set()
+const automaticFailureVideoPaths = new Set()
 
 /**
  * Returns whether Playwright's internal screenshot recorder created an attachment.
@@ -157,6 +164,16 @@ function isAutomaticFailureScreenshotAttachment (attachment) {
   return typeof attachment?.path === 'string' && automaticFailureScreenshotPaths.delete(attachment.path)
 }
 
+/**
+ * Returns whether Playwright's internal video recorder created an attachment.
+ *
+ * @param {object} attachment - Playwright attachment payload
+ * @returns {boolean}
+ */
+function isAutomaticFailureVideoAttachment (attachment) {
+  return typeof attachment?.path === 'string' && automaticFailureVideoPaths.delete(attachment.path)
+}
+
 function isValidKnownTests (receivedKnownTests) {
   return !!receivedKnownTests.playwright
 }
@@ -553,6 +570,21 @@ function isFailureScreenshotCaptureEnabled (projects) {
   return false
 }
 
+/**
+ * Returns whether at least one Playwright project records videos that can be retained for failures.
+ *
+ * @param {Array<object>} projects - Playwright projects with resolved use options
+ * @returns {boolean} Whether video capture is enabled
+ */
+function isFailureVideoCaptureEnabled (projects) {
+  for (const project of projects) {
+    const video = project.use?.video
+    const mode = typeof video === 'object' && video !== null ? video.mode : video
+    if (mode === 'on' || mode === 'retain-on-failure') return true
+  }
+  return false
+}
+
 function getProjectsFromDispatcher (dispatcher) {
   const bundledConfig = dispatcher._testRun?.config?.config?.projects
   if (bundledConfig) {
@@ -614,7 +646,15 @@ function getTestSuiteError (testSuiteAbsolutePath) {
   if (errors.length === 1) {
     return errors[0]
   }
-  return new Error(`${errors.length} errors in this test suite:\n${errors.map(e => e.message).join('\n------\n')}`)
+  let errorMessages = ''
+  let isFirstError = true
+  for (const error of errors) {
+    if (!isFirstError) errorMessages += '\n------\n'
+    errorMessages += error.message || error.value || ''
+    isFirstError = false
+  }
+
+  return new Error(`${errors.length} errors in this test suite:\n${errorMessages}`)
 }
 
 function getTestByTestId (dispatcher, testId) {
@@ -1087,6 +1127,7 @@ function onDispatcherCreateWorker (dispatcher, worker) {
   const projects = getProjectsFromDispatcher(dispatcher)
   sessionProjects = projects
   const automaticFailureScreenshotsByTestId = new Map()
+  const failureVideosByTestId = new Map()
 
   if (disabledTestIds.size && !worker[kDdPlaywrightWorkerHostInstrumented] &&
       typeof worker.runTestGroup === 'function') {
@@ -1112,20 +1153,28 @@ function onDispatcherCreateWorker (dispatcher, worker) {
     if (!test) return
 
     automaticFailureScreenshotsByTestId.clear()
+    failureVideosByTestId.clear()
     const browser = getBrowserNameFromProjects(projects, test)
     const shouldCreateTestSpan = test.expectedStatus === 'skipped'
     testBeginHandler(test, browser, shouldCreateTestSpan)
   })
   worker.on('attach', (attachment) => {
-    const { testId, _ddIsAutomaticFailureScreenshot } = attachment
-    if (!_ddIsAutomaticFailureScreenshot) return
-
-    let screenshots = automaticFailureScreenshotsByTestId.get(testId)
-    if (!screenshots) {
-      screenshots = []
-      automaticFailureScreenshotsByTestId.set(testId, screenshots)
+    const { testId, _ddIsAutomaticFailureScreenshot, _ddIsAutomaticFailureVideo } = attachment
+    if (_ddIsAutomaticFailureScreenshot) {
+      let screenshots = automaticFailureScreenshotsByTestId.get(testId)
+      if (!screenshots) {
+        screenshots = []
+        automaticFailureScreenshotsByTestId.set(testId, screenshots)
+      }
+      screenshots.push(attachment)
+    } else if (isFailureVideoUploadEnabled && _ddIsAutomaticFailureVideo) {
+      let videos = failureVideosByTestId.get(testId)
+      if (!videos) {
+        videos = []
+        failureVideosByTestId.set(testId, videos)
+      }
+      videos.push(attachment)
     }
-    screenshots.push(attachment)
   })
   worker.on('testEnd', ({ testId, status, errors, annotations }) => {
     const test = getTestByTestId(dispatcher, testId)
@@ -1164,6 +1213,14 @@ function onDispatcherCreateWorker (dispatcher, worker) {
       worker[kDdPlaywrightFailureScreenshots] ??= []
       worker[kDdPlaywrightFailureScreenshots].push(screenshots)
     }
+    if (isFailureVideoUploadEnabled &&
+        !shouldCreateTestSpan &&
+        !test._ddShouldSkipEfdRetry &&
+        !disabledTestIds.has(testId)) {
+      const videos = testStatus === 'fail' ? failureVideosByTestId.get(testId) : undefined
+      worker[kDdPlaywrightFailureVideos] ??= []
+      worker[kDdPlaywrightFailureVideos].push(videos)
+    }
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
       !test._ddIsAttemptToFix &&
@@ -1278,6 +1335,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     rootDir = getRootDir(this, config)
     const projects = getProjectsFromRunner(this, config)
     const isFailureScreenshotEnabled = isFailureScreenshotCaptureEnabled(projects)
+    const isFailureVideoEnabled = isFailureVideoCaptureEnabled(projects)
+    const isFailureVideoUploadSupported = satisfies(playwrightVersion, MINIMUM_FAILURE_VIDEO_UPLOAD_VERSION_RANGE)
     const processArgv = process.argv.slice(2).join(' ')
     const command = `playwright ${processArgv}`
     testSessionStartCh.publish({
@@ -1285,6 +1344,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       frameworkVersion: playwrightVersion,
       rootDir,
       isFailureScreenshotEnabled,
+      isFailureVideoEnabled,
+      isFailureVideoUploadSupported,
     })
 
     try {
@@ -1311,7 +1372,11 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       log.error('Playwright session start error', e)
     }
 
-    testSessionConfigurationCh.publish({ isFailureScreenshotEnabled })
+    testSessionConfigurationCh.publish({
+      isFailureScreenshotEnabled,
+      isFailureVideoEnabled,
+      isFailureVideoUploadSupported,
+    })
 
     const isTestOptimizationSupported = satisfies(playwrightVersion, MINIMUM_SUPPORTED_VERSION_RANGE_EFD)
     const shouldGetKnownTests = isKnownTestsEnabled && isTestOptimizationSupported
@@ -1697,8 +1762,33 @@ function recordAutomaticFailureScreenshotPath (ctx) {
   }
 }
 
+/**
+ * Records only the destination used by Playwright's automatic video recorder.
+ *
+ * @param {object} ctx - Orchestrion context
+ * @returns {void}
+ */
+function recordAutomaticFailureVideoPath (ctx) {
+  const video = ctx.arguments?.[0]
+  if (!isFailureVideoUploadEnabled || typeof video?.saveAs !== 'function') return
+
+  const saveAs = video.saveAs
+  ctx.arguments[0] = new Proxy(video, {
+    get (target, property, receiver) {
+      if (property !== 'saveAs') return Reflect.get(target, property, receiver)
+      return function (filePath) {
+        if (typeof filePath === 'string' && PLAYWRIGHT_FAILURE_VIDEO_PATH_RE.test(filePath)) {
+          automaticFailureVideoPaths.add(filePath)
+        }
+        return Reflect.apply(saveAs, target, arguments)
+      }
+    },
+  })
+}
+
 artifactsRecorderScreenshotPathCh.subscribe({ end: recordAutomaticFailureScreenshotPath })
 snapshotRecorderScreenshotPathCh.subscribe({ end: recordAutomaticFailureScreenshotPath })
+saveAutomaticVideoCh.subscribe({ start: recordAutomaticFailureVideoPath })
 
 if (DD_MAJOR < 6) { // <1.38.0 is only supported up to version 5
   addHook({
@@ -2061,6 +2151,7 @@ function finishProcessHostStartRunner (processHost) {
       workerReportCh.publish({
         serializedTraces: message[1],
         screenshots: processHost[kDdPlaywrightFailureScreenshots]?.shift(),
+        videos: processHost[kDdPlaywrightFailureVideos]?.shift(),
       })
     } else if (Array.isArray(message) && message[0] === PLAYWRIGHT_WORKER_TELEMETRY_PAYLOAD_CODE) {
       workerReportTelemetryCh.publish(message[1])
@@ -2409,6 +2500,7 @@ function instrumentWorkerMainMethods (workerMain) {
   shimmer.wrap(workerMain, 'dispatchEvent', dispatchEvent => function (event, payload) {
     if (event === 'testBegin') {
       automaticFailureScreenshotPaths.clear()
+      automaticFailureVideoPaths.clear()
     } else if (event === 'stepBegin') {
       stepInfoByStepId[payload.stepId] = {
         startTime: payload.wallTime,
@@ -2425,8 +2517,12 @@ function instrumentWorkerMainMethods (workerMain) {
         duration: payload.wallTime - stepInfo.startTime,
         error: payload.error,
       })
-    } else if (event === 'attach' && isAutomaticFailureScreenshotAttachment(payload)) {
-      payload._ddIsAutomaticFailureScreenshot = true
+    } else if (event === 'attach') {
+      if (isAutomaticFailureScreenshotAttachment(payload)) {
+        payload._ddIsAutomaticFailureScreenshot = true
+      } else if (isAutomaticFailureVideoAttachment(payload)) {
+        payload._ddIsAutomaticFailureVideo = true
+      }
     }
     return dispatchEvent.apply(this, arguments)
   })

package/packages/datadog-instrumentations/src/rum-browser-scripts.js

@@ -0,0 +1,40 @@
+'use strict'
+
+// Serialized into browsers by browser-test integrations. Excluded from coverage by filename.
+
+/** @returns {{ isRumInstrumented: boolean, isRumActive: boolean, rumSamplingRate: number | null }} */
+function detectRum () {
+  const isRumInstrumented = !!window.DD_RUM
+  const isRumActive = window.DD_RUM && window.DD_RUM.getInternalContext
+    ? !!window.DD_RUM.getInternalContext()
+    : false
+  const rumInitConfiguration = window.DD_RUM && window.DD_RUM.getInitConfiguration
+    ? window.DD_RUM.getInitConfiguration()
+    : undefined
+  const rumSamplingRate = rumInitConfiguration ? rumInitConfiguration.sessionSampleRate : null
+
+  return { isRumInstrumented, isRumActive, rumSamplingRate }
+}
+
+/** @returns {boolean} */
+function stopRumSession () {
+  if (window.DD_RUM && window.DD_RUM.stopSession) {
+    window.DD_RUM.stopSession()
+    return true
+  }
+  return false
+}
+
+/** @returns {boolean} */
+function stopRumSessionAndReportActivity () {
+  if (window.DD_RUM && window.DD_RUM.stopSession) {
+    const isRumActive = window.DD_RUM.getInternalContext
+      ? !!window.DD_RUM.getInternalContext()
+      : false
+    window.DD_RUM.stopSession()
+    return isRumActive
+  }
+  return false
+}
+
+module.exports = { detectRum, stopRumSession, stopRumSessionAndReportActivity }

package/packages/datadog-instrumentations/src/sequelize.js

@@ -5,15 +5,45 @@ const {
   channel,
   addHook,
 } = require('./helpers/instrument')
+const {
+  wrapPoolRelease,
+  wrapPromisePoolAcquire,
+  wrapPromisePoolQueryMethod,
+} = require('./helpers/pool-acquire')
+
+addHook({
+  name: 'sequelize',
+  versions: ['>=4'],
+  file: 'lib/dialects/abstract/connection-manager.js',
+}, ConnectionManager => {
+  shimmer.wrap(ConnectionManager.prototype, 'getConnection', getConnection => wrapPromisePoolAcquire(
+    getConnection,
+    resolveSequelizeDriver,
+    resolveSequelizeConfig,
+    sequelizeHasIdleConnection
+  ))
+  shimmer.wrap(ConnectionManager.prototype, 'releaseConnection', wrapPoolRelease)
+  if (typeof ConnectionManager.prototype.destroyConnection === 'function') {
+    shimmer.wrap(ConnectionManager.prototype, 'destroyConnection', wrapPoolRelease)
+  }
+
+  return ConnectionManager
+})
 
 addHook({ name: 'sequelize', versions: ['>=4'], file: 'lib/sequelize.js' }, Sequelize => {
   const startCh = channel('datadog:sequelize:query:start')
   const finishCh = channel('datadog:sequelize:query:finish')
 
   shimmer.wrap(Sequelize.prototype, 'query', query => {
+    const queryWithPool = wrapPromisePoolQueryMethod(
+      query,
+      (sequelize, args) => args[1]?.transaction ? undefined : sequelize.connectionManager,
+      sequelize => resolveSequelizeDriver(sequelize.connectionManager)
+    )
+
     return function (sql, options) {
       if (!startCh.hasSubscribers) {
-        return query.apply(this, arguments)
+        return queryWithPool.apply(this, arguments)
       }
 
       let dialect
@@ -33,7 +63,7 @@ addHook({ name: 'sequelize', versions: ['>=4'], file: 'lib/sequelize.js' }, Sequ
       }
 
       return startCh.runStores({ sql, dialect }, () => {
-        const promise = query.apply(this, arguments)
+        const promise = queryWithPool.apply(this, arguments)
         promise.then(onFinish, () => { onFinish() })
 
         return promise
@@ -43,3 +73,65 @@ addHook({ name: 'sequelize', versions: ['>=4'], file: 'lib/sequelize.js' }, Sequ
 
   return Sequelize
 })
+
+addHook({ name: 'sequelize', versions: ['>=4'], file: 'lib/transaction.js' }, Transaction => {
+  shimmer.wrap(Transaction.prototype, 'prepareEnvironment', prepareEnvironment => wrapPromisePoolQueryMethod(
+    prepareEnvironment,
+    transaction => transaction.parent ? undefined : transaction.sequelize.connectionManager,
+    transaction => resolveSequelizeDriver(transaction.sequelize.connectionManager)
+  ))
+
+  return Transaction
+})
+
+/**
+ * @typedef {{
+ *   available: number,
+ *   pending?: number,
+ *   waiting?: number,
+ * }} SequelizePool
+ */
+
+/**
+ * @param {{ pool: SequelizePool & { read?: SequelizePool, write?: SequelizePool } }} manager
+ * @param {[{ type?: string, useMaster?: boolean }?]} args
+ * @returns {boolean}
+ */
+function sequelizeHasIdleConnection (manager, args) {
+  const pool = manager.pool
+  const options = args[0]
+  const selected = pool?.read === undefined
+    ? pool
+    : options?.type === 'SELECT' && !options?.useMaster ? pool.read : pool.write
+  const waiting = selected.waiting ?? selected.pending
+  return selected.available > waiting
+}
+
+/**
+ * @param {{ dialectName?: string }|undefined} manager
+ * @returns {'mariadb'|'mysql2'|'pg'|undefined}
+ */
+function resolveSequelizeDriver (manager) {
+  switch (manager?.dialectName) {
+    case 'mariadb':
+      return 'mariadb'
+    case 'mysql':
+      return 'mysql2'
+    case 'postgres':
+      return 'pg'
+  }
+}
+
+/**
+ * @param {{ config: Record<string, unknown> & { username?: string } }} manager
+ * @returns {Record<string, unknown>}
+ */
+function resolveSequelizeConfig (manager) {
+  const config = manager.config
+  return {
+    database: config.database,
+    host: config.host,
+    port: config.port,
+    user: config.username,
+  }
+}

package/packages/datadog-instrumentations/src/undici.js

@@ -1,20 +1,25 @@
 'use strict'
 
-const tracingChannel = require('dc-polyfill').tracingChannel
+const { channel, tracingChannel } = require('dc-polyfill')
 
 const shimmer = require('../../datadog-shimmer')
 const satisfies = require('../../../vendor/dist/semifies')
-const {
-  addHook,
-} = require('./helpers/instrument')
+const { addHook } = require('./helpers/instrument')
 const { createWrapFetch } = require('./helpers/fetch')
 
 const ch = tracingChannel('apm:undici:fetch')
+const upgradeCh = channel('apm:undici:request:upgrade')
 
 // Undici 5.0.x has a bug where fetch doesn't preserve AggregateError in the error cause chain
 // Use native DC only for versions where error handling works correctly
 const NATIVE_DC_VERSION = '>=4.7.0 <5.0.0 || >=5.1.0'
 
+addHook({
+  name: 'undici',
+  versions: ['>=4.4.1 <8.0.0', '>=8.0.0'],
+  file: 'lib/core/request.js',
+}, wrapRequestUpgrade)
+
 addHook({
   name: 'undici',
   versions: ['^4.4.1', '5', '>=6.0.0'],
@@ -27,3 +32,47 @@ addHook({
   // For older versions or those with buggy error handling, wrap fetch
   return shimmer.wrap(undici, 'fetch', createWrapFetch(undici.Request, ch))
 })
+
+/**
+ * @param {Function & { prototype: Record<string, Function> }} Request
+ * @returns {Function}
+ */
+function wrapRequestUpgrade (Request) {
+  const requestSource = Function.prototype.toString.call(Request)
+  const methodName = typeof Request.prototype.onRequestUpgrade === 'function'
+    ? 'onRequestUpgrade'
+    : 'onUpgrade'
+  const method = Request.prototype[methodName]
+
+  // Orchestrion cannot leave fixed source byte-for-byte untouched after a conditional AST match.
+  if (typeof method !== 'function' ||
+      !requestSource.includes('channels.trailers.publish') ||
+      Function.prototype.toString.call(method).includes('channels.trailers.publish')) {
+    return Request
+  }
+
+  shimmer.wrap(Request.prototype, methodName, createWrapUpgrade)
+  return Request
+}
+
+/**
+ * @param {Function} upgrade
+ * @returns {Function}
+ */
+function createWrapUpgrade (upgrade) {
+  return function (statusCode, headers, socket) {
+    if (!upgradeCh.hasSubscribers) return upgrade.apply(this, arguments)
+
+    let result
+    try {
+      result = upgrade.apply(this, arguments)
+    } catch (error) {
+      upgradeCh.publish({ error, headers, request: this, statusCode })
+      throw error
+    }
+    if (!this.aborted) {
+      upgradeCh.publish({ headers, request: this, statusCode })
+    }
+    return result
+  }
+}

package/packages/datadog-instrumentations/src/vitest-main-no-worker-init.js

@@ -56,6 +56,22 @@ const VITEST_NO_WORKER_INIT_SETUP_FILE = path.join(
   'ci',
   'vitest-no-worker-init-setup.mjs'
 )
+const VITEST_NO_WORKER_INIT_RUNNER_SETUP_FILE = path.join(
+  __dirname,
+  '..',
+  '..',
+  '..',
+  'ci',
+  'vitest-no-worker-init-runner-setup.mjs'
+)
+const VITEST_NO_WORKER_INIT_V5_SETUP_FILE = path.join(
+  __dirname,
+  '..',
+  '..',
+  '..',
+  'ci',
+  'vitest-no-worker-init-v5-setup.mjs'
+)
 const VITEST_BROWSER_SETUP_FILE_PLUGIN = {
   name: 'datadog:vitest-browser-setup-file',
   config: configureVitestBrowserSetupFile,
@@ -325,7 +341,10 @@ function isEarlyFlakeDetectionActive (state) {
 function configure (ctx, frameworkVersion, testSpecifications, setupData, options) {
   const { shouldReportTestModule, state } = options
   reserveEarlyFlakeDetectionSuite = options.reserveEarlyFlakeDetectionSuite
-  addSetupFileToVitestConfigs(ctx, VITEST_NO_WORKER_INIT_SETUP_FILE, testSpecifications)
+  const setupFile = satisfies(frameworkVersion, '>=5.0.0')
+    ? VITEST_NO_WORKER_INIT_V5_SETUP_FILE
+    : VITEST_NO_WORKER_INIT_RUNNER_SETUP_FILE
+  addSetupFileToVitestConfigs(ctx, setupFile, testSpecifications)
   addVitestBrowserSetupFileAccess(testSpecifications)
 
   const {
@@ -470,8 +489,15 @@ function allowVitestBrowserSetupFile (viteConfig) {
   const allow = viteConfig.server?.fs?.allow
   if (!allow) return
 
-  if (!allow.includes(VITEST_NO_WORKER_INIT_SETUP_FILE)) {
-    allow.push(VITEST_NO_WORKER_INIT_SETUP_FILE)
+  const setupFiles = [
+    VITEST_NO_WORKER_INIT_SETUP_FILE,
+    VITEST_NO_WORKER_INIT_RUNNER_SETUP_FILE,
+    VITEST_NO_WORKER_INIT_V5_SETUP_FILE,
+  ]
+  for (const setupFile of setupFiles) {
+    if (!allow.includes(setupFile)) {
+      allow.push(setupFile)
+    }
   }
 }
 
@@ -493,6 +519,7 @@ function addVitestBrowserSetupFileAccess (testSpecifications) {
     if (!browserServerProject) continue
 
     addVitestBrowserCommand(safeConfig(project))
+    addVitestBrowserRuntimeCommand(project)
     if (configuredProjects.has(browserServerProject)) continue
 
     configuredProjects.add(browserServerProject)
@@ -507,6 +534,13 @@ function addVitestBrowserSetupFileAccess (testSpecifications) {
   }
 }
 
+function addVitestBrowserRuntimeCommand (project) {
+  const parentBrowser = project?._parentBrowser || project?._parent?._parentBrowser
+  if (parentBrowser?.commands) {
+    parentBrowser.commands[VITEST_BROWSER_EFD_SUITE_ADMISSION_COMMAND] = handleBrowserEfdSuiteAdmission
+  }
+}
+
 /**
  * Adds the private EFD admission command to a Vitest Browser Mode configuration.
  *