codeceptjs 4.1.0 → 4.2.0-beta.2

package/lib/helper/clientscripts/xpathPolyfill.js

@@ -0,0 +1,31 @@
+import { readFileSync } from 'fs'
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
+let cached
+
+export default function xpathPolyfillSource() {
+  if (cached) return cached
+  const engine = readFileSync(require.resolve('xpath/xpath.js'), 'utf8')
+  cached = `(function(){
+  if (window.__codeceptXPathPolyfill) return
+  window.__codeceptXPathPolyfill = true
+  var module = { exports: {} }
+  var exports = module.exports
+  ${engine}
+  var parse = module.exports.parse
+  document.evaluate = function(expr, ctx, resolver, type, res) {
+    var nodes = parse(expr).select({ node: ctx || document, isHtml: true })
+    var i = 0
+    return {
+      resultType: type,
+      snapshotLength: nodes.length,
+      snapshotItem: function(idx) { return idx < nodes.length ? nodes[idx] : null },
+      iterateNext: function() { return i < nodes.length ? nodes[i++] : null },
+      singleNodeValue: nodes.length ? nodes[0] : null,
+      booleanValue: nodes.length > 0,
+    }
+  }
+})()`
+  return cached
+}

package/lib/helper/errors/MultipleElementsFound.js

@@ -1,5 +1,60 @@
 import Locator from '../../locator.js'
 
