codeceptjs 4.2.1 → 4.2.2

package/docs/installation.md

@@ -115,6 +115,22 @@ export const config = {
 
 See [Alternative Browser Engines](/alternative-browsers) for running an existing Playwright suite on Lightpanda.
 
+## Moli (experimental)
+
+Moli is a headless browser for automation that runs your app's JavaScript in V8 and skips layout and painting. Install it following the [official instructions](https://github.com/lexmount/moli#direct-installation), then enable the helper:
+
+```js
+export const config = {
+  helpers: {
+    Moli: {
+      url: 'http://localhost:3000',
+    },
+  },
+}
+```
+
+See [Alternative Browser Engines](/alternative-browsers) for running an existing Playwright suite on Moli.
+
 ## Appium (mobile)
 
 Native iOS and Android testing. Appium speaks the WebDriver protocol, so CodeceptJS drives it through `webdriverio`:
@@ -134,6 +150,8 @@ appium
 
 You'll also need the Android SDK and an emulator or device, or Xcode and a simulator or device (or a device-cloud account). Set `platformName`, `deviceName`, and `app` in the helper config — see [Mobile Testing](/mobile).
 
+For mobile tests without an Appium server, see the experimental [Mobilewright helper](/mobilewright): it drives devices directly via adb/mobilecli and reads the accessibility tree.
+
 ## API testing
 
 REST and GraphQL tests need no browser — the helpers are built in (they use `axios`, already a dependency):

package/docs/lint.md

@@ -0,0 +1,111 @@
+---
+permalink: /lint
+title: Linting
+---
+
+# Linting
+
+CodeceptJS tests have well-known smell patterns: fixed sleeps instead of waits, `if` branches that make tests non-deterministic, raw `fetch()` calls that bypass test steps and reports, plain-text passwords printed into logs, missing `await` on grabbers, and leftover `pause()` or `.only` from debugging sessions.
+
+[`@codeceptjs/lint`](https://github.com/codeceptjs/lint) catches all of them statically. It reads tests, page objects and helpers as an AST — CodeceptJS itself doesn't need to be installed and no browser is started.
+
+## Usage
+
+```bash
+npx @codeceptjs/lint                          # files from codecept.conf.js in the current directory
+npx @codeceptjs/lint tests/ pages/login.js    # explicit paths
+npx @codeceptjs/lint -r no-pause -r no-only   # only these rules (or --rules no-pause,no-only)
+npx @codeceptjs/lint rules                    # list all rules
+npx @codeceptjs/lint --json                   # findings as JSON
+npx @codeceptjs/lint -c e2e/codecept.conf.js  # config in another directory
+```
+
+Each finding is printed on one line:
+
+```
+checkout_test.js:4:3  error  no-fixed-wait  I.wait() sleeps unconditionally. Wait for a condition: I.waitForElement / I.waitForText / I.see
+```
+
+Exit codes: `0` — no errors (warnings allowed), `1` — errors found, `2` — bad input or a file that can't be parsed.
+
+Without paths, the linter reads `codecept.conf.js` (or `.ts`, `.cjs`, `.mjs`) and lints files matched by `tests`, local files from `include` (page objects, steps file) and helpers loaded with `require`.
+
+## Rules
+
+| Rule | Default | Detects |
+| --- | --- | --- |
+| `no-fixed-wait` | error | `I.wait(5)` with a number. Use `I.waitForElement`, `I.waitForText`, `I.see` |
+| `no-sleep` | error | `setTimeout`, including `window.setTimeout`, `await new Promise(r => setTimeout(r, ms))` and `timers/promises`, outside helpers |
+| `no-if-in-test` | error | `if` inside a Scenario or hook. Use `tryTo()` from `codeceptjs/effects` |
+| `no-fetch` | error | `fetch()` outside helpers. Use the REST helper: `I.sendGetRequest`, `I.sendPostRequest` |
+| `no-console` | warn | `console.*` outside helpers. Use `I.say()` |
+| `no-only` | error on CI, warn locally | `Scenario.only`, `Feature.only`, `Data(...).only` |
+| `no-pause` | error on CI, warn locally | `pause()` |
+| `no-skip` | warn | `Scenario.skip`, `Feature.skip`, `xScenario`, `xFeature` |
+| `secret-credentials` | error | `I.fillField` on a password, token, secret or API key field, or such a `process.env.*` passed to `I.*`, without `secret()` |
+| `await-grab` | error | `I.grab*()` assigned or used without `await` |
+| `no-actor-in-helper` | error | `I` inside a class extending `Helper`. Use `this.helpers[...]` |
+| `raw-browser-in-test` | warn | `I.use*To`, `I.executeScript` in a Scenario. Move it into a helper or page object |
+
+"On CI" means the `CI` environment variable is set, which every CI provider does. Locally `pause()` and `.only` stay warnings, so debugging stubs don't fail the lint.
+
+## Configuration
+
+Set rule levels in a `lint` section of `codecept.conf.js`:
+
+```js
+export const config = {
+  tests: './*_test.js',
+  lint: {
+    rules: { 'no-if-in-test': 'warn', 'raw-browser-in-test': 'off' },
+  },
+}
+```
+
+Levels are `error`, `warn` or `off`.
+
+To allow a single case, suppress it inline — the rule id is required:
+
+```js
+I.wait(1) // codeceptjs-lint-disable-line no-fixed-wait
+
+// codeceptjs-lint-disable-next-line no-fixed-wait
+I.wait(1)
+```
+
+TypeScript is read with Node's type stripping (Node 22.13+). Files that use `enum` or `namespace` are reported as parse errors. A TypeScript config that imports `.js` paths of `.ts` files (the tsx/esbuild convention) can't be loaded by plain Node; if the project has `tsx` installed, the linter registers its loader automatically, otherwise pass paths explicitly.
+
+## CI
+
+```yaml
+- run: npx @codeceptjs/lint
+- run: npx codeceptjs run
+```
+
+## Blocking Bad Edits by an AI Agent
+
+The linter can check an agent's edit before it lands. Add a `PreToolUse` hook to `.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [{ "type": "command", "command": "npx @codeceptjs/lint --hook claude" }]
+      }
+    ]
+  }
+}
+```
+
+The hook checks only files the config lints. It builds the file as it would look after the edit, and blocks the edit only when it adds a new error. Errors already in the file and warnings never block, so an agent can still add a `pause()` stub or touch a legacy test. If the hook fails, the edit is allowed. See [Agentic Testing](/agents/) for the full agent toolkit.
+
+## API
+
+```js
+import Linter from '@codeceptjs/lint'
+
+const linter = await Linter.load('codecept.conf.js')
+for (const file of linter.files()) console.log(linter.lintFile(file))
+```

package/docs/mobile.md

@@ -231,6 +231,7 @@ Accessibility id is recommended to use for locating element, as it rarely change
 * For [React Native for Android see our special guide](mobile-react-native-locators.md).
 
 > If you test React Native application, consider using [Detox helper](/detox) for faster tests.
+> If you want mobile tests without an Appium server at all, consider the experimental [Mobilewright helper](/mobilewright).
 
 Add `~` prefix to search for element by its accessibility id:
 

package/docs/mobilewright.md

@@ -0,0 +1,166 @@
+---
+permalink: /mobilewright
+title: Mobile Testing with Mobilewright
+---
+
+> Warning! Mobilewright support in CodeceptJS is experimental. Please try it and help us to test it and improve it. [See Mobilewright helper repository](https://github.com/codeceptjs/mobilewright-helper).
+
+[Appium](/mobile) is the default choice for mobile testing with CodeceptJS, but it requires a running Appium server and slow UI-dump based automation. [Mobilewright](https://mobilewright.dev) takes a different approach: it talks to simulators, emulators and real devices directly via adb (Android) and mobilecli (iOS), and reads the accessibility tree instead of taking UI snapshots.
+
+**Pros** (vs Appium):
+
+* no Appium server, no WebDriver — a device and `adb` is all you need
+* fast startup: a full suite of 4 scenarios runs in about a minute, ~7-10s per test including app installation
+* Playwright-like locators: `{ role: 'button', name: 'Sign In' }`, test ids, accessibility labels, and human-style "label next to the field" matching
+* same locator conventions as the Appium helper, so most tests move between the two helpers unchanged
+* interactive [pause](/basics#pause), auto-retries and other CodeceptJS features work out of the box
+
+**Cons**:
+
+* experimental (v0.1.x), the API may change
+* no XPath or CSS locators — only accessibility-based ones
+* text on screen ≠ text in the accessibility tree: some visible messages can't be asserted by text (common for React Native error labels)
+* iOS + React Native: taps may not reach RN controls (known mobilecli issue); Android works
+
+CodeceptJS allows you to try different options and choose the one which works best for you. If Mobilewright covers your app, tests run dramatically faster than with Appium.
+
+## Installation
+
+Requirements: Node.js 22.12+, CodeceptJS 4, a booted simulator or emulator, or a connected device.
+
+```
+npm i @codeceptjs/mobilewright --save-dev
+```
+
+Check your environment with one command:
+
+```
+npx mobilewright doctor
+```
+
+It reports Node.js, mobilecli versions, connected devices and common misconfigurations. List available devices:
+
+```
+npx mobilewright devices
+```
+
+## Configuration
+
+```js
+exports.config = {
+  tests: './*_test.js',
+  output: './output',
+  helpers: {
+    Mobilewright: {
+      require: '@codeceptjs/mobilewright',
+      platform: 'android',                      // or 'ios'
+      app: 'com.saucelabs.mydemoapp.rn',        // package name (Android) or bundle id (iOS)
+      installApps: './MyDemoApp.apk',           // installed before tests
+      actionTimeout: 10000,
+      waitForTimeout: 10000,
+      animations: 'off',                        // disables system animations on device
+    },
+  },
+  plugins: {
+    screenshot: { enabled: true },
+    retryFailedStep: { enabled: true },
+  },
+}
+```
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `platform` | required | `ios` or `android` |
+| `app` | — | bundle id (iOS) or package name (Android) of the app under test |
+| `installApps` | — | path or list of paths to `.apk`, `.app` or `.ipa` files installed before tests |
+| `deviceId` | first booted device | UDID or serial of the device |
+| `deviceName` | — | string or RegExp matched against device names |
+| `url` | — | URL of a running mobilecli server; when set, the helper does not start one |
+| `restart` | `'app'` | `'app'` relaunches the app before every test, `'session'` launches it once, `false` never launches it |
+| `animations` | unchanged | `'off'` disables system animations |
+
+The helper starts and stops a mobilecli server automatically; with `restart: 'app'` (default) the app is relaunched before every test, so no `Before()` hook is needed.
+
+## Locators
+
+Mobilewright reads the accessibility tree. Locators follow the [Appium helper](/mobile) conventions:
+
+| Locator | Finds |
+| --- | --- |
+| `'~login'` | test id, then accessibility label |
+| `'#login'` | test id; on Android also matches `com.app:id/login` |
+| `{ role: 'button', name: 'Sign In' }` | element by role and accessible name |
+| `{ label }`, `{ text }`, `{ placeholder }`, `{ testId }` | the matching attribute; `text` accepts a RegExp |
+| `{ android: '#a', ios: '~b' }` | a different locator per platform |
+
+For `fillField` a plain name matches a text field by its accessibility label, its placeholder, or **the text label displayed next to the field** — the way a human reads a form. XPath and CSS are not supported and fail with an error suggesting a supported locator.
+
+## A Test
+
+A test against the [Sauce Labs My Demo App](https://github.com/saucelabs/my-demo-app-rn) (React Native):
+
+```js
+import { secret } from 'codeceptjs'
+
+Feature('Sauce Labs Store')
+
+Scenario('Open a product and add it to cart', ({ I }) => {
+  I.waitForText('Products', 30)
+  I.click('Sauce Labs Backpack')               // click by visible text
+  I.waitForElement('~Add To Cart button', 15)
+  I.click('~Add To Cart button')               // ~ = accessibility id / label
+  I.see('1', '~cart badge')
+  I.saveElementScreenshot('~cart badge', 'cart-badge.png')  // element screenshot
+})
+
+Scenario('Deep link and fill fields by label', ({ I }) => {
+  I.waitForText('Products', 30)
+  I.amOnPage('mydemoapprn://login')            // deep link
+  I.fillField('Username', 'bob@example.com')   // found by the label next to the field
+  I.fillField('Password', secret('10203040'))  // secret() keeps the password out of logs
+  I.click('~Login button')
+  I.waitForText('Products', 15)
+})
+
+Scenario('Rotate the screen', ({ I }) => {
+  I.setOrientation('LANDSCAPE')
+  I.seeOrientationIs('LANDSCAPE')
+  I.setOrientation('PORTRAIT')
+})
+```
+
+Run tests as usual:
+
+```
+npx codeceptjs run --steps
+```
+
+## Debugging
+
+* [Interactive pause](/basics#pause) works: drop `pause()` into a test and try steps and locators by hand.
+* `DEBUG='mw:*' npx codeceptjs run` prints the whole device dialogue over WebSocket.
+* `await I.grabSource()` returns the accessibility tree as JSON — the main tool for debugging locators: it shows every label, testId and element type on the current screen.
+* `npx mobilewright screenshot -o screen.png` takes a device screenshot without any test.
+* `npx mobilewright codegen` records taps on the device and generates a test; `npx mobilewright inspect` opens a live element inspector in the browser.
+
+## Appium vs Mobilewright
+
+| | Appium | Mobilewright |
+| --- | --- | --- |
+| Server | Appium server + WebDriver required | none (adb / mobilecli direct) |
+| Automation basis | UI dumps | accessibility tree |
+| Speed | slow startup, minutes per suite | ~7-10s per test incl. app install |
+| Locators | XPath, CSS, accessibility ids | accessibility ids, roles, labels, text |
+| App instrumentation | none needed | none needed |
+| Maturity | industry standard, huge ecosystem | experimental (v0.1.x) |
+| Cloud (SauceLabs, BrowserStack) | yes | not yet |
+
+Both helpers share locator conventions, so most tests move between them with little change — start with Mobilewright for fast local runs and keep an Appium job for cloud testing and XPath-heavy suites.
+
+## Known Pitfalls
+
+1. **Text on screen ≠ text in the accessibility tree.** Error messages may be visible on a screenshot but missing from the tree — text assertions on such elements fail. Check with `I.grabSource()` before asserting by text.
+2. **`clearField` on React Native fields is unstable**; the helper falls back to backspaces, but masked values (passwords) report the wrong length. Filling a password field twice is a flakiness candidate.
+3. **React Native components may not expose testIds** — on such apps `#id` locators don't match; `~` locators fall back to labels and usually work.
+4. **App state persists between tests**: `restart` relaunches the app but does not clear its data.
+5. **iOS + React Native**: taps may not reach RN controls (known mobilecli issue); Android works.

