codeceptjs 4.1.0 → 4.2.0-beta.1

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/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',

package/lib/plugin/screencast.js

@@ -20,16 +20,21 @@ const defaultConfig = {
 }
 
 /**
- * Records WebM video of tests using Playwright's screencast API.
+ * Records a video of tests. Uses Playwright's `page.screencast` API (WebM) when the active
+ * helper is Playwright, or raw CDP `Page.startScreencast` (APNG, assembled in-process) when the
+ * active helper is `CDPBrowser` or a subclass (`Obscura`, `Kitesurf`, ...). Which path is used is
+ * detected automatically per test run; nothing in the config changes between them.
  *
- * When `captions` is enabled, action annotations are burned into the video;
- * when `subtitles` is enabled, a standalone `.srt` is also produced. Default
- * `on=fail` keeps videos for failed tests only; `on=test` keeps every test's
- * video.
+ * When `captions` is enabled, action annotations are burned into the video — Playwright only,
+ * via `page.screencast.showActions()`/`showChapter()`; silently absent on the CDP path, since CDP
+ * screencast frames are raw, uncomposited page captures with no overlay mechanism. `subtitles`
+ * (a standalone `.srt`) works identically on both paths, since it's driven by step events, not by
+ * the video API. Default `on=fail` keeps videos for failed tests only; `on=test` keeps every
+ * test's video.
  *
- * Note: enabling Playwright's helper-level `video: true` together with this
- * plugin produces two independent recordings (`output/videos/*.webm` from the
- * helper, `output/screencast/*.webm` from this plugin).
+ * Note: enabling Playwright's helper-level `video: true` together with this plugin produces two
+ * independent recordings (`output/videos/*.webm` from the helper, `output/screencast/*.webm` from
+ * this plugin).
  *
  * #### Configuration
  *
@@ -49,11 +54,11 @@ const defaultConfig = {
  *
  * Other config options:
  *
- * * `captions`: burn-in action overlays via `page.screencast.showActions()`. Default: true.
+ * * `captions`: burn-in action overlays via `page.screencast.showActions()`. Playwright only. Default: true.
  * * `subtitles`: also write a standalone `.srt` file alongside the video. Default: false.
  * * `video`: record a video. With `video=false, subtitles=true`, only the `.srt` is produced. Default: true.
- * * `size`: pass-through `{ width, height }` for `screencast.start`.
- * * `quality`: pass-through 0–100 for `screencast.start`.
+ * * `size`: pass-through `{ width, height }` — `screencast.start`'s `size` on Playwright, `maxWidth`/`maxHeight` on the CDP path.
+ * * `quality`: pass-through 0–100 for `screencast.start` (Playwright) or CDP `Page.startScreencast` (CDPBrowser family).
  *
  * CLI examples:
  *
@@ -64,7 +69,7 @@ const defaultConfig = {
  * ```
  */
 export default function (config = {}) {
-  const helper = getBrowserHelper()
+  const helper = getScreencastHelper()
   if (!helper) return
 
   const cliArgs = parsePluginArgs(config._args)
@@ -86,7 +91,9 @@ function wireScreencast(mode, options) {
   const state = {
     test: null,
     webmPath: null,
+    apngPath: null,
     srtPath: null,
+    kind: null,
     steps: null,
     startedAt: null,
     failed: false,
@@ -99,7 +106,9 @@ function wireScreencast(mode, options) {
     state.test = test
     state.failed = false
     state.webmPath = null
+    state.apngPath = null
     state.srtPath = null
+    state.kind = null
     state.startQueued = false
     state.started = false
     state.steps = options.subtitles ? {} : null
@@ -141,7 +150,9 @@ function wireScreencast(mode, options) {
     recorder.add('screencast:stop', async () => finalizeScreencast({
       test: state.test,
       webmPath: state.webmPath,
+      apngPath: state.apngPath,
       srtPath: state.srtPath,
+      kind: state.kind,
       steps: state.steps,
       failed: state.failed,
       started: state.started,
@@ -152,15 +163,25 @@ function wireScreencast(mode, options) {
 }
 
 async function startScreencast(test, options, state) {
-  const helper = getBrowserHelper()
-  if (!helper?.page?.screencast) {
-    if (!state.warnedNoApi) {
-      output.plugin('screencast', 'page.screencast not available — requires Playwright >= 1.59. Skipping.')
-      state.warnedNoApi = true
-    }
-    return
+  const helper = getScreencastHelper()
+
+  if (helper?.page?.screencast) {
+    state.kind = 'playwright'
+    return startPlaywrightScreencast(helper, test, options, state)
   }
 
+  if (typeof helper?.startScreencast === 'function') {
+    state.kind = 'cdp'
+    return startCdpScreencast(helper, test, options, state)
+  }
+
+  if (!state.warnedNoApi) {
+    output.plugin('screencast', 'No screencast API available on the active helper — requires Playwright >= 1.59, or a CDPBrowser-family helper (CDPBrowser/Obscura/Kitesurf). Skipping.')
+    state.warnedNoApi = true
+  }
+}
+
+async function startPlaywrightScreencast(helper, test, options, state) {
   const baseDir = path.join(store.outputDir || '_output', 'screencast')
   mkdirp.sync(baseDir)
   const baseName = testToFileName(test, { suffix: '', unique: true })
@@ -192,12 +213,42 @@ async function startScreencast(test, options, state) {
   }
 }
 
+async function startCdpScreencast(helper, test, options, state) {
+  const baseDir = path.join(store.outputDir || '_output', 'screencast')
+  mkdirp.sync(baseDir)
+  const baseName = testToFileName(test, { suffix: '', unique: true })
+  state.apngPath = path.join(baseDir, `${baseName}.apng`)
+  state.srtPath = path.join(baseDir, `${baseName}.srt`)
+
+  const startOpts = {}
+  if (options.size) {
+    startOpts.maxWidth = options.size.width
+    startOpts.maxHeight = options.size.height
+  }
+  if (options.quality != null) startOpts.quality = options.quality
+
+  try {
+    await helper.startScreencast(startOpts)
+    state.started = true
+  } catch (err) {
+    output.plugin('screencast', `Failed to start: ${err.message}`)
+    state.apngPath = null
+    state.srtPath = null
+    state.started = false
+  }
+
+  // captions/chapter burn-in (showActions/showChapter) is Playwright-only — CDP screencast
+  // frames are raw page captures with no overlay mechanism, so this is silently absent here.
+}
+
 async function finalizeScreencast(snapshot) {
-  const { test, options, mode, steps } = snapshot
-  let { webmPath, srtPath } = snapshot
+  const { test, options, mode, steps, kind } = snapshot
+  let { webmPath, apngPath, srtPath } = snapshot
 
-  const helper = getBrowserHelper()
-  if (snapshot.started && helper?.page?.screencast) {
+  const helper = getScreencastHelper()
+  let apngBuffer = null
+
+  if (kind === 'playwright' && snapshot.started && helper?.page?.screencast) {
     try {
       await helper.page.screencast.stop()
     } catch (err) {
@@ -205,6 +256,14 @@ async function finalizeScreencast(snapshot) {
     }
   }
 
+  if (kind === 'cdp' && snapshot.started && typeof helper?.stopScreencast === 'function') {
+    try {
+      apngBuffer = await helper.stopScreencast()
+    } catch (err) {
+      output.plugin('screencast', `stop failed: ${err.message}`)
+    }
+  }
+
   const shouldKeep = mode === 'test' || (mode === 'fail' && snapshot.failed)
 
   if (options.video && webmPath) {
@@ -218,6 +277,22 @@ async function finalizeScreencast(snapshot) {
     }
   }
 
+  if (options.video && apngPath) {
+    if (!shouldKeep || !apngBuffer) {
+      apngPath = null
+    } else {
+      try {
+        await fs.promises.writeFile(apngPath, apngBuffer)
+        ensureArtifactsObject(test)
+        test.artifacts.screencast = apngPath
+        attachJUnitArtifact(test, apngPath)
+      } catch (err) {
+        output.plugin('screencast', `failed to write APNG: ${err.message}`)
+        apngPath = null
+      }
+    }
+  }
+
   if (options.subtitles && steps) {
     if (options.video && !shouldKeep) {
       try { srtPath && fs.unlinkSync(srtPath) } catch { /* nothing to delete */ }
@@ -275,8 +350,25 @@ function buildSrt(steps) {
   return out
 }
 
+// `getBrowserHelper` (from `pluginParser.js`) only recognizes `Container.STANDARD_ACTING_HELPERS`
+// (`Playwright`/`WebDriver`/`Puppeteer`/`Appium`), so it never finds `CDPBrowser`/`Obscura`/
+// `Kitesurf`. Rather than widen that shared list — used by several other plugins with their own,
+// Playwright/WebDriver-specific assumptions — this plugin does its own duck-typed fallback lookup,
+// scoped to itself: any active helper exposing a `startScreencast` function qualifies, with no
+// hardcoded class names, so any future CDP-family helper picks this up automatically too.
+function getScreencastHelper() {
+  const standard = getBrowserHelper()
+  if (standard) return standard
+  const helpers = Container.helpers()
+  for (const name of Object.keys(helpers)) {
+    if (typeof helpers[name]?.startScreencast === 'function') return helpers[name]
+  }
+  return null
+}
+
 function ensureArtifactsObject(test) {
-  if (!test.artifacts || Array.isArray(test.artifacts)) test.artifacts = {}
+  if (!test.artifacts) test.artifacts = {}
+  else if (Array.isArray(test.artifacts)) test.artifacts = Object.assign({}, test.artifacts)
 }
 
 function attachJUnitArtifact(test, filePath) {

package/lib/step/base.js

@@ -1,4 +1,5 @@
 import color from 'chalk'
+import { pathToFileURL } from 'url'
 import Secret from '../secret.js'
 import { getCurrentTimeout } from '../timeout.js'
 import { ucfirst, humanizeString, serializeError } from '../utils.js'
@@ -149,8 +150,6 @@ class Step {
     const lines = this.stack.split('\n')
     if (lines[STACK_LINE]) {
       let line = lines[STACK_LINE].trim()
-        .replace(store.codeceptDir || '', '.')
-        .trim()
 
       // Map .temp.mjs back to original .ts files using container's tsFileMapping
       const fileMapping = store.tsFileMapping
@@ -160,10 +159,23 @@ class Step {
             line = line.replace(mjsFile, tsFile)
             break
           }
+
+          const mjsFileUrl = pathToFileURL(mjsFile).href
+          if (line.includes(mjsFileUrl)) {
+            line = line.replace(mjsFileUrl, pathToFileURL(tsFile).href)
+            break
+          }
         }
       }
 
-      return line
+      const codeceptDir = store.codeceptDir || ''
+      if (codeceptDir) {
+        line = line
+          .replace(pathToFileURL(codeceptDir).href, '.')
+          .replace(codeceptDir, '.')
+      }
+
+      return line.trim()
     }
     return ''
   }

package/lib/utils/loaderCheck.js

@@ -6,10 +6,16 @@
  * Check if a TypeScript loader is available for test files
  * Note: This checks if loaders are in the require array, not if packages are installed
  * Package installation is checked when actually requiring modules
+ * Always true under Bun, which transpiles TypeScript itself
  * @param {string[]} requiredModules - Array of required modules from config
  * @returns {boolean}
  */
 export function checkTypeScriptLoader(requiredModules = []) {
+  // Bun transpiles TypeScript natively, so no loader is needed.
+  // Node is not treated the same way: its native type stripping rejects enums
+  // and does not resolve extensionless relative imports.
+  if (process.versions.bun) return true
+
   // Check if a loader is configured in the require array
   return (
     requiredModules.includes('tsx/esm') ||

package/lib/utils.js

@@ -108,7 +108,7 @@ export const methodsOfObject = function (obj, className) {
 export const template = function (template, data) {
   return template.replace(/{{([^{}]*)}}/g, (a, b) => {
     const r = data[b]
-    if (r === undefined) return ''
+    if (r === undefined || r === null) return ''
     return r.toString()
   })
 }

package/lib/workers.js

@@ -508,10 +508,27 @@ class Workers extends EventEmitter {
     // Create workers and set up message handlers immediately (not in recorder queue)
     // This prevents a race condition where workers start sending messages before handlers are attached
     const workerThreads = []
+    const staggerDelay = this.codecept.config.workerInitializationDelay !== undefined 
+      ? this.codecept.config.workerInitializationDelay 
+      : 200
+
+    // Maximum total stagger window (default 10 seconds). Allows capping total delay regardless of worker count.
+    const maxStagger = this.codecept.config.workerInitializationMaxDelay ?? 10000
+    // Compute effective per-worker delay to keep total stagger within maxStagger.
+    const effectiveDelay = staggerDelay > 0
+      ? Math.min(staggerDelay, Math.floor(maxStagger / Math.max(1, this.workers.length - 1)))
+      : 0
+
     for (const worker of this.workers) {
       const workerThread = createWorker(worker, this.isPoolMode)
       this._listenWorkerEvents(workerThread)
       workerThreads.push(workerThread)
+      
+      // Stagger worker creation to prevent CPU spikes 
+      // from massive V8 isolate creation and naturally stagger browser init
+      if (this.workers.length > 1 && effectiveDelay > 0) {
+        await new Promise(resolve => setTimeout(resolve, effectiveDelay))
+      }
     }
 
     recorder.add('workers started', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.1.0",
+  "version": "4.2.0-beta.1",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
@@ -78,6 +78,8 @@
     "test:unit:webbapi:puppeteer": "mocha test/helper/Puppeteer_test.js --reporter @testomatio/reporter/mocha",
     "test:unit:webbapi:webDriver": "mocha test/helper/WebDriver_test.js --timeout 10000 --reporter @testomatio/reporter/mocha",
     "test:unit:webbapi:webDriver:noSeleniumServer": "mocha test/helper/WebDriver.noSeleniumServer_test.js --timeout 10000 --reporter @testomatio/reporter/mocha",
+    "test:unit:webbapi:cdpbrowser": "mocha test/helper/CDPBrowser_chrome_test.js --timeout 30000 --reporter @testomatio/reporter/mocha",
+    "test:unit:webbapi:obscura": "mocha test/helper/CDPBrowser_obscura_test.js --timeout 30000 --reporter @testomatio/reporter/mocha",
     "test:unit:expect": "mocha test/helper/Expect_test.js --reporter @testomatio/reporter/mocha",
     "test:plugin": "mocha test/plugin/plugin_test.js --reporter @testomatio/reporter/mocha",
     "def": "./runok.cjs def",
@@ -134,6 +136,7 @@
     "promise-retry": "1.1.1",
     "sprintf-js": "1.1.3",
     "uuid": "11.1.0",
+    "ws": "^8.21.2",
     "xpath": "0.0.34",
     "zod": "^4.1.11"
   },