+export function splitXPath(xpath) {
+  if (typeof xpath !== 'string' || xpath.length === 0) return []
+  const withoutRoot = xpath.startsWith('//') ? xpath.slice(1) : xpath
+  return withoutRoot.split('/').filter(Boolean)
+}
+
+export function isAncestorXPath(ancestor, descendant) {
+  if (!ancestor || !descendant || ancestor === descendant) return false
+  const ancestorSegments = splitXPath(ancestor)
+  const descendantSegments = splitXPath(descendant)
+  if (ancestorSegments.length === 0 || ancestorSegments.length >= descendantSegments.length) return false
+  return ancestorSegments.every((segment, index) => segment === descendantSegments[index])
+}
+
+export function computeParents(entries) {
+  const parents = new Array(entries.length).fill(-1)
+  const stack = []
+  for (let i = 0; i < entries.length; i++) {
+    const xpath = entries[i].xpath
+    if (!xpath) continue
+    while (stack.length > 0 && !isAncestorXPath(entries[stack[stack.length - 1]].xpath, xpath)) {
+      stack.pop()
+    }
+    parents[i] = stack.length > 0 ? stack[stack.length - 1] : -1
+    stack.push(i)
+  }
+  return parents
+}
+
+export function computeDepths(entries) {
+  const parents = computeParents(entries)
+  return parents.map((parent, i) => {
+    if (!entries[i].xpath) return 0
+    let depth = 0
+    let current = parent
+    while (current !== -1) {
+      depth++
+      current = parents[current]
+    }
+    return depth
+  })
+}
+
+export function formatTree(entries, depths, parents) {
+  return entries.map((entry, i) => {
+    const pad = '  '.repeat(depths[i] || 0)
+    if (entry.error) {
+      return `${pad}  ${entry.index}. [Unable to get element info: ${entry.error}]`
+    }
+    const parentPos = parents ? parents[i] : -1
+    const nesting = parentPos !== undefined && parentPos !== -1 ? ` (inside ${entries[parentPos].index}.)` : ''
+    return `${pad}  ${entry.index}.${nesting} > ${entry.xpath}\n${pad}     ${entry.html}`
+  })
+}
+
 class MultipleElementsFound extends Error {
   constructor(locator, webElements) {
     const locatorStr = (typeof locator === 'object' && !(locator instanceof Locator))
@@ -17,7 +72,7 @@ class MultipleElementsFound extends Error {
     if (this._detailsFetched) return
 
     try {
-      const items = []
+      const entries = []
       const maxToShow = Math.min(this.count, 10)
 
       for (let i = 0; i < maxToShow; i++) {
@@ -25,12 +80,14 @@ class MultipleElementsFound extends Error {
         try {
           const xpath = await webEl.toAbsoluteXPath()
           const html = await webEl.toSimplifiedHTML()
-          items.push(`  ${i + 1}. > ${xpath}\n     ${html}`)
+          entries.push({ index: i + 1, xpath, html })
         } catch (err) {
-          items.push(`  ${i + 1}. [Unable to get element info: ${err.message}]`)
+          entries.push({ index: i + 1, error: err.message })
         }
       }
 
+      const items = formatTree(entries, computeDepths(entries), computeParents(entries))
+
       if (this.count > 10) {
         items.push(`  ... and ${this.count - 10} more`)
       }

package/lib/helper/extras/CDPConnection.js

@@ -0,0 +1,92 @@
+import { WebSocket } from 'ws'
+
+class CDPConnection {
+  constructor(endpoint, options = {}) {
+    this.endpoint = endpoint
+    this.headers = options.headers || {}
+    this.timeout = options.timeout || 10000
+    this.ws = null
+    this.lastId = 0
+    this.pending = new Map()
+    this.listeners = new Map()
+  }
+
+  async connect() {
+    await new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.endpoint, { headers: this.headers })
+      this.ws.once('open', resolve)
+      this.ws.once('error', reject)
+    })
+    this.ws.on('message', raw => {
+      try {
+        this._onMessage(JSON.parse(raw.toString()))
+      } catch (err) {
+      }
+    })
+    this.ws.on('close', () => {
+      for (const { reject, timer } of this.pending.values()) {
+        clearTimeout(timer)
+        reject(new Error('CDP connection closed'))
+      }
+      this.pending.clear()
+    })
+    return this
+  }
+
+  get isConnected() {
+    return !!this.ws && this.ws.readyState === WebSocket.OPEN
+  }
+
+  send(method, params = {}, sessionId = undefined) {
+    if (!this.isConnected) {
+      return Promise.reject(new Error(`CDP connection is not open (sending ${method})`))
+    }
+    const id = ++this.lastId
+    const message = { id, method, params }
+    if (sessionId) message.sessionId = sessionId
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id)
+        reject(new Error(`CDP command ${method} timed out after ${this.timeout}ms`))
+      }, this.timeout)
+      this.pending.set(id, { resolve, reject, timer })
+      this.ws.send(JSON.stringify(message))
+    })
+  }
+
+  on(method, fn) {
+    if (!this.listeners.has(method)) this.listeners.set(method, [])
+    this.listeners.get(method).push(fn)
+  }
+
+  _onMessage(msg) {
+    if (msg.id && this.pending.has(msg.id)) {
+      const { resolve, reject, timer } = this.pending.get(msg.id)
+      clearTimeout(timer)
+      this.pending.delete(msg.id)
+      if (msg.error) reject(new Error(msg.error.message))
+      else resolve(msg.result)
+      return
+    }
+    if (msg.method && this.listeners.has(msg.method)) {
+      for (const fn of this.listeners.get(msg.method)) {
+        try {
+          fn(msg.params, msg.sessionId)
+        } catch (err) {
+        }
+      }
+    }
+  }
+
+  async close() {
+    if (!this.ws) return
+    await new Promise(resolve => {
+      if (this.ws.readyState === WebSocket.CLOSED) return resolve()
+      this.ws.once('close', resolve)
+      this.ws.close()
+    })
+    this.ws = null
+  }
+}
+
+export default CDPConnection

package/lib/helper/extras/CDPElementHandle.js

@@ -0,0 +1,27 @@
+/**
+ * Lightweight element handle for `CDPBrowser`. Unlike Puppeteer/WebDriver, `CDPBrowser` never
+ * keeps a persistent handle to a DOM node on the Node side — every action re-resolves candidates
+ * in-page via `_run`/`_runSelected`. This class stores the candidates and the 1-based index of one
+ * specific element within that candidate set, and re-resolves it on demand. It exists to give
+ * `grabWebElement(s)` and `MultipleElementsFound.fetchDetails()` something to call
+ * `toAbsoluteXPath()`/`toOuterHTML()` on, wrapped by `lib/element/WebElement.js`.
+ */
+class CDPElementHandle {
+  constructor(helper, candidates, index) {
+    this.helper = helper
+    this.candidates = candidates
+    this.index = index
+  }
+
+  async outerHTML() {
+    const res = await this.helper._runSelected(this.candidates, 'outerHTML', null, { index: this.index })
+    return res.result
+  }
+
+  async absoluteXPath() {
+    const res = await this.helper._runSelected(this.candidates, 'absoluteXPath', null, { index: this.index })
+    return res.result
+  }
+}
+
+export default CDPElementHandle

package/lib/helper/extras/PlaywrightLocator.js

