codeceptjs 4.0.0-rc.22 → 4.0.0-rc.24

package/docs/migration-4.md

@@ -96,14 +96,27 @@ await Container.create(config, opts)
 
 | Removed helper | What to do |
 |----------------|------------|
-| `Nightmare` | Switch to `Playwright`, `Puppeteer`, or `WebDriver`. |
-| `Protractor` | Switch to `Playwright` or `WebDriver`. |
+| `Nightmare` | Switch to `Playwright`, `Puppeteer`, or `WebDriver`. Nightmare is unmaintained; `Playwright` is the closest drop-in for headless flows. |
+| `Protractor` | Switch to `Playwright` or `WebDriver`. Angular apps work without the Protractor-specific waits — use `waitForElement`/`waitForClickable`. |
 | `TestCafe` | Switch to `Playwright`. |
 | `AI` | Use the top-level `ai:` config option and the new `aiTrace` plugin. |
 | `SoftExpectHelper` | Use the `hopeThat` effect instead — see below. |
+| `Mochawesome` | Removed. Use the [Testomat.io Reporter](https://github.com/testomatio/reporter) HTML pipe for HTML reports — see below. |
 
 `Container.STANDARD_ACTING_HELPERS` no longer lists `TestCafe`.
 
+If you relied on a removed helper for behavior none of the built-in helpers cover, **write a custom helper**. A helper is a plain class extending `@codeceptjs/helper`; you can wrap any Node library and expose `I.*` actions. See [Custom Helpers](/helpers).
+
+```js
+import Helper from '@codeceptjs/helper'
+
+class MyHelper extends Helper {
+  async doSomething() { /* wrap any library here */ }
+}
+
+export default MyHelper
+```
+
 ### `SoftExpectHelper` → `hopeThat`
 
 3.x shipped a `SoftExpectHelper` (`I.softAssert`, `I.softExpectEqual`, `I.flushSoftAssertions`, etc.) for soft assertions. It is gone in 4.x. Use the `hopeThat` effect — it works with **any** assertion that throws (built-in `I.see*`, your custom helper, `expect` from chai/jest, Node's `assert`).
@@ -131,6 +144,147 @@ hopeThat.noErrors()
 
 Each `hopeThat()` call records the failure as a note on the test and lets the scenario continue; `hopeThat.noErrors()` throws once at the end with every recorded failure if any happened. See [Effects: hopeThat](/effects#hopethat).
 
+### `Mochawesome` → Testomat.io Reporter
+
+3.x bundled a `Mochawesome` helper that pushed steps and screenshots into a [`mochawesome`](https://www.npmjs.com/package/mochawesome) Mocha report. The helper, the `mochawesome` dependency, and the worker-level report-dir wiring are all gone in 4.x.
+
+For an HTML report, use the [Testomat.io Reporter](https://github.com/testomatio/reporter) with the HTML pipe — it includes steps, screenshots, videos, and traces, works under `--workers`, and needs no helper in your config. See [Reports](/reports).
+
+3.x:
+
+```js
+helpers: { Mochawesome: { uniqueScreenshotNames: true } }
+```
+
+```bash
+npx codeceptjs run --reporter mochawesome --reporter-options reportDir=output
+```
+
+4.x:
+
+```bash
+npm install --save-dev @testomatio/reporter
+```
+
+```js
+// codecept.conf.js
+plugins: {
+  testomatio: {
+    enabled: true,
+    require: '@testomatio/reporter/codecept',
+    html: true,
+  },
+}
+```
+
+```bash
+npx codeceptjs run
+```
+
+The HTML report is written to `output/report/` by default. See [Reports > HTML](/reports) for pipe options.
+
+Reporting notes:
+
+- **JUnit XML** (CI servers, GitHub Actions test tab): enable the [`junitReporter`](/plugins#junitreporter) plugin instead of `mocha-junit-reporter`. It includes CodeceptJS steps. See [Reports → JUnit XML](/reports#junit-xml).
+- **Multiple Mocha reporters** via `mocha-multi` / `cmr` is **not recommended** in 4.x — the Testomat.io HTML pipe plus the `junitReporter` plugin cover the HTML + JUnit combination without chaining reporters.
+
+#### Keeping Mochawesome (not recommended)
+
+The `mochawesome` reporter itself is a stock Mocha reporter — it never depended on CodeceptJS bundling it, so it keeps working. Only the bundled **helper** (which embedded failure screenshots into the report) was removed. If you must stay on Mochawesome, you own that glue now.
+
+**Report only — no screenshots embedded.** This works as-is:
+
+```bash
+npm install --save-dev mochawesome
+npx codeceptjs run --reporter mochawesome --reporter-options reportDir=output
+```
+
+**Report with embedded failure screenshots.** Re-create the old helper as a project-local custom helper. This is a faithful port of the 3.x helper:
+
+```js
+// helpers/Mochawesome.js
+import Helper from '@codeceptjs/helper'
+import { createRequire } from 'module'
+// ⚠️ Internal, NOT semver-stable subpaths. Pin your codeceptjs version —
+// a future minor may move these. This coupling is why core dropped the helper.
+import { clearString } from 'codeceptjs/lib/utils.js'
+import { testToFileName } from 'codeceptjs/lib/mocha/test.js'
+
+const addContext = createRequire(import.meta.url)('mochawesome/addContext')
+
+class Mochawesome extends Helper {
+  constructor(config) {
+    super(config)
+    this.options = { uniqueScreenshotNames: false, disableScreenshots: false, ...config }
+    this.currentTest = ''
+    this.currentSuite = null
+  }
+
+  _beforeSuite(suite) {
+    this.currentSuite = suite
+    this.currentTest = ''
+  }
+
+  _before() {
+    if (this.currentSuite?.ctx) {
+      this.currentTest = { test: this.currentSuite.ctx.currentTest }
+    }
+  }
+
+  _test(test) {
+    this.currentTest = { test }
+  }
+
+  _failed(test) {
+    if (this.options.disableScreenshots) return
+    let fileName
+    if (test.ctx?.test?.type === 'hook') {
+      this.currentTest = { test: test.ctx.test }
+      test._retries = -1
+      fileName = clearString(`${test.title}_${this.currentTest.test.title}`)
+    } else {
+      this.currentTest = { test }
+      fileName = testToFileName(test)
+    }
+    if (this.options.uniqueScreenshotNames) {
+      fileName = testToFileName(test, { unique: true })
+    }
+    if (test._retries < 1 || test._retries === test.retryNum) {
+      return addContext(this.currentTest, `${fileName}.failed.png`)
+    }
+  }
+
+  // exposed as I.addMochawesomeContext(...) for manual attachments
+  addMochawesomeContext(context) {
+    if (this.currentTest === '') this.currentTest = { test: this.currentSuite.ctx.test }
+    return addContext(this.currentTest, context)
+  }
+}
+
+export default Mochawesome
+```
+
+Register it and run with the reporter:
+
+```js
+// codecept.conf.js
+helpers: {
+  Mochawesome: {
+    require: './helpers/Mochawesome.js',
+    uniqueScreenshotNames: true,
+  },
+}
+```
+
+```bash
+npx codeceptjs run --reporter mochawesome --reporter-options reportDir=output
+```
+
+Two caveats this port cannot fully solve:
+
+- The internal imports (`codeceptjs/lib/utils.js`, `codeceptjs/lib/mocha/test.js`) are reachable but **not part of the public API** — pin `codeceptjs` and re-test on upgrades.
+- The 3.x `screenshot`/`screenshotOnFail` plugin read `helpers.Mochawesome.config.uniqueScreenshotNames` to keep the embedded reference and the saved screenshot file in sync. Core no longer does this. Set `uniqueScreenshotNames` to the **same value** on both this helper and the `screenshot` plugin, or the embedded filename and the saved file can diverge on retries.
+
 ### Custom Assertion Libraries
 
 No code changes are required for chai, expect, jest-style matchers, or Node's `assert` — just import them in your test files. With `noGlobals: true`, they work the same as before.
@@ -148,8 +302,8 @@ Heads up on chai: 3.x pinned `chai@4`; 4.x devDep is `chai@6`, which is **ESM-on
 | `commentStep` | `import step from 'codeceptjs/steps'` then `step.section('name')` / `step.endSection()` |
 | `fakerTransform` | Import `@faker-js/faker` directly in tests. |
 | `enhancedRetryFailedStep` | Merged into `retryFailedStep`. Rename in config. |
-| `allure` | Use [@testomatio/reporter](https://testomat.io) or Mochawesome. |
-| `htmlReporter` | Use an external reporter. |
+| `allure` | Use [@testomatio/reporter](https://testomat.io). |
+| `htmlReporter` | Use the [Testomat.io Reporter](https://github.com/testomatio/reporter) HTML pipe — see [Reports](/reports). |
 | `wdio` | Configure WebdriverIO services directly in `helpers.WebDriver`. |
 | `selenoid` | Run Selenoid externally. |
 | `standardActingHelpers` | No longer needed; the list lives in core. |
@@ -320,18 +474,50 @@ Use one of:
 
 The `customLocators` strategy registration in Playwright config is removed. Use the `customLocator` plugin or built-in ARIA locators (`{ role: 'button', name: 'Submit' }`).
 
-### `I.retry()` is deprecated
+### React and Vue Locators removed
+
+The `react` component locator and the bare-string `_react=`/`_vue=` Playwright selectors are removed from the Playwright, Puppeteer, and WebDriver helpers. The `resq` dependency is dropped.
+
+```js
+// 3.x (removed)
+I.click({ react: 'SubmitButton' })
+I.seeElement({ react: 'Alert' })
+I.fillField({ react: 'EmailInput' }, 'a@b.com')
+```
+
+They relied on `resq`, which is unmaintained, supports only React 16, reads React's private internal tree, and breaks under production minification. There is no working path for React 17, 18, or 19.
+
+Use [ARIA locators](/locators#aria-locators) instead — they match how a user perceives the page and survive refactoring and minification:
 
-Use the step options API:
+```js
+// 4.x
+I.click({ role: 'button', name: 'Submit' })
+I.seeElement('[role=alert]')
+I.fillField('Email', 'a@b.com')
+```
+
+For a component that renders no stable role, label, or text, add a `data-testid` in the JSX and locate by it: `I.click('[data-testid="submit"]')`.
+
+### `I.retry()` and `I.limitTime()` removed
+
+Both were deprecated in 3.x and are **removed in 4.x**. They configured the *next* step through a chained call; the replacement is the step options API — pass a `step.*` config as the **last argument** of the step itself.
 
 ```js
 import step from 'codeceptjs/steps'
 
-I.click('Submit', step.retry(3))
-I.fillField('Email', 'a@b.c', step.timeout(10))
+// 3.x (removed)            →  4.x
+I.retry(3).click('Submit')  //  I.click('Submit', step.retry(3))
+I.limitTime(10).fillField('Email', 'a@b.c') // I.fillField('Email', 'a@b.c', step.timeout(10))
+```
+
+`step.*` configs are also composable with the other step options:
+
+```js
 I.click('Add', step.opts({ elementIndex: 2 }))
 ```
 
+The behavior is unchanged — the option applies only to the step it is attached to, not to subsequent steps (this also fixes the 3.x footgun where `I.retry()` could leak retry settings onto the following step). `recorder.retry()` is unaffected and remains available for custom helpers.
+
 ### `within` Is Now an Effect
 
 In 3.x, `within(...)` was a global statement available everywhere. In 4.x it's an effect alongside `tryTo`, `retryTo`, and `hopeThat`. Under `noGlobals: true` you must import it:
@@ -527,6 +713,7 @@ If your project depends on these directly, check for breakage:
 | `testcafe` | 3.7.2 | **removed** |
 | `inquirer-test` | 2.0.1 | **removed** |
 | `joi` | 18 | **removed** — use `zod` |
+| `resq` | 1.11 | **removed** — `react`/`vue` locators dropped; use ARIA locators |
 | `zod` | — | added (^4) — schema validation in `JSONResponse` |
 | `tsx` | — | added as optional peer |
 | `@modelcontextprotocol/sdk` | — | added |

package/docs/plugins/aiTrace.md

@@ -0,0 +1,49 @@
+---
+permalink: /plugins/aiTrace
+editLink: false
+sidebar: auto
+title: aiTrace
+---
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## aiTrace
+
+Generates AI-friendly trace files for debugging with AI agents.
+This plugin creates a markdown file with test execution logs and links to all artifacts
+(screenshots, HTML, ARIA snapshots, browser logs, HTTP requests) for each step.
+
+#### Configuration
+
+```js
+"plugins": {
+   "aiTrace": {
+     "enabled": true
+   }
+ }
+```
+
+Possible config options:
+
+*   `deleteSuccessful`: delete traces for successfully executed tests. Default: false.
+*   `fullPageScreenshots`: should full page screenshots be used. Default: false.
+*   `output`: a directory where traces should be stored. Default: `output`.
+*   `captureHTML`: capture HTML for each step. Default: true.
+*   `captureARIA`: capture ARIA snapshot for each step. Default: true.
+*   `captureBrowserLogs`: capture browser console logs. Default: true.
+*   `captureHTTP`: capture HTTP requests (requires `trace` or `recordHar` enabled in helper config). Default: true.
+*   `captureDebugOutput`: capture CodeceptJS debug output. Default: true.
+*   `ignoreSteps`: steps to ignore in trace. Array of RegExps is expected.
+*   `on`: trigger mode — `step` (default), `fail`, `test`, `file`, `url`.
+
+#### `on=` modes
+
+*   **step** — persist every step (default)
+*   **fail** — persist only the failed step
+*   **test** — persist only the last step of each test
+*   **file** — persist steps from `path=...[;line=...]`
+*   **url** — persist when the current URL matches `pattern=...`
+
+### Parameters
+
+*   `config` **any**  

package/docs/plugins/analyze.md

@@ -0,0 +1,66 @@
+---
+permalink: /plugins/analyze
+editLink: false
+sidebar: auto
+title: analyze
+---
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## analyze
+
+Uses AI to analyze test failures and provide insights
+
+This plugin analyzes failed tests using AI to provide detailed explanations and group similar failures.
+When enabled with --ai flag, it generates reports after test execution.
+
+#### Usage
+
+```js
+// in codecept.conf.js
+exports.config = {
+  plugins: {
+    analyze: {
+      enabled: true,
+      clusterize: 5,
+      analyze: 2,
+      vision: false
+    }
+  }
+}
+```
+
+#### Configuration
+
+*   `clusterize` (number) - minimum number of failures to trigger clustering analysis. Default: 5
+*   `analyze` (number) - maximum number of individual test failures to analyze in detail. Default: 2
+*   `vision` (boolean) - enables visual analysis of test screenshots. Default: false
+*   `categories` (array) - list of failure categories for classification. Defaults to:
+    *   Browser connection error / browser crash
+    *   Network errors (server error, timeout, etc)
+    *   HTML / page elements (not found, not visible, etc)
+    *   Navigation errors (404, etc)
+    *   Code errors (syntax error, JS errors, etc)
+    *   Library & framework errors
+    *   Data errors (password incorrect, invalid format, etc)
+    *   Assertion failures
+    *   Other errors
+*   `prompts` (object) - customize AI prompts for analysis
+    *   `clusterize` - prompt for clustering analysis
+    *   `analyze` - prompt for individual test analysis
+
+#### Features
+
+*   Groups similar failures when number of failures >= clusterize value
+*   Provides detailed analysis of individual failures
+*   Analyzes screenshots if vision=true and screenshots are available
+*   Classifies failures into predefined categories
+*   Suggests possible causes and solutions
+
+### Parameters
+
+*   `config` **[Object][1]** Plugin configuration 
+
+Returns **void**&#x20;
+
+[1]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object

package/docs/plugins/auth.md

@@ -0,0 +1,241 @@
+---
+permalink: /plugins/auth
+editLink: false
+sidebar: auto
+title: auth
+---
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## auth
+
+Logs user in for the first test and reuses session for next tests.
+Works by saving cookies into memory or file.
+If a session expires automatically logs in again.
+
+> For better development experience cookies can be saved into file, so a session can be reused while writing tests.
+
+#### Usage
+
+1.  Enable this plugin and configure as described below
+2.  Define user session names (example: `user`, `editor`, `admin`, etc).
+3.  Define how users are logged in and how to check that user is logged in
+4.  Use `login` object inside your tests to log in:
+
+```js
+// inside a test file
+// use login to inject auto-login function
+Feature('Login');
+
+Before(({ login }) => {
+   login('user'); // login using user session
+});
+
+// Alternatively log in for one scenario.
+Scenario('log me in', ( { I, login } ) => {
+   login('admin');
+   I.see('I am logged in');
+});
+```
+
+#### Configuration
+
+*   `saveToFile` (default: false) - save cookies to file. Allows to reuse session between execution.
+*   `inject` (default: `login`) - name of the login function to use
+*   `users` - an array containing different session names and functions to:
+    *   `login` - sign in into the system
+    *   `check` - check that user is logged in
+    *   `fetch` - to get current cookies (by default `I.grabCookie()`)
+    *   `restore` - to set cookies (by default `I.amOnPage('/'); I.setCookie(cookie)`)
+
+#### How It Works
+
+1.  `restore` method is executed. It should open a page and set credentials.
+2.  `check` method is executed. It should reload a page (so cookies are applied) and check that this page belongs to logged-in user. When you pass the second args `session`, you could perform the validation using passed session.
+3.  If `restore` and `check` were not successful, `login` is executed
+4.  `login` should fill in login form
+5.  After successful login, `fetch` is executed to save cookies into memory or file.
+
+#### Example: Simple login
+
+```js
+auth: {
+  enabled: true,
+  saveToFile: true,
+  inject: 'login',
+  users: {
+    admin: {
+      // loginAdmin function is defined in `steps_file.js`
+      login: (I) => I.loginAdmin(),
+      // if we see `Admin` on page, we assume we are logged in
+      check: (I) => {
+         I.amOnPage('/');
+         I.see('Admin');
+      }
+    }
+  }
+}
+```
+
+#### Example: Multiple users
+
+```js
+auth: {
+  enabled: true,
+  saveToFile: true,
+  inject: 'loginAs', // use `loginAs` instead of login
+  users: {
+    user: {
+      login: (I) => {
+         I.amOnPage('/login');
+         I.fillField('email', 'user@site.com');
+         I.fillField('password', '123456');
+         I.click('Login');
+      },
+      check: (I) => {
+         I.amOnPage('/');
+         I.see('User', '.navbar');
+      },
+    },
+    admin: {
+      login: (I) => {
+         I.amOnPage('/login');
+         I.fillField('email', 'admin@site.com');
+         I.fillField('password', '123456');
+         I.click('Login');
+      },
+      check: (I) => {
+         I.amOnPage('/');
+         I.see('Admin', '.navbar');
+      },
+    },
+  }
+}
+```
+
+#### Example: Keep cookies between tests
+
+If you decide to keep cookies between tests you don't need to save/retrieve cookies between tests.
+But you need to login once work until session expires.
+For this case, disable `fetch` and `restore` methods.
+
+```js
+helpers: {
+   WebDriver: {
+     // config goes here
+     keepCookies: true; // keep cookies for all tests
+   }
+},
+plugins: {
+   auth: {
+     users: {
+       admin: {
+         login: (I) => {
+           I.amOnPage('/login');
+           I.fillField('email', 'admin@site.com');
+           I.fillField('password', '123456');
+           I.click('Login');
+         },
+         check: (I) => {
+           I.amOnPage('/dashboard');
+           I.see('Admin', '.navbar');
+         },
+         fetch: () => {}, // empty function
+         restore: () => {}, // empty funciton
+       }
+    }
+  }
+}
+```
+
+#### Example: Getting sessions from local storage
+
+If your session is stored in local storage instead of cookies you still can obtain sessions.
+
+```js
+plugins: {
+   auth: {
+    admin: {
+      login: (I) => I.loginAsAdmin(),
+      check: (I) => I.see('Admin', '.navbar'),
+      fetch: (I) => {
+        return I.executeScript(() => localStorage.getItem('session_id'));
+      },
+      restore: (I, session) => {
+        I.amOnPage('/');
+        I.executeScript((session) => localStorage.setItem('session_id', session), session);
+      },
+    }
+  }
+}
+```
+
+#### Tips: Using async function in the auth
+
+If you use async functions in the auth plugin, login function should be used with `await` keyword.
+
+```js
+auth: {
+  enabled: true,
+  saveToFile: true,
+  inject: 'login',
+  users: {
+    admin: {
+      login: async (I) => {  // If you use async function in the auth plugin
+         const phrase = await I.grabTextFrom('#phrase')
+         I.fillField('username', 'admin'),
+         I.fillField('password', 'password')
+         I.fillField('phrase', phrase)
+      },
+      check: (I) => {
+         I.amOnPage('/');
+         I.see('Admin');
+      },
+    }
+  }
+}
+```
+
+```js
+Scenario('login', async ( {I, login} ) => {
+  await login('admin') // you should use `await`
+})
+```
+
+#### Tips: Using session to validate user
+
+Instead of asserting on page elements for the current user in `check`, you can use the `session` you saved in `fetch`
+
+```js
+auth: {
+  enabled: true,
+  saveToFile: true,
+  inject: 'login',
+  users: {
+    admin: {
+      login: async (I) => {  // If you use async function in the auth plugin
+         const phrase = await I.grabTextFrom('#phrase')
+         I.fillField('username', 'admin'),
+         I.fillField('password', 'password')
+         I.fillField('phrase', phrase)
+      },
+      check: (I, session) => {
+         // Throwing an error in `check` will make CodeceptJS perform the login step for the user
+         if (session.profile.email !== the.email.you.expect@some-mail.com) {
+              throw new Error ('Wrong user signed in');
+        }
+      },
+    }
+  }
+}
+```
+
+```js
+Scenario('login', async ( {I, login} ) => {
+  await login('admin') // you should use `await`
+})
+```
+
+### Parameters
+
+*   `config` &#x20;

package/docs/plugins/autoDelay.md

@@ -0,0 +1,48 @@
+---
+permalink: /plugins/autoDelay
+editLink: false
+sidebar: auto
+title: autoDelay
+---
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## autoDelay
+
+Sometimes it takes some time for a page to respond to user's actions.
+Depending on app's performance this can be either slow or fast.
+
+For instance, if you click a button and nothing happens - probably JS event is not attached to this button yet
+Also, if you fill field and input validation doesn't accept your input - maybe because you typed value too fast.
+
+This plugin allows to slow down tests execution when a test running too fast.
+It puts a tiny delay for before and after action commands.
+
+Commands affected (by default):
+
+*   `click`
+*   `fillField`
+*   `checkOption`
+*   `pressKey`
+*   `doubleClick`
+*   `rightClick`
+
+#### Configuration
+
+```js
+plugins: {
+   autoDelay: {
+     enabled: true
+   }
+}
+```
+
+Possible config options:
+
+*   `methods`: list of affected commands. Can be overridden
+*   `delayBefore`: put a delay before a command. 100ms by default
+*   `delayAfter`: put a delay after a command. 200ms by default
+
+### Parameters
+
+*   `config` &#x20;

package/docs/plugins/browser.md

@@ -0,0 +1,41 @@
+---
+permalink: /plugins/browser
+editLink: false
+sidebar: auto
+title: browser
+---
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## browser
+
+Overrides browser helper config from the command line. Works for all browser helpers
+(Playwright, Puppeteer, WebDriver, Appium) without touching `codecept.conf`.
+
+Enable it via `-p` option with one or more colon-chained args:
+
+    npx codeceptjs run -p browser:show
+    npx codeceptjs run -p browser:hide
+    npx codeceptjs run -p browser:browser=firefox
+    npx codeceptjs run -p browser:windowSize=1024x768:video=false
+    npx codeceptjs run -p browser:hide:browser=webkit:windowSize=800x600
+
+#### Args
+
+*   **show** — force visible browser
+*   **hide** — force headless (also injects `--headless` into WebDriver chrome/firefox capability args)
+*   **`<key>=<value>`** — set `helpers.<eachBrowserHelper>.<key> = <value>`. Three keys
+    get per-helper translation via `setBrowserConfig`:
+    *   `browser=<name>` — Puppeteer receives `product`, Playwright receives `browser`
+    *   `windowSize=WxH` — also adds `--window-size=W,H` chromium/chrome args
+    *   `show=true|false` — toggles `show` on Playwright/Puppeteer; injects/strips
+        `--headless` in WebDriver chrome/firefox capability args
+
+Values stay as strings. `true` / `false` are coerced to booleans.
+
+Requires `@codeceptjs/configure` to be installed; if missing, the plugin
+logs a hint and skips the override.
+
+### Parameters
+
+*   `config`