@itmetsam/samurai-framework 0.9.0 → 0.12.0

package/README.md

@@ -19,6 +19,7 @@ test("Visitor can sign in", async ({ page, env, secrets }) => {
 - **Auto-waiting.** Actions wait until the element is attached, visible, stable, enabled and not covered. Assertions retry until they pass or time out.
 - **Semantic locators.** By role, label, text, test id, CSS or XPath, with ordered fallbacks.
 - **Environments and secrets.** One test file runs against `dev`, `staging` or `production`; secrets come from the environment or a `.env.<name>` file and are masked in logs and reports.
+- **Parallel runs.** Tests run side by side in worker processes (`--workers`, `workers` in the config; half the CPUs by default), and a flow's Parallel node runs its branches at the same time (see [Running tests and reports](docs/running-and-reports.md#parallel-runs)).
 - **Network control.** Mock, block or modify requests; wait for requests, responses and network idle; read response bodies.
 - **Flows.** Chain tests and groups into a graph with conditions, variables, waits and HTTP requests, and run it from the command line or CI (see [Flows](docs/flows.md)).
 - **Recorder building blocks.** Specs are parsed into steps and edited back with minimal diffs, and an engine records what a person does in the browser. A toolbar in the recorded page adds assertions, variables and secrets, waits, screenshots and pause (see [Steps and the recorder](docs/recorder.md)). The Electron app that ties them together lives in a separate repository (see the [roadmap](docs/roadmap.md)).
@@ -57,7 +58,7 @@ bun install
 
 ### 3. Write a test
 
-Tests live in the folder `srcDir` points to (`./src/tests` in `samurai.config.ts`) and end in `.spec.ts`. Create `src/tests/example.spec.ts`:
+Tests live in the folder `srcDir` points to (`./src/tests` in `samurai.config.ts`) and end in `.spec.ts`. This repository has one as `src/tests/example.spec.ts`:
 
 ```ts
 import { expect, test } from "../api.js";
@@ -82,7 +83,7 @@ import { defineConfig } from "./src/config/config.js";
 
 export default defineConfig({
   srcDir: "./src/tests",
-  browser: "firefox",
+  browsers: ["firefox"],
   timeout: 30000,
   environments: {
     staging: { baseURL: "https://staging.example.com" },
@@ -106,8 +107,6 @@ bun run dev --timeout 60000    # per-test timeout in ms; also --expect-timeout
 
 A browser window opens for each test and closes when the test ends (`--headless` hides it; on CI it is the default, see [Configuration](docs/configuration.md#headless)). Each test's result is printed as it finishes, followed by a summary, and the full report is written to `result/report.json`. The process exits with code 0 when every test passed, 1 otherwise and 2 for a usage or configuration error. Framework logs go to stderr and `logs/`.
 
-> `src/tests/index.spec.ts` is an example that submits a real contact form. Delete it or replace it before running everything.
-
 ### Flows (optional)
 
 A project can also keep flows in `flows/*.flow.json` (edited in the Samurai app) that chain tests and groups with conditions and variables. `samurai flow check` validates them and `samurai flow run <flow>` runs them, with a report in `result/flows/`. See [Flows](docs/flows.md).
@@ -142,7 +141,7 @@ Read it in a test as `secrets.TEST_PASSWORD`. Real environment variables win ove
 | [Contributing](docs/contributing.md)                         | Project layout, running the framework's own tests, conventions                                        |
 | [Roadmap](docs/roadmap.md)                                   | What is built and what is still open                                                                  |
 
-The [documentation index](docs/README.md) lists every guide and design note by topic. Design notes for every feature live in [`docs/superpowers/specs`](docs/superpowers/specs).
+The [documentation index](docs/README.md) lists every guide by topic.
 
 ## Scripts
 

package/dist/assert/assertion-error.d.ts

@@ -11,7 +11,7 @@ export interface AssertionErrorDetails {
     matcher: string;
     expected: unknown;
     actual: unknown;
-    /** XPath of the asserted locator, only for locator assertions */
+    /** Description of the asserted locator, only for locator assertions */
     locator?: string | undefined;
 }
 export declare class AssertionError extends Error {

package/dist/assert/expect.d.ts

@@ -1,54 +1,9 @@
 import Locator from "../locator/locator.js";
-/**
- * Returns the matcher names of locator assertions that were never awaited and are
- * still running or already failed, and stops tracking them. The runner calls this
- * after a test to detect a missing `await`.
- */
-export declare function takePendingAssertions(): string[];
-export interface LocatorAssertionOptions {
-    /** Time (ms) to keep retrying. Defaults to config `expect.timeout`, then 5000 */
-    timeout?: number;
-}
-export declare class ValueAssertions<T> {
-    private readonly actual;
-    private readonly negated;
-    constructor(actual: T, negated?: boolean);
-    /** Inverts the next matcher */
-    get not(): ValueAssertions<T>;
-    private assert;
-    private compare;
-    /** Strict identity (`Object.is`) */
-    toBe(expected: unknown): void;
-    /** Deep structural equality */
-    toEqual(expected: unknown): void;
-    toBeTruthy(): void;
-    toBeFalsy(): void;
-    /** Array includes `item`, or string contains substring `item` */
-    toContain(item: unknown): void;
-    /** String contains `pattern` (string) or matches it (RegExp) */
-    toMatch(pattern: string | RegExp): void;
-    toBeGreaterThan(expected: number | bigint): void;
-    toBeGreaterThanOrEqual(expected: number | bigint): void;
-    toBeLessThan(expected: number | bigint): void;
-    toBeLessThanOrEqual(expected: number | bigint): void;
-}
-export declare class LocatorAssertions {
-    private readonly locator;
-    private readonly negated;
-    constructor(locator: Locator, negated?: boolean);
-    /** Inverts the next matcher: it retries until the condition is false */
-    get not(): LocatorAssertions;
-    /** Re-reads the element until `check` passes or the timeout expires */
-    private assertEventually;
-    toBeVisible(options?: LocatorAssertionOptions): Promise<void>;
-    /** Trimmed text content equals `expected` (string) or matches it (RegExp) */
-    toHaveText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
-    /** Text content contains `expected` (string) or matches it (RegExp) */
-    toContainText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
-    toHaveValue(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
-    toHaveAttribute(name: string, expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
-    toHaveCount(expected: number, options?: LocatorAssertionOptions): Promise<void>;
-}
+import { LocatorAssertions } from "./locator-assertions.js";
+import { ValueAssertions } from "./value-assertions.js";
+export { takePendingAssertions } from "./pending-assertions.js";
+export { LocatorAssertions } from "./locator-assertions.js";
+export { ValueAssertions } from "./value-assertions.js";
 /** Auto-retrying assertions on a page element */
 export declare function expect(locator: Locator): LocatorAssertions;
 /** Synchronous assertions on a plain value */

package/dist/assert/expect.js

@@ -1,186 +1,9 @@
-import { isDeepStrictEqual } from "node:util";
-import { AssertionError } from "./assertion-error.js";
 import Locator from "../locator/locator.js";
-import { resolveTimeout, waitUntil, WaitTimeoutError } from "../wait/wait-until.js";
-/**
- * Locator assertions nobody has awaited yet that are still running or have failed,
- * mapped to their matcher name
- */
-const pendingAssertions = new Map();
-/**
- * Returns the matcher names of locator assertions that were never awaited and are
- * still running or already failed, and stops tracking them. The runner calls this
- * after a test to detect a missing `await`.
- */
-export function takePendingAssertions() {
-    const names = [...pendingAssertions.values()];
-    pendingAssertions.clear();
-    return names;
-}
-/**
- * Promise that stops being pending as soon as anyone subscribes to it. `await`,
- * `.catch`, `.finally`, `Promise.all` and `assert.rejects` all go through `then`
- * (`await` calls it because the constructor is not the native Promise).
- */
-class TrackedAssertion extends Promise {
-    /** Promises derived through `then` are plain promises */
-    static get [Symbol.species]() {
-        return Promise;
-    }
-    then(onfulfilled, onrejected) {
-        pendingAssertions.delete(this);
-        return super.then(onfulfilled, onrejected);
-    }
-}
-function track(matcher, assertion) {
-    const tracked = new TrackedAssertion((resolve, reject) => {
-        assertion.then(resolve, reject);
-    });
-    pendingAssertions.set(tracked, matcher);
-    // The native then does not count as awaiting: a pass stops tracking, a failure stays
-    // tracked. Handling the rejection keeps an un-awaited failure from being unhandled.
-    Promise.prototype.then.call(tracked, () => pendingAssertions.delete(tracked), () => { });
-    return tracked;
-}
-function matchesText(actual, expected, mode) {
-    // search() ignores lastIndex, so global regexps behave the same on every call
-    if (expected instanceof RegExp)
-        return actual.search(expected) !== -1;
-    return mode === "exact" ? actual === expected : actual.includes(expected);
-}
-function isNumeric(value) {
-    return typeof value === "number" || typeof value === "bigint";
-}
-export class ValueAssertions {
-    constructor(actual, negated = false) {
-        this.actual = actual;
-        this.negated = negated;
-    }
-    /** Inverts the next matcher */
-    get not() {
-        return new ValueAssertions(this.actual, !this.negated);
-    }
-    assert(pass, matcher, expected) {
-        if (pass !== this.negated)
-            return;
-        throw new AssertionError({
-            matcher: this.negated ? `not.${matcher}` : matcher,
-            expected,
-            actual: this.actual,
-        });
-    }
-    compare(matcher, expected, check) {
-        const actual = this.actual;
-        if (!isNumeric(actual) || !isNumeric(expected)) {
-            throw new TypeError(`${matcher} expects numbers, received ${typeof actual} and ${typeof expected}`);
-        }
-        this.assert(check(actual, expected), matcher, expected);
-    }
-    /** Strict identity (`Object.is`) */
-    toBe(expected) {
-        this.assert(Object.is(this.actual, expected), "toBe", expected);
-    }
-    /** Deep structural equality */
-    toEqual(expected) {
-        this.assert(isDeepStrictEqual(this.actual, expected), "toEqual", expected);
-    }
-    toBeTruthy() {
-        this.assert(Boolean(this.actual), "toBeTruthy", "truthy");
-    }
-    toBeFalsy() {
-        this.assert(!this.actual, "toBeFalsy", "falsy");
-    }
-    /** Array includes `item`, or string contains substring `item` */
-    toContain(item) {
-        const actual = this.actual;
-        if (typeof actual === "string") {
-            if (typeof item !== "string") {
-                throw new TypeError(`toContain on a string expects a string, received ${typeof item}`);
-            }
-            this.assert(actual.includes(item), "toContain", item);
-            return;
-        }
-        if (Array.isArray(actual)) {
-            this.assert(actual.includes(item), "toContain", item);
-            return;
-        }
-        throw new TypeError(`toContain expects an array or string, received ${typeof actual}`);
-    }
-    /** String contains `pattern` (string) or matches it (RegExp) */
-    toMatch(pattern) {
-        const actual = this.actual;
-        if (typeof actual !== "string") {
-            throw new TypeError(`toMatch expects a string, received ${typeof actual}`);
-        }
-        this.assert(matchesText(actual, pattern, "contains"), "toMatch", pattern);
-    }
-    toBeGreaterThan(expected) {
-        this.compare("toBeGreaterThan", expected, (a, b) => a > b);
-    }
-    toBeGreaterThanOrEqual(expected) {
-        this.compare("toBeGreaterThanOrEqual", expected, (a, b) => a >= b);
-    }
-    toBeLessThan(expected) {
-        this.compare("toBeLessThan", expected, (a, b) => a < b);
-    }
-    toBeLessThanOrEqual(expected) {
-        this.compare("toBeLessThanOrEqual", expected, (a, b) => a <= b);
-    }
-}
-export class LocatorAssertions {
-    constructor(locator, negated = false) {
-        this.locator = locator;
-        this.negated = negated;
-    }
-    /** Inverts the next matcher: it retries until the condition is false */
-    get not() {
-        return new LocatorAssertions(this.locator, !this.negated);
-    }
-    /** Re-reads the element until `check` passes or the timeout expires */
-    assertEventually(matcher, expected, read, check, options) {
-        const name = this.negated ? `not.${matcher}` : matcher;
-        return track(name, (async () => {
-            const timeout = await resolveTimeout(options?.timeout);
-            try {
-                await waitUntil(read, (actual) => check(actual) !== this.negated, { timeout });
-            }
-            catch (err) {
-                if (!(err instanceof WaitTimeoutError))
-                    throw err;
-                // Reads never resolve to undefined, so an undefined `last` means no read completed
-                if (err.last === undefined) {
-                    throw new Error(`expect(locator).${name}: could not read ${this.locator.selector} within ${timeout}ms`);
-                }
-                throw new AssertionError({
-                    matcher: name,
-                    expected,
-                    actual: err.last,
-                    locator: this.locator.selector,
-                });
-            }
-        })());
-    }
-    toBeVisible(options) {
-        return this.assertEventually("toBeVisible", true, () => this.locator.isVisible(), (visible) => visible, options);
-    }
-    /** Trimmed text content equals `expected` (string) or matches it (RegExp) */
-    toHaveText(expected, options) {
-        return this.assertEventually("toHaveText", expected, () => this.locator.textContent(), (text) => text !== null && matchesText(text, expected, "exact"), options);
-    }
-    /** Text content contains `expected` (string) or matches it (RegExp) */
-    toContainText(expected, options) {
-        return this.assertEventually("toContainText", expected, () => this.locator.textContent(), (text) => text !== null && matchesText(text, expected, "contains"), options);
-    }
-    toHaveValue(expected, options) {
-        return this.assertEventually("toHaveValue", expected, () => this.locator.inputValue(), (value) => value !== null && matchesText(value, expected, "exact"), options);
-    }
-    toHaveAttribute(name, expected, options) {
-        return this.assertEventually("toHaveAttribute", expected, () => this.locator.getAttribute(name), (value) => value !== null && matchesText(value, expected, "exact"), options);
-    }
-    toHaveCount(expected, options) {
-        return this.assertEventually("toHaveCount", expected, () => this.locator.count(), (count) => count === expected, options);
-    }
-}
+import { LocatorAssertions } from "./locator-assertions.js";
+import { ValueAssertions } from "./value-assertions.js";
+export { takePendingAssertions } from "./pending-assertions.js";
+export { LocatorAssertions } from "./locator-assertions.js";
+export { ValueAssertions } from "./value-assertions.js";
 export function expect(value) {
     return value instanceof Locator
         ? new LocatorAssertions(value)

package/dist/assert/locator-assertions.d.ts

@@ -0,0 +1,22 @@
+import type Locator from "../locator/locator.js";
+export interface LocatorAssertionOptions {
+    /** Time (ms) to keep retrying. Defaults to config `expect.timeout`, then 5000 */
+    timeout?: number;
+}
+export declare class LocatorAssertions {
+    private readonly locator;
+    private readonly negated;
+    constructor(locator: Locator, negated?: boolean);
+    /** Inverts the next matcher: it retries until the condition is false */
+    get not(): LocatorAssertions;
+    /** Re-reads the element until `check` passes or the timeout expires */
+    private assertEventually;
+    toBeVisible(options?: LocatorAssertionOptions): Promise<void>;
+    /** Trimmed text content equals `expected` (string) or matches it (RegExp) */
+    toHaveText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
+    /** Text content contains `expected` (string) or matches it (RegExp) */
+    toContainText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
+    toHaveValue(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
+    toHaveAttribute(name: string, expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
+    toHaveCount(expected: number, options?: LocatorAssertionOptions): Promise<void>;
+}

package/dist/assert/locator-assertions.js

@@ -0,0 +1,61 @@
+import { resolveTimeout } from "../config/timeouts.js";
+import { waitUntil, WaitTimeoutError } from "../wait/wait-until.js";
+import { AssertionError } from "./assertion-error.js";
+import { track } from "./pending-assertions.js";
+import { textCheck } from "./text-match.js";
+export class LocatorAssertions {
+    constructor(locator, negated = false) {
+        this.locator = locator;
+        this.negated = negated;
+    }
+    /** Inverts the next matcher: it retries until the condition is false */
+    get not() {
+        return new LocatorAssertions(this.locator, !this.negated);
+    }
+    /** Re-reads the element until `check` passes or the timeout expires */
+    assertEventually(matcher, expected, read, check, options) {
+        const name = this.negated ? `not.${matcher}` : matcher;
+        return track(name, (async () => {
+            const timeout = await resolveTimeout(options?.timeout);
+            try {
+                await waitUntil(read, (actual) => check(actual) !== this.negated, {
+                    timeout,
+                });
+            }
+            catch (err) {
+                if (!(err instanceof WaitTimeoutError))
+                    throw err;
+                // Reads never resolve to undefined, so an undefined `last` means no read completed
+                if (err.last === undefined) {
+                    throw new Error(`expect(locator).${name}: could not read ${this.locator.selector} within ${timeout}ms`);
+                }
+                throw new AssertionError({
+                    matcher: name,
+                    expected,
+                    actual: err.last,
+                    locator: this.locator.selector,
+                });
+            }
+        })());
+    }
+    toBeVisible(options) {
+        return this.assertEventually("toBeVisible", true, () => this.locator.isVisible(), (visible) => visible, options);
+    }
+    /** Trimmed text content equals `expected` (string) or matches it (RegExp) */
+    toHaveText(expected, options) {
+        return this.assertEventually("toHaveText", expected, () => this.locator.textContent(), textCheck(expected, "exact"), options);
+    }
+    /** Text content contains `expected` (string) or matches it (RegExp) */
+    toContainText(expected, options) {
+        return this.assertEventually("toContainText", expected, () => this.locator.textContent(), textCheck(expected, "contains"), options);
+    }
+    toHaveValue(expected, options) {
+        return this.assertEventually("toHaveValue", expected, () => this.locator.inputValue(), textCheck(expected, "exact"), options);
+    }
+    toHaveAttribute(name, expected, options) {
+        return this.assertEventually("toHaveAttribute", expected, () => this.locator.getAttribute(name), textCheck(expected, "exact"), options);
+    }
+    toHaveCount(expected, options) {
+        return this.assertEventually("toHaveCount", expected, () => this.locator.count(), (count) => count === expected, options);
+    }
+}

package/dist/assert/pending-assertions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the matcher names of locator assertions that were never awaited and are
+ * still running or already failed, and stops tracking them. The runner calls this
+ * after a test to detect a missing `await`.
+ */
+export declare function takePendingAssertions(): string[];
+export declare function track(matcher: string, assertion: Promise<void>): Promise<void>;

package/dist/assert/pending-assertions.js

@@ -0,0 +1,40 @@
+/**
+ * Locator assertions nobody has awaited yet that are still running or have failed,
+ * mapped to their matcher name
+ */
+const pendingAssertions = new Map();
+/**
+ * Returns the matcher names of locator assertions that were never awaited and are
+ * still running or already failed, and stops tracking them. The runner calls this
+ * after a test to detect a missing `await`.
+ */
+export function takePendingAssertions() {
+    const names = [...pendingAssertions.values()];
+    pendingAssertions.clear();
+    return names;
+}
+/**
+ * Promise that stops being pending as soon as anyone subscribes to it. `await`,
+ * `.catch`, `.finally`, `Promise.all` and `assert.rejects` all go through `then`
+ * (`await` calls it because the constructor is not the native Promise).
+ */
+class TrackedAssertion extends Promise {
+    /** Promises derived through `then` are plain promises */
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    then(onfulfilled, onrejected) {
+        pendingAssertions.delete(this);
+        return super.then(onfulfilled, onrejected);
+    }
+}
+export function track(matcher, assertion) {
+    const tracked = new TrackedAssertion((resolve, reject) => {
+        assertion.then(resolve, reject);
+    });
+    pendingAssertions.set(tracked, matcher);
+    // The native then does not count as awaiting: a pass stops tracking, a failure stays
+    // tracked. Handling the rejection keeps an un-awaited failure from being unhandled.
+    Promise.prototype.then.call(tracked, () => pendingAssertions.delete(tracked), () => { });
+    return tracked;
+}

package/dist/assert/text-match.d.ts

@@ -0,0 +1,4 @@
+/** Whether `actual` equals (`exact`) or contains (`contains`) `expected`, or matches it when it is a RegExp */
+export declare function matchesText(actual: string, expected: string | RegExp, mode: "exact" | "contains"): boolean;
+/** A check for a read that may find nothing (`null`): true when the text is there and matches */
+export declare function textCheck(expected: string | RegExp, mode: "exact" | "contains"): (actual: string | null) => boolean;

package/dist/assert/text-match.js

@@ -0,0 +1,11 @@
+/** Whether `actual` equals (`exact`) or contains (`contains`) `expected`, or matches it when it is a RegExp */
+export function matchesText(actual, expected, mode) {
+    // search() ignores lastIndex, so global regexps behave the same on every call
+    if (expected instanceof RegExp)
+        return actual.search(expected) !== -1;
+    return mode === "exact" ? actual === expected : actual.includes(expected);
+}
+/** A check for a read that may find nothing (`null`): true when the text is there and matches */
+export function textCheck(expected, mode) {
+    return (actual) => actual !== null && matchesText(actual, expected, mode);
+}

package/dist/assert/value-assertions.d.ts

@@ -0,0 +1,23 @@
+export declare class ValueAssertions<T> {
+    private readonly actual;
+    private readonly negated;
+    constructor(actual: T, negated?: boolean);
+    /** Inverts the next matcher */
+    get not(): ValueAssertions<T>;
+    private assert;
+    private compare;
+    /** Strict identity (`Object.is`) */
+    toBe(expected: unknown): void;
+    /** Deep structural equality */
+    toEqual(expected: unknown): void;
+    toBeTruthy(): void;
+    toBeFalsy(): void;
+    /** Array includes `item`, or string contains substring `item` */
+    toContain(item: unknown): void;
+    /** String contains `pattern` (string) or matches it (RegExp) */
+    toMatch(pattern: string | RegExp): void;
+    toBeGreaterThan(expected: number | bigint): void;
+    toBeGreaterThanOrEqual(expected: number | bigint): void;
+    toBeLessThan(expected: number | bigint): void;
+    toBeLessThanOrEqual(expected: number | bigint): void;
+}

package/dist/assert/value-assertions.js

@@ -0,0 +1,82 @@
+import { isDeepStrictEqual } from "node:util";
+import { AssertionError } from "./assertion-error.js";
+import { matchesText } from "./text-match.js";
+function isNumeric(value) {
+    return typeof value === "number" || typeof value === "bigint";
+}
+export class ValueAssertions {
+    constructor(actual, negated = false) {
+        this.actual = actual;
+        this.negated = negated;
+    }
+    /** Inverts the next matcher */
+    get not() {
+        return new ValueAssertions(this.actual, !this.negated);
+    }
+    assert(pass, matcher, expected) {
+        if (pass !== this.negated)
+            return;
+        throw new AssertionError({
+            matcher: this.negated ? `not.${matcher}` : matcher,
+            expected,
+            actual: this.actual,
+        });
+    }
+    compare(matcher, expected, check) {
+        const actual = this.actual;
+        if (!isNumeric(actual) || !isNumeric(expected)) {
+            throw new TypeError(`${matcher} expects numbers, received ${typeof actual} and ${typeof expected}`);
+        }
+        this.assert(check(actual, expected), matcher, expected);
+    }
+    /** Strict identity (`Object.is`) */
+    toBe(expected) {
+        this.assert(Object.is(this.actual, expected), "toBe", expected);
+    }
+    /** Deep structural equality */
+    toEqual(expected) {
+        this.assert(isDeepStrictEqual(this.actual, expected), "toEqual", expected);
+    }
+    toBeTruthy() {
+        this.assert(Boolean(this.actual), "toBeTruthy", "truthy");
+    }
+    toBeFalsy() {
+        this.assert(!this.actual, "toBeFalsy", "falsy");
+    }
+    /** Array includes `item`, or string contains substring `item` */
+    toContain(item) {
+        const actual = this.actual;
+        if (typeof actual === "string") {
+            if (typeof item !== "string") {
+                throw new TypeError(`toContain on a string expects a string, received ${typeof item}`);
+            }
+            this.assert(actual.includes(item), "toContain", item);
+            return;
+        }
+        if (Array.isArray(actual)) {
+            this.assert(actual.includes(item), "toContain", item);
+            return;
+        }
+        throw new TypeError(`toContain expects an array or string, received ${typeof actual}`);
+    }
+    /** String contains `pattern` (string) or matches it (RegExp) */
+    toMatch(pattern) {
+        const actual = this.actual;
+        if (typeof actual !== "string") {
+            throw new TypeError(`toMatch expects a string, received ${typeof actual}`);
+        }
+        this.assert(matchesText(actual, pattern, "contains"), "toMatch", pattern);
+    }
+    toBeGreaterThan(expected) {
+        this.compare("toBeGreaterThan", expected, (a, b) => a > b);
+    }
+    toBeGreaterThanOrEqual(expected) {
+        this.compare("toBeGreaterThanOrEqual", expected, (a, b) => a >= b);
+    }
+    toBeLessThan(expected) {
+        this.compare("toBeLessThan", expected, (a, b) => a < b);
+    }
+    toBeLessThanOrEqual(expected) {
+        this.compare("toBeLessThanOrEqual", expected, (a, b) => a <= b);
+    }
+}

package/dist/browser/browser-context.d.ts

@@ -2,7 +2,6 @@ import type { BiDiConnector } from "../transport/bidi-connection.js";
 import type { SameSite } from "../types/bidi-modules/network.js";
 import { type EmulationOptions } from "./emulation.js";
 import type Page from "./page.js";
-export type { SameSite } from "../types/bidi-modules/network.js";
 /** A cookie as `context.cookies()` returns it */
 export interface Cookie {
     name: string;

package/dist/browser/browser-context.js

@@ -21,7 +21,10 @@ export class BrowserContext {
     /** Opens a tab in this context */
     async newPage() {
         this.assertOpen();
-        return this.host.newPage({ type: "tab", ...(!this.isDefault && { userContext: this.id }) });
+        return this.host.newPage({
+            type: "tab",
+            ...(!this.isDefault && { userContext: this.id }),
+        });
     }
     /** The pages opened in this context that are still open */
     pages() {
@@ -38,7 +41,10 @@ export class BrowserContext {
         this.assertOpen();
         const prepared = cookies.map(toBiDiCookie);
         for (const cookie of prepared) {
-            await this.host.connector.send("storage.setCookie", { cookie, partition: this.partition() });
+            await this.host.connector.send("storage.setCookie", {
+                cookie,
+                partition: this.partition(),
+            });
         }
     }
     /** The cookies of this context, optionally only those matching `filter` */
@@ -84,11 +90,13 @@ export class BrowserContext {
     /** Removes the context; the browser closes its pages. The default context cannot be closed */
     async close() {
         if (this.isDefault)
-            throw new Error("cannot close the default context");
+            throw new Error("close(): cannot close the default context");
         if (this.isClosed)
             return;
         try {
-            await this.host.connector.send("browser.removeUserContext", { userContext: this.id });
+            await this.host.connector.send("browser.removeUserContext", {
+                userContext: this.id,
+            });
         }
         catch (err) {
             // Already gone: the goal is met
@@ -118,7 +126,7 @@ function toBiDiCookie(input) {
         secure ??= url.protocol === "https:";
     }
     if (domain === undefined)
-        throw new TypeError(`cookie "${input.name}" needs a domain or a url`);
+        throw new TypeError(`addCookies(): cookie "${input.name}" needs a domain or a url`);
     return {
         name: input.name,
         value: { type: "string", value: input.value },