@@ -1,10 +1,10 @@
-async function findByPlaywrightLocator(matcher, locator) {
+function findByPlaywrightLocator(matcher, locator) {
   const pwLocator = locator.locator || locator
   if (pwLocator && pwLocator.toString && pwLocator.toString().includes(process.env.testIdAttribute)) {
     return matcher.getByTestId(pwLocator.pw.value.split('=')[1])
   }
   const pwValue = typeof pwLocator.pw === 'string' ? pwLocator.pw : pwLocator.pw
-  return matcher.locator(pwValue).all()
+  return matcher.locator(pwValue)
 }
 
 export { findByPlaywrightLocator }

package/lib/helper/extras/apngAssembler.js

@@ -0,0 +1,156 @@
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256)
+  for (let n = 0; n < 256; n++) {
+    let c = n
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1
+    }
+    table[n] = c >>> 0
+  }
+  return table
+})()
+
+function crc32(buf) {
+  let c = 0xffffffff
+  for (let i = 0; i < buf.length; i++) {
+    c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8)
+  }
+  return (c ^ 0xffffffff) >>> 0
+}
+
+/**
+ * True if `buf` starts with the 8-byte PNG signature.
+ *
+ * @param {object} buf a Buffer.
+ * @returns {boolean}
+ */
+function isPng(buf) {
+  return buf.length >= 8 && buf.subarray(0, 8).equals(PNG_SIGNATURE)
+}
+
+function readChunks(buf) {
+  if (!isPng(buf)) throw new Error('not a PNG file (bad signature)')
+  const chunks = []
+  let offset = 8
+  while (offset + 8 <= buf.length) {
+    const length = buf.readUInt32BE(offset)
+    const type = buf.toString('ascii', offset + 4, offset + 8)
+    const dataStart = offset + 8
+    const dataEnd = dataStart + length
+    if (dataEnd + 4 > buf.length) break
+    const data = buf.subarray(dataStart, dataEnd)
+    chunks.push({ type, data })
+    offset = dataEnd + 4
+    if (type === 'IEND') break
+  }
+  return chunks
+}
+
+function makeChunk(type, data) {
+  const length = Buffer.alloc(4)
+  length.writeUInt32BE(data.length, 0)
+  const typeBuf = Buffer.from(type, 'ascii')
+  const crc = Buffer.alloc(4)
+  crc.writeUInt32BE(crc32(Buffer.concat([typeBuf, data])), 0)
+  return Buffer.concat([length, typeBuf, data, crc])
+}
+
+function delayToFraction(delayMs) {
+  let num = Math.max(1, Math.round(delayMs))
+  let den = 1000
+  while (num > 65535) {
+    num = Math.round(num / 2)
+    den = Math.round(den / 2) || 1
+  }
+  return { num, den }
+}
+
+/**
+ * Muxes a sequence of complete, same-dimension PNG frames into a single APNG (Animated PNG) file.
+ * This is byte-level PNG chunk container work only — no pixel encoding or decoding. The first
+ * frame's `IHDR` and any other ancillary chunks (e.g. `gAMA`, `pHYs`) are carried over verbatim;
+ * each frame's `IDAT` chunk(s) are concatenated and re-emitted as the animation's `IDAT` (frame 0)
+ * or `fdAT` (subsequent frames) with a shared, monotonically increasing sequence number across all
+ * `fcTL`/`fdAT` chunks, per the APNG spec.
+ *
+ * @param {Array<{buffer: object, delayMs: number}>} frames complete single-image PNG buffers with the
+ * delay (in milliseconds) to hold that frame before advancing to the next one; the last frame's own
+ * `delayMs` is ignored in favor of `options.lastFrameDelayMs`.
+ * @param {object} [options] {onDropFrame: function, numPlays: number, lastFrameDelayMs: number} — options.onDropFrame(info) is called for any frame whose
+ * dimensions don't match the first frame, which is then excluded from the output (APNG requires a
+ * single fixed size per this implementation — no scaling). options.numPlays is the animation loop
+ * count (0 = infinite, the default). options.lastFrameDelayMs is the hold time for the final frame
+ * (default 1000ms).
+ * @returns {object} a Buffer containing the assembled APNG file.
+ */
+function assembleApng(frames, options = {}) {
+  if (!frames || !frames.length) throw new Error('assembleApng: at least one frame is required')
+
+  const parsed = frames.map(f => ({ chunks: readChunks(f.buffer), delayMs: f.delayMs }))
+  const ihdr = parsed[0].chunks.find(c => c.type === 'IHDR')
+  if (!ihdr) throw new Error('assembleApng: first frame has no IHDR chunk')
+  const width = ihdr.data.readUInt32BE(0)
+  const height = ihdr.data.readUInt32BE(4)
+
+  const usable = []
+  for (const pf of parsed) {
+    const frameIhdr = pf.chunks.find(c => c.type === 'IHDR')
+    const w = frameIhdr && frameIhdr.data.readUInt32BE(0)
+    const h = frameIhdr && frameIhdr.data.readUInt32BE(4)
+    if (w !== width || h !== height) {
+      if (typeof options.onDropFrame === 'function') {
+        options.onDropFrame({ width: w, height: h, expectedWidth: width, expectedHeight: height })
+      }
+      continue
+    }
+    usable.push(pf)
+  }
+  if (!usable.length) throw new Error('assembleApng: no frames with dimensions matching the first frame')
+
+  const out = [PNG_SIGNATURE, makeChunk('IHDR', ihdr.data)]
+
+  const actl = Buffer.alloc(8)
+  actl.writeUInt32BE(usable.length, 0)
+  actl.writeUInt32BE(options.numPlays || 0, 4)
+  out.push(makeChunk('acTL', actl))
+
+  for (const c of parsed[0].chunks) {
+    if (c.type === 'IHDR' || c.type === 'IDAT' || c.type === 'IEND') continue
+    out.push(makeChunk(c.type, c.data))
+  }
+
+  let seq = 0
+  usable.forEach((pf, i) => {
+    const imageData = Buffer.concat(pf.chunks.filter(c => c.type === 'IDAT').map(c => c.data))
+    const delayMs = i === usable.length - 1 ? (options.lastFrameDelayMs ?? 1000) : pf.delayMs
+    const { num, den } = delayToFraction(delayMs)
+
+    const fctl = Buffer.alloc(26)
+    fctl.writeUInt32BE(seq++, 0)
+    fctl.writeUInt32BE(width, 4)
+    fctl.writeUInt32BE(height, 8)
+    fctl.writeUInt32BE(0, 12)
+    fctl.writeUInt32BE(0, 16)
+    fctl.writeUInt16BE(num, 20)
+    fctl.writeUInt16BE(den, 22)
+    fctl.writeUInt8(0, 24)
+    fctl.writeUInt8(0, 25)
+    out.push(makeChunk('fcTL', fctl))
+
+    if (i === 0) {
+      out.push(makeChunk('IDAT', imageData))
+    } else {
+      const fdat = Buffer.alloc(4 + imageData.length)
+      fdat.writeUInt32BE(seq++, 0)
+      imageData.copy(fdat, 4)
+      out.push(makeChunk('fdAT', fdat))
+    }
+  })
+
+  out.push(makeChunk('IEND', Buffer.alloc(0)))
+  return Buffer.concat(out)
+}
+
+export { assembleApng, isPng, readChunks, crc32, PNG_SIGNATURE }

