codeceptjs 4.1.0 → 4.2.0-beta.1

package/docs/helpers/Kitesurf.md

@@ -0,0 +1,118 @@
+---
+permalink: /helpers/Kitesurf
+editLink: false
+sidebar: auto
+title: Kitesurf
+---
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## Kitesurf
+
+**Extends CDPBrowser**
+
+Kitesurf is a cloud browser helper that extends CDPBrowser to run tests against
+Cloudflare's Browser Run service (Kitesurf browser). It automates real browser
+sessions in Cloudflare's cloud infrastructure, eliminating the need to manage
+local browser instances.
+
+**Status:** Beta
+
+## Requirements
+
+*   Cloudflare account with Browser Run enabled
+*   API token with **Browser Rendering Edit** permission
+
+## Setup
+
+To create an API token with Browser Rendering Edit permission:
+
+1.  Log in to your Cloudflare dashboard
+2.  Go to My Profile > API Tokens
+3.  Click "Create Token"
+4.  Use the "Custom token" template
+5.  Under "Permissions", select "Browser Rendering" > "Edit"
+6.  Set the account scope to your target account
+7.  Copy the token and set it as `CF_API_TOKEN` environment variable
+
+For more details, see:
+
+*   [Cloudflare Browser Run Developers Docs][1]
+*   [Cloudflare Blog - Kitesurf Announcement][2]
+
+## Example
+
+```js
+// codecept.conf.js
+{
+  helpers: {
+    Kitesurf: {
+      url: 'https://example.com',
+      accountId: process.env.CF_ACCOUNT_ID,
+      apiToken: process.env.CF_API_TOKEN,
+    }
+  }
+}
+```
+
+Or set environment variables and rely on defaults:
+
+```bash
+export CF_ACCOUNT_ID="your-account-id"
+export CF_API_TOKEN="your-api-token"
+```
+
+
+
+## Configuration
+
+This helper should be configured in codecept.conf.js. It accepts everything `CDPBrowser`
+accepts (see its config table), plus:
+
+Type: [object][5]
+
+### Properties
+
+*   `url` **[string][4]?** base URL for tests
+*   `accountId` **[string][4]?** Cloudflare account ID; defaults to CF_ACCOUNT_ID env var
+*   `apiToken` **[string][4]?** Cloudflare API token; defaults to CF_API_TOKEN env var
+*   `keepAlive` **[number][6]?** session keep-alive time in milliseconds
+*   `apiBase` **[string][4]?** Cloudflare API base URL
+*   `input` **[string][4]?** input method for user actions; defaults to 'cdp' for Kitesurf's real layout engine, but can be overridden
+*   `capabilities` **[object][5]?** pre-configured capabilities; Kitesurf uses { layout: 'real', screenshot: true }
+
+
+
+## Methods
+
+### Parameters
+
+*   `config` **KitesurfConfig**&#x20;
+
+### _finishTest
+
+Closes the target as `CDPBrowser._finishTest` does, then releases the cloud session acquired
+in `_resolveEndpoint` via the Cloudflare API so it does not linger for the full `keepAlive`
+window. The release runs in a `finally` so a rejection while closing the CDP connection still
+frees the cloud session instead of leaving the browser alive until `keepAlive` expires; the
+session id is cleared before the request, so a repeated call never releases it twice.
+
+### _resolveEndpoint
+
+Acquires a Kitesurf browser session from the Cloudflare Browser Run API and resolves it to
+the `wss://` debugger URL `CDPConnection` connects to. Overrides `CDPBrowser._resolveEndpoint`,
+which resolves a fixed local endpoint instead of provisioning a cloud session per test.
+
+Returns **[Promise][3]<[string][4]>** a `wss://` debugger URL ready to be passed to `CDPConnection`.
+
+[1]: https://developers.cloudflare.com/browser-run/
+
+[2]: https://blog.cloudflare.com/kitesurf/
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number

package/docs/helpers/Obscura.md