package/lib/command/run-multiple.js

@@ -75,10 +75,10 @@ export default async function (selectedRuns, options) {
   if (options.config) {
     // update paths to config path
     if (config.tests) {
-      config.tests = path.resolve(testRoot, config.tests)
+      config.tests = resolvePatterns(testRoot, config.tests)
     }
     if (config.gherkin && config.gherkin.features) {
-      config.gherkin.features = path.resolve(testRoot, config.gherkin.features)
+      config.gherkin.features = resolvePatterns(testRoot, config.gherkin.features)
     }
   }
 
@@ -117,6 +117,11 @@ export default async function (selectedRuns, options) {
   })
 }
 
+export function resolvePatterns(testRoot, patterns) {
+  const resolve = pattern => path.resolve(testRoot, pattern).split(path.sep).join(path.posix.sep)
+  return Array.isArray(patterns) ? patterns.map(resolve) : resolve(patterns)
+}
+
 function executeRun(runName, runConfig) {
   // clone config
   let overriddenConfig = { ...config }

package/lib/container.js

@@ -61,7 +61,7 @@ class Container {
    *
    */
   static get STANDARD_ACTING_HELPERS() {
-    return ['Playwright', 'WebDriver', 'Puppeteer', 'Appium', 'Obscura', 'Lightpanda']
+    return ['Playwright', 'WebDriver', 'Puppeteer', 'Appium', 'Obscura', 'Lightpanda', 'Moli']
   }
   /**
    * Create container with all required helpers and support objects

package/lib/helper/Decision.js

@@ -244,7 +244,7 @@ class Decision extends Helper {
 
   _actingHelper() {
     const helper = pickActingHelper(Container.helpers())
-    if (!helper) throw new Error('Decision helper requires a web helper: Playwright, Puppeteer, WebDriver, Obscura or Lightpanda')
+    if (!helper) throw new Error('Decision helper requires a web helper: Playwright, Puppeteer, WebDriver, Obscura, Lightpanda or Moli')
     return helper
   }
 }

package/lib/helper/Moli.js

@@ -0,0 +1,125 @@
+import CDPBrowser from './CDPBrowser.js'
+
+/**
+ * ## Configuration
+ *
+ * This helper should be configured in codecept.conf.js
+ *
+ * @typedef MoliConfig
+ * @type {object}
+ * @prop {string} [endpoint] - 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).
+ * @prop {string} [binaryPath] - path to the `moli` executable, used in SELF-MANAGED mode
+ * (`endpoint` unset). Checked before `MOLI_PATH` and `PATH`.
+ * @prop {number} [port] - port `moli 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.
+ * @prop {number} [serverStartTimeout=15000] - milliseconds to wait for a spawned `moli serve` to
+ * answer `/json/version` before `_connect` gives up.
+ */
+const config = {}
+
+/**
+ * Moli drives [Moli](https://github.com/lexmount/moli), an open-source headless browser written
+ * in Rust for automation, exposed over the Chrome DevTools Protocol. It runs real JavaScript in V8
+ * and computes styles with Servo's Stylo, but by default skips layout and painting: element boxes
+ * use deterministic placeholder geometry, so there are no screenshots and no coordinate input.
+ *
+ * This helper is a thin `CDPBrowser` subclass: it changes nothing about how locating or acting on
+ * elements works, it only pins the config presets Moli requires and manages the `moli serve`
+ * process lifecycle, the same way Playwright manages its own browser process.
+ *
+ * > Moli support is experimental. Pin the browser version in CI and keep a
+ * > Playwright/WebDriver job for browser-compatibility coverage.
+ *
+ * ## 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 `MOLI_PATH` environment variable, then `moli` on `PATH`. The helper
+ *   spawns `moli serve --host 127.0.0.1 --port <port>` (`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. `moli serve` started by hand). The helper
+ *   attaches to it and never kills it. If neither a binary nor a running server on :9222 can be
+ *   found, the helper throws a loud, actionable error.
+ *
+ * ## Install
+ *
+ * Follow the [official installation instructions](https://github.com/lexmount/moli#direct-installation),
+ * then put `moli` on your `PATH`, or point `binaryPath`/`MOLI_PATH` at it. The helper then
+ * launches and tears it down automatically.
+ *
+ * ## Config presets
+ *
+ * These are set automatically and only need overriding for unusual setups:
+ *
+ * | option | value | why |
+ * | --- | --- | --- |
+ * | `input` | `synthetic` | without layout Moli rejects coordinate mouse input, so `click` always takes the `forceClick` path |
+ * | `xpathPolyfill` | `auto` | probed per binary/page |
+ * | `capabilities.layout` | `real` | Moli computes real styles and gives displayed elements a non-empty placeholder box, which is enough for `seeElement` and the `waitForVisible` family; it is pinned because the runtime probe would also enable coordinate input |
+ * | `capabilities.screenshot` | `false` | screenshots require `moli serve --layout`, which this helper does not use: its layout is a snapshot that goes stale when the page changes |
+ *
+ * ## Limitations
+ *
+ * - No screenshots and no screencast: `saveScreenshot` and `saveElementScreenshot` do nothing (a debug message is printed).
+ * - No coordinate-based input (`clickXY`).
+ * - No frames or popups.
+ * - Uploaded files are sent as `application/octet-stream` regardless of their extension.
+ * - The default stylesheet does not color links: `a` computes `color: rgb(0, 0, 0)`.
+ *
+ * <!-- configuration -->
+ *
+ * ## Example
+ *
+ * ```js
+ * // inside codecept.conf.js — SELF-LAUNCH mode (recommended): the helper finds/starts/stops
+ * // moli serve on its own, on a free port. Ideal for run-workers: every worker gets its own
+ * // instance with no config.
+ * {
+ *   helpers: {
+ *     Moli: {
+ *       url: 'http://localhost',
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ```js
+ * // ATTACH mode — connect to a Moli instance you manage yourself (remote host, container, etc.)
+ * {
+ *   helpers: {
+ *     Moli: {
+ *       url: 'http://localhost',
+ *       endpoint: 'http://127.0.0.1:9222',
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ## Methods
+ */
+class Moli extends CDPBrowser {
+  /**
+   * @param {MoliConfig} config
+   */
+  constructor(config) {
+    super({
+      input: 'synthetic',
+      xpathPolyfill: 'auto',
+      ...config,
+      capabilities: { layout: 'real', screenshot: false, ...((config && config.capabilities) || {}) },
+    })
+    this._manageServer(config, {
+      name: 'moli',
+      envVar: 'MOLI_PATH',
+      args: port => ['serve', '--host', '127.0.0.1', '--port', String(port)],
+      releases: 'https://github.com/lexmount/moli/releases',
+    })
+  }
+}
+
+export default Moli

package/lib/helper/WebDriver.js

@@ -1079,7 +1079,6 @@ class WebDriver extends Helper {
    *
    */
   async click(locator, context = null) {
-    const clickMethod = this.browser.isMobile && this.browser.capabilities.platformName !== 'android' ? 'touchClick' : 'elementClick'
     const locateFn = prepareLocateFn.call(this, context)
 
     const res = await findClickable.call(this, locator, locateFn)
@@ -1090,7 +1089,7 @@ class WebDriver extends Helper {
     }
     const elem = selectElement(res, locator, this)
     highlightActiveElement.call(this, elem)
-    return this.browser[clickMethod](getElementId(elem))
+    return this.browser.elementClick(getElementId(elem))
   }
 
   /**
@@ -1390,7 +1389,6 @@ class WebDriver extends Helper {
    * {{> checkOption }}
    */
   async checkOption(field, context = null) {
-    const clickMethod = this.browser.isMobile && this.browser.capabilities.platformName !== 'android' ? 'touchClick' : 'elementClick'
     const locateFn = prepareLocateFn.call(this, context)
 
     const res = await findCheckable.call(this, field, locateFn)
@@ -1403,7 +1401,7 @@ class WebDriver extends Helper {
     const isSelected = await isElementChecked(this.browser, elementId)
 
     if (isSelected) return Promise.resolve(true)
-    return this.browser[clickMethod](elementId)
+    return this.browser.elementClick(elementId)
   }
 
   /**
@@ -1411,7 +1409,6 @@ class WebDriver extends Helper {
    * {{> uncheckOption }}
    */
   async uncheckOption(field, context = null) {
-    const clickMethod = this.browser.isMobile && this.browser.capabilities.platformName !== 'android' ? 'touchClick' : 'elementClick'
     const locateFn = prepareLocateFn.call(this, context)
 
     const res = await findCheckable.call(this, field, locateFn)
@@ -1424,7 +1421,7 @@ class WebDriver extends Helper {
     const isSelected = await isElementChecked(this.browser, elementId)
 
     if (!isSelected) return Promise.resolve(true)
-    return this.browser[clickMethod](elementId)
+    return this.browser.elementClick(elementId)
   }
 
   /**

package/lib/mocha/cli.js

@@ -1,5 +1,5 @@
-import mocha from 'mocha'
-const { reporters: { Base } } = mocha
+import { reporters } from 'mocha'
+const { Base } = reporters
 import ms from 'ms'
 import figures from 'figures'
 import { readFileSync } from 'fs'

package/lib/mocha/index.js

@@ -1,5 +1,4 @@
-import Suite from 'mocha/lib/suite.js'
-import Test from 'mocha/lib/test.js'
+import { Suite, Test } from 'mocha'
 import { BeforeHook, AfterHook, BeforeSuiteHook, AfterSuiteHook } from './hooks.js'
 
 export {

package/lib/mocha/suite.js

@@ -1,4 +1,4 @@
-import MochaSuite from 'mocha/lib/suite.js'
+import { Suite as MochaSuite } from 'mocha'
 /**
  * @typedef {import('mocha')} Mocha
  */

package/lib/mocha/test.js

@@ -1,5 +1,4 @@
-import Test from 'mocha/lib/test.js'
-import Suite from 'mocha/lib/suite.js'
+import { Suite, Test } from 'mocha'
 import { genTestId, serializeError, clearString, relativeDir } from '../utils.js'
 import Step from '../step/base.js'
 import { enhanceMochaSuite } from './suite.js'

package/lib/mocha/ui.js

@@ -7,7 +7,7 @@ import { createTest } from './test.js'
 import { createSuite } from './suite.js'
 import { HookConfig, AfterSuiteHook, AfterHook, BeforeSuiteHook, BeforeHook } from './hooks.js'
 import { initMochaGlobals } from '../globals.js'
-import common from 'mocha/lib/interfaces/common.js'
+import { createCommon } from 'mocha/lib/interfaces/common.js'
 import container from '../container.js'
 import store from '../store.js'
 
@@ -49,7 +49,7 @@ export default function (suite) {
   let afterEachHooksAreLoaded
 
   suite.on('pre-require', (context, file, mocha) => {
-    const cmn = common(suites, context, mocha)
+    const cmn = createCommon(suites, context, mocha)
 
     const addScenario = function (title, opts = {}, fn) {
       const suite = suites[0]
@@ -74,7 +74,7 @@ export default function (suite) {
     context.BeforeAll = cmn.before
     context.AfterAll = cmn.after
 
-    context.run = mocha.options.delay && common.runWithSuite(suite)
+    context.run = mocha.options.delay && cmn.runWithSuite(suite)
     /**
      * Describe a "suite" with the given `title`
      * and callback `fn` containing nested suites

package/lib/plugin/pause.js

@@ -109,7 +109,7 @@ function initUrlMode(pattern) {
   const helper = getBrowserHelper()
 
   if (!helper) {
-    output.error('pause:on=url requires a browser helper (Playwright, WebDriver, Puppeteer, Appium, Obscura, Lightpanda)')
+    output.error('pause:on=url requires a browser helper (Playwright, WebDriver, Puppeteer, Appium, Obscura, Lightpanda, Moli)')
     return
   }