package/lib/html.js

@@ -78,11 +78,12 @@ const defaultHtmlOpts = {
   textElements: ['label', 'h1', 'h2'],
   allowedAttrs: ['id', 'for', 'class', 'name', 'type', 'value', 'tabindex', 'aria-labelledby', 'aria-label', 'label', 'placeholder', 'title', 'alt', 'src', 'role'],
   allowedRoles: ['button', 'checkbox', 'search', 'textbox', 'tab'],
+  keepText: false,
 }
 
 function removeNonInteractiveElements(html, opts = {}) {
   opts = { ...defaultHtmlOpts, ...opts }
-  const { interactiveElements, textElements, allowedAttrs, allowedRoles } = opts
+  const { interactiveElements, textElements, allowedAttrs, allowedRoles, keepText } = opts
 
   // Parse the HTML into a document tree
   const document = parse(html)
@@ -111,8 +112,14 @@ function removeNonInteractiveElements(html, opts = {}) {
     return false
   }
 
+  function hasVisibleText(node) {
+    if (node.nodeName === '#text') return !!node.value.trim()
+    return (node.childNodes || []).some(hasVisibleText)
+  }
+
   function hasMeaningfulText(node) {
     if (textElements.includes(node.nodeName)) return true
+    if (keepText && hasVisibleText(node)) return true
     return false
   }
 
@@ -294,7 +301,7 @@ function splitByChunks(text, chunkSize) {
 
 function simplifyHtmlElement(html, maxLength = 300) {
   try {
-    html = removeNonInteractiveElements(html)
+    html = removeNonInteractiveElements(html, { keepText: true })
     html = html.replace(/<html>(?:<head>.*?<\/head>)?<body>(.*)<\/body><\/html>/s, '$1').trim()
   } catch (e) {
     // keep raw html if minification fails

package/lib/listener/retryEnhancer.js

@@ -44,7 +44,8 @@ function copyCodeceptJSProperties(originalTest, retriedTest) {
   }
 
   if (originalTest.artifacts !== undefined) {
-    retriedTest.artifacts = originalTest.artifacts ? [...originalTest.artifacts] : []
+    const artifacts = originalTest.artifacts
+    retriedTest.artifacts = artifacts ? (Array.isArray(artifacts) ? Object.assign([], artifacts) : { ...artifacts }) : []
   }
 
   if (originalTest.steps !== undefined) {

package/lib/listener/steps.js

@@ -16,6 +16,14 @@ const EXCLUDED_SESSIONS = ['tryTo', 'hopeThat']
  * Register steps inside tests
  */
 export default function () {
+  // Mocha's Suite has no start timestamp of its own, and junitReporter reads
+  // `suite.startedAt` for each `<testsuite timestamp>`. Without this the
+  // reporter falls back to `new Date()` at write time, stamping every suite
+  // with the moment the XML was serialized. (#5668)
+  event.dispatcher.on(event.suite.before, suite => {
+    suite.startedAt = +new Date()
+  })
+
   event.dispatcher.on(event.test.before, test => {
     test.startedAt = +new Date()
   })

package/lib/locator.js

@@ -649,6 +649,9 @@ Locator.field = {
     ]),
 }
 
+const checkable = `self::input[@type = 'checkbox' or @type = 'radio'] or @role = 'checkbox' or @role = 'radio' or @role = 'switch'`
+const visibleCheckable = `.//*[${checkable}][not(@aria-hidden = 'true')]`
+
 Locator.checkable = {
   /**
    * @param {string} literal
@@ -656,8 +659,10 @@ Locator.checkable = {
    */
   byText: literal =>
     xpathLocator.combine([
-      `.//input[@type = 'checkbox' or @type = 'radio'][(@id = //label[@for][contains(normalize-space(string(.)), ${literal})]/@for) or @placeholder = ${literal}]`,
-      `.//label[contains(normalize-space(string(.)), ${literal})]//input[@type = 'radio' or @type = 'checkbox']`,
+      `${visibleCheckable}[(@id = //label[@for][contains(normalize-space(string(.)), ${literal})]/@for) or @placeholder = ${literal}]`,
+      `.//label[contains(normalize-space(string(.)), ${literal})]//*[${checkable}][not(@aria-hidden = 'true')]`,
+      `${visibleCheckable}[@aria-labelledby = //*[@id][contains(normalize-space(string(.)), ${literal})]/@id]`,
+      `${visibleCheckable}[@aria-label = ${literal}]`,
     ]),
 
   /**

package/lib/mocha/asyncWrapper.js

@@ -4,7 +4,7 @@ import recorder from '../recorder.js'
 import assertThrown from '../assert/throws.js'
 import { ucfirst, isAsyncFunction } from '../utils.js'
 import { getInjectedArguments } from './inject.js'
-import { fireHook } from './hooks.js'
+import { fireHook, BeforeSuiteHook, AfterSuiteHook } from './hooks.js'
 
 const injectHook = function (inject, suite) {
   try {
@@ -232,6 +232,10 @@ export function suiteSetup(suite) {
 
     // Set up error handler for suite setup
     recorder.errHandler(err => {
+      // A helper's `_beforeSuite()` runs through this hook, not through the
+      // `injected()` wrapper, so nothing here used to emit `hook.failed` and
+      // reporters listening for it never saw the failure. (#5660)
+      event.emit(event.hook.failed, new BeforeSuiteHook(suite, err))
       doneFn(err)
     })
 
@@ -254,6 +258,8 @@ export function suiteTeardown(suite) {
 
     // Set up error handler for suite teardown
     recorder.errHandler(err => {
+      // Same for a helper's `_afterSuite()`. (#5660)
+      event.emit(event.hook.failed, new AfterSuiteHook(suite, err))
       doneFn(err)
     })
 

package/lib/mocha/hooks.js

@@ -33,12 +33,22 @@ class Hook {
   }
 
   simplify() {
+    // this.runnable (context.ctx.test) is the hook's own runnable; its
+    // .parent is the real Mocha Suite that owns this hook. Included here so
+    // run-workers can forward suite identity to the main process, where
+    // listeners (e.g. junitReporter) have no other way to recover it — the
+    // worker's live Suite/ctx objects aren't serializable across the thread
+    // boundary, only these plain fields are.
+    const suite = this.runnable?.parent
     return {
       hookName: this.hookName,
       title: this.title,
       // test: this.test ? serializeTest(this.test) : null,
       // suite: this.suite ? serializeSuite(this.suite) : null,
       error: this.err ? serializeError(this.err) : null,
+      suiteTitle: suite?.title || null,
+      suiteFile: suite?.file || null,
+      suiteTags: suite?.tags || [],
     }
   }
 

package/lib/parser.js

@@ -4,7 +4,8 @@ function _interopDefault(ex) {
 import * as acorn from 'acorn'
 import parseFunctionModule from 'parse-function'
 const parseFunction = _interopDefault(parseFunctionModule)
-const parser = parseFunction({ parse: acorn.parse, ecmaVersion: 11, plugins: ['objectRestSpread'] })
+const ecmaVersion = 11
+const parser = parseFunction({ parse: acorn.parse, ecmaVersion, plugins: ['objectRestSpread'] })
 import output from './output.js'
 
 parser.use(destructuredArgs)
@@ -17,7 +18,7 @@ export const getParamsToString = function (fn) {
 function getParams(fn, { warnOnLegacyFormat = false } = {}) {
   if (fn.isSinonProxy) return []
   try {
-    const reflected = parser.parse(fn)
+    const reflected = parser.parse(normalizeArrowFn(fn))
     if (warnOnLegacyFormat && (reflected.args.length > 1 || reflected.args[0] === 'I')) {
       output.error('Error: old CodeceptJS v2 format detected. Upgrade your project to the new format -> https://bit.ly/codecept3Up')
     }
@@ -38,6 +39,17 @@ function getParams(fn, { warnOnLegacyFormat = false } = {}) {
 
 export { getParams }
 
+function normalizeArrowFn(fn) {
+  const code = (typeof fn === 'function' ? fn.toString() : String(fn)).trim()
+  if (!code.includes('=>') || code.startsWith('async')) return fn
+  try {
+    if (acorn.parseExpressionAt(code, 0, { ecmaVersion }).type !== 'ArrowFunctionExpression') return fn
+  } catch {
+    return fn
+  }
+  return `async ${code}`
+}
+
 function destructuredArgs() {
   return (node, result) => {
     result.destructuredArgs = result.destructuredArgs || []

package/lib/plugin/junitReporter.js

@@ -67,13 +67,29 @@ export default function (config = {}) {
 
   let written = false
   const hookFailures = []
+  // groupBySuite() (below) groups by object identity, not by value — reused
+  // across BeforeSuite/AfterSuite failures from the same worker-forwarded
+  // suite so they land in one <testsuite>, not one per failure.
+  const workerSuiteByKey = new Map()
 
   event.dispatcher.on(event.hook.failed, hook => {
     if (!hook || !['BeforeSuite', 'AfterSuite'].includes(hook.hookName)) return
     const err = hook.err || hook.error
     if (!err) return
     const runnable = hook.ctx && hook.ctx.test
-    const suite = runnable && runnable.parent
+    // Under run-workers, hook.ctx is absent — the failure arrives as the
+    // plain object from Hook.simplify() in the main process instead of a
+    // live Hook instance. Fall back to the suiteTitle/suiteFile/suiteTags
+    // simplify() carries across the worker boundary so the failure still
+    // groups under its real suite instead of the "Tests" fallback.
+    let suite = runnable && runnable.parent
+    if (!suite && hook.suiteTitle) {
+      const key = `${hook.suiteTitle} ${hook.suiteFile || ''}`
+      if (!workerSuiteByKey.has(key)) {
+        workerSuiteByKey.set(key, { title: hook.suiteTitle, file: hook.suiteFile, tags: hook.suiteTags })
+      }
+      suite = workerSuiteByKey.get(key)
+    }
     hookFailures.push({
       title: hook.title || `${hook.hookName} hook failed`,
       state: 'failed',