@@ -0,0 +1,210 @@
+---
+permalink: /helpers/Obscura
+editLink: false
+sidebar: auto
+title: Obscura
+---
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## Obscura
+
+**Extends CDPBrowser**
+
+Obscura drives [Obscura][1], a minimal headless
+browser exposed over the Chrome DevTools Protocol. From v0.2.0, default release builds ship a
+real rendering engine (layout, paint, screenshots); `-no-render` variants and v0.1.x builds keep
+the original single-V8-isolate, nothing-rendered mode. This helper does not hardcode which mode a
+given binary is in — `CDPBrowser._probeCapabilities` detects `layout`/`screenshot` per binary at
+runtime, so the same helper works against either.
+
+This helper is a thin `CDPBrowser` subclass: it changes nothing about how locating or acting on
+elements works, it only pins the config presets Obscura requires and manages the `obscura serve`
+process lifecycle, the same way Playwright manages its own browser process.
+
+## Modes
+
+*   **ATTACH** — `endpoint` is set explicitly in the config. The helper only connects to it; it
+    never spawns or kills anything, no matter what `binaryPath`/`port` are set to.
+*   **SELF-LAUNCH** — `endpoint` is unset and a binary can be resolved, in order: `binaryPath` in
+    the config, then the `OBSCURA_PATH` environment variable, then `obscura` on `PATH`. The helper
+    spawns `obscura serve --port <port> --allow-private-network` (`port` from the config, or a
+    free port picked automatically), waits for it to answer, connects, and kills it in
+    `_finishTest`.
+*   **COURTESY-ATTACH** — `endpoint` is unset and no binary can be resolved, but something already
+    answers `http://127.0.0.1:9222/json/version` (e.g. `obscura serve` started by hand, or by CI
+    before this process ever ran). The helper attaches to it and never kills it — it isn't the
+    helper's process to kill. If neither a binary nor a running server on :9222 can be found, the
+    helper throws a loud, actionable error.
+
+## Install
+
+Download a release binary and put it on your `PATH` (or point `binaryPath`/`OBSCURA_PATH` at
+it directly) and the helper launches and tears it down for you automatically:
+
+```sh
+curl -sL https://github.com/h4ckf0r0day/obscura/releases/download/v0.2.0/obscura-x86_64-linux.tar.gz | tar xz
+```
+
+`--allow-private-network` is always passed by this helper (it's required to reach apps running
+on `localhost`/private IPs, e.g. a dev server on `127.0.0.1:8000` — Obscura blocks
+private-network requests by default).
+
+## Config presets
+
+These are set automatically and only need overriding for unusual setups:
+
+| option          | value       | why                                                                                                                                                                                                                                          |
+| --------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `input`         | `synthetic` | coordinate-click navigation is unreliable over CDP on Obscura even on rendering builds (no `frameNavigated` event, stale `page.url()`); `click` always takes the `forceClick` path — on Obscura, `click` and `forceClick` are the same thing |
+| `xpathPolyfill` | `auto`      | probed per binary/page: Obscura's native `document.evaluate` still doesn't support attribute selection or `not()`, so the polyfill is used until that lands                                                                                  |
+
+`capabilities.layout`/`capabilities.screenshot`/`capabilities.xpath` are intentionally left
+unset here — `CDPBrowser._probeCapabilities` detects them at runtime from the actual binary
+(`'real'`/`true` on v0.2.0+ default builds, `'none'`/`false` on `-no-render` builds and v0.1.x).
+Set them explicitly in your own config to skip probing or to force a mode.
+
+## Limitations
+
+*   `input` is always `synthetic`, even on rendering builds — see `input` above.
+*   No frames, popups, or file uploads.
+*   On `-no-render` builds and v0.1.x: no screenshots, no visibility assertions
+    (`seeElement`/`dontSeeElement` always throw) — only DOM presence
+    (`seeElementInDOM`/`dontSeeElementInDOM`) is meaningful without a layout engine.
+*   On v0.2.0+ default (rendering) builds: layout, screenshots, and CSS work, but it's a new,
+    independently implemented rendering/CSS engine — expect edge cases and gaps versus a real browser.
+*   Single V8 isolate: heavy or long-running pages, or many pages in parallel against one
+    `obscura serve` process, compete for the same isolate.
+
+
+
+## Configuration
+
+This helper should be configured in codecept.conf.js. It accepts everything `CDPBrowser`
+accepts (see its config table), plus:
+
+Type: [object][6]
+
+### Properties
+
+*   `endpoint` **[string][4]?** explicit CDP endpoint. Setting this switches the helper to ATTACH
+    mode: it only connects, and never spawns or kills a process, no matter what else is configured.
+    Leave it unset for SELF-MANAGED mode (see below).
+*   `binaryPath` **[string][4]?** path to the `obscura` executable, used in SELF-MANAGED mode
+    (`endpoint` unset). Checked before `OBSCURA_PATH` and `PATH`.
+*   `port` **[number][3]?** port `obscura serve` listens on, in SELF-MANAGED mode. When unset, a
+    free port is picked automatically, which is what makes `run-workers` collision-free — every
+    worker gets its own instance on its own port with zero config.
+*   `serverStartTimeout` **[number][3]?** milliseconds to wait for a spawned `obscura serve`
+    to answer `/json/version` before `_connect` gives up.
+
+
+
+## Example
+
+```js
+// inside codecept.conf.js — SELF-LAUNCH mode (recommended): the helper finds/starts/stops
+// obscura serve on its own, on a free port. Ideal for run-workers: every worker gets its own
+// instance with no config.
+{
+  helpers: {
+    Obscura: {
+      url: 'http://localhost',
+    }
+  }
+}
+```
+
+```js
+// ATTACH mode — connect to an Obscura instance you manage yourself (remote host, container, etc.)
+{
+  helpers: {
+    Obscura: {
+      url: 'http://localhost',
+      endpoint: 'http://127.0.0.1:9222',
+    }
+  }
+}
+```
+
+## Methods
+
+### Parameters
+
+*   `config` **ObscuraConfig**&#x20;
+
+### _connect
+
+In ATTACH mode, connects exactly as `CDPBrowser._connect` would. In SELF-MANAGED mode,
+resolves and spawns `obscura serve` (or courtesy-attaches to an already-running one on
+:9222) exactly once via `_resolveSelfManaged`, then connects.
+
+A spawn failure (e.g. a bad binary) is delivered asynchronously by Node as an `error`
+event; it is recorded on `this.serverError` and surfaced as a rejection from `_waitForServer`
+instead of crashing the process as an uncaught exception.
+
+### _findFreePort
+
+Picks a free TCP port on 127.0.0.1 by briefly listening on port 0 and reading back the OS-assigned
+port. Used as the SELF-LAUNCH default when `options.port` isn't explicitly set, so multiple
+`run-workers` workers never collide on the same port.
+
+Returns **[Promise][2]<[number][3]>** a free port.
+
+### _finishTest
+
+Closes the CDP connection (via `CDPBrowser._finishTest`), then kills the `obscura serve`
+process spawned by `_connect`, if any (never runs in ATTACH or COURTESY-ATTACH mode, since
+`this.serverProcess` is only ever set in SELF-LAUNCH mode). Runs in a `finally` so the process
+is always reaped even if closing the CDP connection throws. Sends `SIGTERM` first and waits for
+the process to exit; a process that ignores `SIGTERM` is escalated to `SIGKILL` after 5s. The
+promise only resolves once the child has actually exited (confirmed via the `exit` event, not
+merely once `SIGKILL` was sent — the kernel needs a moment to reap it), with a final safety-net
+timeout so a stuck child can never keep the event loop alive even if that confirmation is
+somehow lost.
+
+### _probeUp
+
+Probes a `/json/version`-style URL with a short timeout, used for the COURTESY-ATTACH check.
+
+#### Parameters
+
+*   `url` **[string][4]**&#x20;
+
+Returns **[Promise][2]<[boolean][5]>** true if the URL answered.
+
+### _resolveBinary
+
+Resolves the `obscura` binary to spawn, in priority order: `options.binaryPath`, then the
+`OBSCURA_PATH` environment variable, then `obscura` on `PATH`. The `PATH` lookup walks the
+directories itself instead of shelling out to `which`, which does not exist on Windows: on
+Windows every `PATHEXT` suffix is tried, so an `obscura.exe` on `PATH` is found too.
+
+Returns **([string][4] | null)** an absolute or relative path to the binary, or null if none resolved.
+
+### _resolveSelfManaged
+
+Resolves how to reach Obscura when no explicit `endpoint` was configured, trying, in order:
+spawn a binary (`binaryPath` config, then `OBSCURA_PATH` env, then `obscura` on `PATH`),
+courtesy-attach to `http://127.0.0.1:9222` if something already answers there, or throw a
+loud, actionable error. Sets `this.options.endpoint` as a side effect.
+
+### _waitForServer
+
+Polls `http://127.0.0.1:<port>/json/version` until `obscura serve` responds, `this.serverError`
+is set by the spawned process' `error` event, or `options.serverStartTimeout` elapses. The
+process typically comes up within tens of milliseconds — a 20ms retry interval (down from a
+previous 200ms) keeps the wasted tail after the server is actually ready small, since this cost
+is paid once per run and counts directly toward real-world startup latency.
+
+[1]: https://github.com/h4ckf0r0day/obscura
+
+[2]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise
+
+[3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+
+[4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+
+[5]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+
+[6]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object

package/docs/migration-4.md

@@ -614,7 +614,7 @@ Test files written for 3.x keep working until you flip the flag.
 
 ### `wait*` Methods Resolve Relative URLs
 
-`waitInUrl`, `waitUrlEquals`, and `waitCurrentPathEquals` now resolve a relative path against the helper's configured `url` before comparing. In 3.x a literal substring match against `window.location.href` would fail for relative paths.
+`waitUrlEquals` and `waitCurrentPathEquals` now resolve a relative path against the helper's configured `url` before comparing. In 3.x a literal comparison against `window.location.href` would fail for relative paths.
 
 ```js
 // helpers: { Playwright: { url: 'https://app.example.com' } }
@@ -623,6 +623,8 @@ I.waitUrlEquals('/dashboard')   // matches https://app.example.com/dashboard
 I.waitInUrl('/users')           // matches any URL containing /users
 ```
 
+`waitInUrl` is unchanged from 3.x — it stays a plain substring match against the current URL and never resolves its argument.
+
 `waitUrlEquals` error messages now include the actual URL the page was on when the wait timed out — easier to diagnose `/dashboard` vs `/dashboard?session=expired`.
 
 ## 6. Adopt New Behaviors

package/docs/parallel.md

@@ -22,6 +22,8 @@ npx codeceptjs run-workers 4
 
 Steps are not streamed to the console in this mode — output from separate threads can't be interleaved cleanly. While workers run, CodeceptJS sets `process.env.RUNS_WITH_WORKERS=true`, so plugins and helpers can branch on it. All `run` options work here too: `--grep "@smoke"`, `-c codecept.conf.js`, `--debug`, and the rest.
 
+By default, workers are created with a staggered delay of 200ms to prevent CPU spikes and stagger browser initializations. You can adjust this via `workerInitializationDelay` in your configuration.
+
 ### Distribution strategies
 
 `--by` controls how tests spread across workers:
@@ -185,3 +187,11 @@ Shared data is a Proxy. Don't reassign the injected object itself (`let d = inje
 ```js
 share({ tmpFile: '/tmp/run-1' }, { local: true })
 ```
+
+## Scaling beyond one machine
+
+Worker threads split the suite, but every Playwright worker still runs a full local browser.
+With the [Kitesurf helper](/helpers/Kitesurf) each worker drives a cloud browser on Cloudflare
+instead — `run-workers 16` means sixteen browsers spawned in about a second, none of them
+competing for your runner's CPU. See [Alternative Browser Engines](/alternative-browsers) for
+the full setup.

package/docs/plugins/screencast.md

@@ -9,16 +9,21 @@ title: screencast
 
 ## screencast
 
-Records WebM video of tests using Playwright's screencast API.
-
-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.
-
-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).
+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 — 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).
 
 #### Configuration
 
@@ -38,11 +43,11 @@ plugins: {
 
 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:
 

package/docs/plugins.md

@@ -71,7 +71,7 @@ Retries each failed step in a test.
 
 ## [screencast](/plugins/screencast)
 
-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.
 
 ## [screenshot](/plugins/screenshot)
 

package/lib/command/info.js

@@ -44,6 +44,14 @@ async function getOsBrowsers() {
   ].join(', ')
 }
 
+// Which runtime executes CodeceptJS can only be told from `process.versions`; envinfo probes
+// PATH, where under `bunx --bun` the first `node` is a Bun shim with no --version, so
+// getNodeInfo() returns "Not Found" on a working install.
+async function getRuntimeInfo() {
+  if (process.versions.bun) return { bunInfo: await envinfo.helpers.getbunInfo() }
+  return { nodeInfo: await envinfo.helpers.getNodeInfo() }
+}
+
 export default async function (path) {
   const testsPath = getTestRoot(path)
   const config = await getConfig(testsPath)
@@ -53,7 +61,7 @@ export default async function (path) {
   output.print('\n Environment information: \n')
   const info = {}
   info.codeceptVersion = Codecept.version()
-  info.nodeInfo = await envinfo.helpers.getNodeInfo()
+  Object.assign(info, await getRuntimeInfo())
   info.osInfo = await envinfo.helpers.getOSInfo()
   info.cpuInfo = await envinfo.helpers.getCPUInfo()
   info.osBrowsers = await getOsBrowsers()
@@ -77,11 +85,11 @@ export default async function (path) {
   output.print('***************************************')
 }
 
-export { parsePlaywrightBrowsers }
+export { parsePlaywrightBrowsers, getRuntimeInfo }
 
 export const getMachineInfo = async () => {
   const info = {
-    nodeInfo: await envinfo.helpers.getNodeInfo(),
+    ...(await getRuntimeInfo()),
     osInfo: await envinfo.helpers.getOSInfo(),
     cpuInfo: await envinfo.helpers.getCPUInfo(),
     chromeInfo: await envinfo.helpers.getChromeInfo(),

package/lib/command/workers/runTests.js

@@ -129,13 +129,7 @@ let config
 // Load test and run
 initPromise = (async function () {
   try {
-    // Add staggered delay at the very start to prevent resource conflicts
-    // Longer delay for browser initialization conflicts
-    const delay = (workerIndex - 1) * 2000 // 0ms, 2s, 4s, etc.
-    if (delay > 0) {
-      await new Promise(resolve => setTimeout(resolve, delay))
-    }
-    
+
     // Import modules dynamically to avoid ES Module loader race conditions in Node 22.x
     const eventModule = await import('../../event.js')
     const containerModule = await import('../../container.js')
@@ -153,9 +147,9 @@ initPromise = (async function () {
     Codecept = CodeceptModule.default
     fixErrorStack = typescriptModule.fixErrorStack
     loadTests = loadTestsModule.default
-    
+
     const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
-    
+
     let baseConfig
     try {
       // IMPORTANT: await is required here since getConfig is async
@@ -172,14 +166,14 @@ initPromise = (async function () {
       await new Promise(resolve => setTimeout(resolve, 100))
       process.exit(1)
     }
-    
+
     // important deep merge so dynamic things e.g. functions on config are not overridden
     config = deepMerge(baseConfig, overrideConfigs)
-    
+
     // Pass workerIndex as child option for output.process() to display worker prefix
     const optsWithChild = { ...options, child: workerIndex }
     codecept = new Codecept(config, optsWithChild)
-    
+
     try {
       await codecept.init(testRoot)
     } catch (initErr) {
@@ -193,7 +187,7 @@ initPromise = (async function () {
       process.stderr.write(`${initErr.stack}\n`)
       process.exit(1)
     }
-    
+
     codecept.loadTests()
     mocha = container.mocha()
 
@@ -279,7 +273,7 @@ async function runPoolTests() {
       const messageHandler = async eventData => {
         // Remove handler immediately to prevent duplicate processing
         parentPort?.off('message', messageHandler)
-        
+
         if (eventData.type === 'TEST_ASSIGNED') {
           // In pool mode with ESM, we receive test FILE paths instead of UIDs
           // because UIDs are not stable across different mocha instances
@@ -289,7 +283,7 @@ async function runPoolTests() {
             // Create a fresh Mocha instance for each test file
             container.createMocha()
             const mocha = container.mocha()
-            
+
             // Load only the assigned test file
             mocha.files = [testIdentifier]
             await loadTests(mocha)
@@ -348,7 +342,7 @@ async function runPoolTests() {
 
       // Set up handler BEFORE sending request to avoid race condition
       parentPort?.on('message', messageHandler)
-      
+
       // Now send the request
       sendToParentThread({ type: 'REQUEST_TEST', workerIndex })
     })
@@ -391,13 +385,13 @@ async function runPoolTests() {
 function filterTestById(testUid) {
   // In pool mode with ESM, test files are already loaded once at initialization
   // We just need to filter the existing mocha suite to only include the target test
-  
+
   // Get the existing mocha instance
   const mocha = container.mocha()
 
   // Save reference to all suites before clearing
   const allSuites = [...mocha.suite.suites]
-  
+
   // Clear suites and tests but preserve other mocha settings
   mocha.suite.suites = []
   mocha.suite.tests = []
@@ -406,10 +400,10 @@ function filterTestById(testUid) {
   let foundTest = false
   for (const suite of allSuites) {
     const originalTests = [...suite.tests]
-    
+
     // Check if this suite has our target test
     const targetTest = originalTests.find(test => test.uid === testUid)
-    
+
     if (targetTest) {
       // Create a filtered suite with only the target test
       suite.tests = [targetTest]

package/lib/container.js

@@ -892,6 +892,12 @@ async function loadSupportObject(modulePath, supportObjectName) {
           for (const [key, value] of mapping.entries()) {
             container.tsFileMapping.set(key, value)
           }
+          if (!store.tsFileMapping) {
+            store.tsFileMapping = new Map()
+          }
+          for (const [key, value] of mapping.entries()) {
+            store.tsFileMapping.set(key, value)
+          }
         } catch (tsError) {
           throw new Error(`Failed to load TypeScript file ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
         }

package/lib/data/context.js

@@ -68,6 +68,10 @@ function replaceTitle(title, dataRow) {
     return `${title} | {${JSON.stringify(dataRow.data)}}`
   }
 
+  if (typeof dataRow.data.getMasked === 'function') {
+    return `${title} | ${dataRow.data.getMasked()}`
+  }
+
   // if `dataRow` is object and has own `toString()` method,
   // it should be printed
   if (Object.prototype.toString.call(dataRow.data) === Object().toString() && dataRow.data.toString() !== Object().toString()) {

package/lib/element/WebElement.js

@@ -20,6 +20,7 @@ class WebElement {
       if (ctor.name === 'Playwright') return 'playwright'
       if (ctor.name === 'WebDriver') return 'webdriver'
       if (ctor.name === 'Puppeteer') return 'puppeteer'
+      if (ctor.name === 'CDPBrowser') return 'cdpbrowser'
       ctor = Object.getPrototypeOf(ctor)
     }
 
@@ -493,6 +494,8 @@ class WebElement {
         return this.element.evaluate(xpathFn)
       case 'webdriver':
         return this.helper.browser.execute(xpathFn, this.element)
+      case 'cdpbrowser':
+        return this.element.absoluteXPath()
       default:
         throw new Error(`Unsupported helper type: ${this.helperType}`)
     }
@@ -506,6 +509,8 @@ class WebElement {
         return this.element.evaluate(el => el.outerHTML)
       case 'webdriver':
         return this.helper.browser.execute(el => el.outerHTML, this.element)
+      case 'cdpbrowser':
+        return this.element.outerHTML()
       default:
         throw new Error(`Unsupported helper type: ${this.helperType}`)
     }

package/lib/helper/Appium.js

@@ -978,11 +978,23 @@ class Appium extends Webdriver {
    */
   async setNetworkConnection(value) {
     onlyForApps.call(this, supportedPlatform.android)
-    return this.browser.execute('mobile: setConnectivity', {
+    const connectivity = {
       airplaneMode: !!(value & 1),
       wifi: !!(value & 2),
       data: !!(value & 4),
-    })
+    }
+    // `mobile: setConnectivity` runs `adb shell svc data <state>` for every field it receives,
+    // which fails with "Can't find service: phone" on images without telephony (e.g. tablets).
+    // Only a positive result is cached: a freshly booted device may not have registered a carrier
+    // yet, and caching that would strip `data` for the whole session.
+    if (!this._hasTelephony) {
+      const deviceInfo = await this.browser.execute('mobile: deviceInfo')
+      this._hasTelephony = !!deviceInfo?.carrierName
+    }
+    // Keep `data` on telephony-capable devices, otherwise the device stays online over cellular
+    // and going offline silently does nothing.
+    if (!this._hasTelephony) delete connectivity.data
+    return this.browser.execute('mobile: setConnectivity', connectivity)
   }
 
   /**