@itmetsam/samurai-framework 0.9.0 → 0.12.0

package/dist/recorder/toolbar/types.d.ts

@@ -0,0 +1,70 @@
+import type { ElementHandle } from "../../script/element-handle.js";
+import type { LocatorCall, LocatorSpec } from "../../steps/model.js";
+import type { Observation } from "../normalise.js";
+import type { ActionReply, PickInfo, ToolbarMessage, ToolbarState } from "./protocol.js";
+/** What `inspect` found for a picked element: the reply, and the locator behind each Count choice */
+export interface Inspection {
+    info: PickInfo & {
+        ok: true;
+    };
+    /** `counts[i]` is the locator `info.counts[i]` describes */
+    counts: LocatorCall[];
+}
+/** Everything the controller does to the browser and the project; the recorder implements these */
+export interface ControllerDeps {
+    /** Sends the state to every loaded top-level document's toolbar */
+    push(state: ToolbarState): void;
+    reply(id: number, result: PickInfo | ActionReply): void;
+    currentUrl(): Promise<string>;
+    rank(target: ElementHandle, candidates: LocatorCall[]): Promise<LocatorSpec | undefined>;
+    inspect(target: ElementHandle, locator: LocatorSpec, candidates: LocatorCall[]): Promise<Inspection>;
+    /** Types into the field with capture muted */
+    type(locator: LocatorSpec, value: string): Promise<void>;
+    mute(): Promise<void>;
+    unmute(): Promise<void>;
+    addVariable(name: string, value: string): Promise<void>;
+    setSecret(name: string, value: string): Promise<void>;
+    /** A secret was written to the project (called before its value is typed) */
+    secretAdded(name: string): void;
+    observe(observation: Observation): void;
+    stop(): void;
+    onStatus(status: {
+        state: "recording" | "paused";
+        toolbar: boolean;
+    }): void;
+}
+export interface ControllerOptions {
+    environment: string;
+    canAddVariables: boolean;
+    variables: Record<string, string | number | boolean>;
+    /** Name → value; undefined when not set */
+    secrets: Record<string, string | undefined>;
+    secretsIgnored: boolean;
+    /** Screenshot steps already in the test, for the default name */
+    screenshots: number;
+}
+export type Message = ToolbarMessage & {
+    target?: ElementHandle;
+};
+export type Of<A extends Message["action"]> = Extract<Message, {
+    action: A;
+}>;
+/** The element picked for an Assert, and the locator behind each of its Count choices */
+export interface PickState {
+    id: number;
+    locator: LocatorSpec;
+    counts: LocatorCall[];
+}
+/** What the action handlers (assert, insert, add a variable or secret) use of the controller */
+export interface ActionContext {
+    readonly deps: ControllerDeps;
+    readonly options: ControllerOptions;
+    readonly variables: Map<string, string>;
+    readonly secrets: Map<string, string | undefined>;
+    isPaused(): boolean;
+    /** The picked element an `assert` with the same id refers to */
+    pick(): PickState | undefined;
+    setPick(pick: PickState | undefined): void;
+    showToast(text: string): void;
+    push(): void;
+}

package/dist/recorder/toolbar/types.js

@@ -0,0 +1 @@
+export {};

package/dist/recorder/toolbar-bridge.d.ts

@@ -0,0 +1,43 @@
+import type Page from "../browser/page.js";
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import type { Observation } from "./normalise.js";
+import type { ToolbarOptions } from "./options.js";
+import { ToolbarController } from "./toolbar/controller.js";
+/** The toolbar's hook in its sandbox */
+export declare const TOOLBAR_HOOK: string;
+/** What the bridge needs of the recording it belongs to */
+export interface BridgeHost {
+    page: Page;
+    connector: BiDiConnector;
+    context: string;
+    mute(): Promise<void>;
+    unmute(): Promise<void>;
+    /** A step the toolbar made (wait, screenshot, insert, assertion) */
+    observe(observation: Observation): void;
+    /** The toolbar's Stop, when the caller did not ask to be told */
+    stop(): void;
+    /** Runs `work` in order with the recording's other events */
+    enqueue(work: () => Promise<void>): void;
+}
+/**
+ * The recorder's side of the toolbar: builds its controller, sends it state and replies, and takes its messages
+ * only from the toolbar's own sandbox realm (the page cannot reach that sandbox).
+ */
+export declare class ToolbarBridge {
+    private readonly host;
+    readonly controller: ToolbarController;
+    /** The context's `samurai-toolbar` sandbox realms, as last listed */
+    private realms;
+    /** Messages waiting for a realm lookup, and those that arrived behind them (kept in order) */
+    private backlog;
+    private waiting;
+    constructor(host: BridgeHost, toolbar: ToolbarOptions);
+    /** A message that came on the toolbar's channel from `realm` */
+    receive(realm: string, data: unknown): void;
+    private listRealms;
+    /** A message from the toolbar's own sandbox */
+    private fromToolbar;
+    private createController;
+    /** Calls the toolbar hook's `method` in the loaded document; a document between loads has no toolbar yet */
+    private call;
+}

package/dist/recorder/toolbar-bridge.js

@@ -0,0 +1,106 @@
+import logger from "../logger/index.js";
+import { callFunction } from "../script/call-function.js";
+import { fromRemoteValue } from "../script/serialize.js";
+import { locatorFromSpec } from "../steps/build.js";
+import { addVariable, setSecret } from "../project/index.js";
+import { listSandboxRealms } from "./realms.js";
+import { rankLocator } from "./ranking.js";
+import { ToolbarController } from "./toolbar/controller.js";
+import { inspectElement } from "./toolbar/inspect.js";
+import { TOOLBAR_KEY, TOOLBAR_SANDBOX, } from "./toolbar/protocol.js";
+/** The toolbar's hook in its sandbox */
+export const TOOLBAR_HOOK = `globalThis[Symbol.for(${JSON.stringify(TOOLBAR_KEY)})]`;
+/**
+ * The recorder's side of the toolbar: builds its controller, sends it state and replies, and takes its messages
+ * only from the toolbar's own sandbox realm (the page cannot reach that sandbox).
+ */
+export class ToolbarBridge {
+    constructor(host, toolbar) {
+        this.host = host;
+        /** The context's `samurai-toolbar` sandbox realms, as last listed */
+        this.realms = new Set();
+        /** Messages waiting for a realm lookup, and those that arrived behind them (kept in order) */
+        this.backlog = Promise.resolve();
+        this.waiting = 0;
+        this.controller = this.createController(toolbar);
+    }
+    /** A message that came on the toolbar's channel from `realm` */
+    receive(realm, data) {
+        if (this.waiting === 0 && this.realms.has(realm)) {
+            this.fromToolbar(data);
+            return;
+        }
+        // A sandbox not seen yet (a new document's toolbar): look it up, and keep later messages behind it
+        this.waiting++;
+        this.backlog = this.backlog
+            .then(async () => {
+            if (!this.realms.has(realm))
+                await this.listRealms();
+            if (this.realms.has(realm))
+                this.fromToolbar(data);
+            else
+                logger.warn("Recorder ignored a toolbar message from outside the toolbar's sandbox");
+        })
+            .catch((err) => {
+            logger.debug("Could not check a toolbar message's realm", { err });
+        })
+            .finally(() => this.waiting--);
+    }
+    async listRealms() {
+        this.realms = await listSandboxRealms(this.host.connector, this.host.context, TOOLBAR_SANDBOX);
+    }
+    /** A message from the toolbar's own sandbox */
+    fromToolbar(data) {
+        const message = fromRemoteValue(data);
+        const controller = this.controller;
+        if (message.type !== "toolbar" || !("action" in message))
+            return;
+        if (message.action === "ready") {
+            // Not behind a slow insert: the ready watchdog is waiting for it
+            void controller.handle(message);
+        }
+        else if (controller.accept(message)) {
+            // Decided as it arrives: a double click's second copy would only run after the first had finished
+            this.host.enqueue(async () => controller.handle(message));
+        }
+    }
+    createController(toolbar) {
+        const { page, connector, context } = this.host;
+        const { projectDir, environment, onStatus, onStop, onSecretAdded } = toolbar;
+        return new ToolbarController({
+            push: (state) => this.call("update", [state]),
+            reply: (id, result) => this.call("reply", [id, result]),
+            currentUrl: () => page.url(),
+            rank: (target, candidates) => rankLocator(page, target, candidates),
+            inspect: (target, locator, candidates) => inspectElement(page, connector, context, target, locator, candidates),
+            type: async (locator, value) => {
+                await this.host.mute();
+                try {
+                    await locatorFromSpec(page, locator).fill(value, {
+                        timeout: 5000,
+                    });
+                }
+                finally {
+                    await this.host.unmute();
+                }
+            },
+            mute: () => this.host.mute(),
+            unmute: () => this.host.unmute(),
+            addVariable: (name, value) => addVariable(projectDir, environment, name, value),
+            setSecret: (name, value) => setSecret(projectDir, environment, name, value),
+            secretAdded: (name) => onSecretAdded?.(name),
+            observe: (observation) => this.host.observe(observation),
+            stop: () => {
+                if (onStop)
+                    onStop();
+                else
+                    this.host.stop();
+            },
+            onStatus: (status) => onStatus?.(status),
+        }, toolbar);
+    }
+    /** Calls the toolbar hook's `method` in the loaded document; a document between loads has no toolbar yet */
+    call(method, args) {
+        callFunction(this.host.connector, this.host.context, `(...args) => { ${TOOLBAR_HOOK}?.${method}(...args); }`, args, { sandbox: TOOLBAR_SANDBOX, awaitPromise: false }).catch((err) => logger.debug("Could not reach the recorder toolbar", { err }));
+    }
+}

package/dist/runner/browsers.d.ts

@@ -0,0 +1,10 @@
+import type { SupportedBrowser } from "../types/browser.js";
+/**
+ * The browsers a run uses, the first that is set winning: the command line, the group being run, the project, then
+ * Firefox. An empty list counts as not given.
+ */
+export declare function browsersFor(sources: {
+    flag?: readonly SupportedBrowser[] | undefined;
+    group?: readonly SupportedBrowser[] | undefined;
+    project?: readonly SupportedBrowser[] | undefined;
+}): SupportedBrowser[];

package/dist/runner/browsers.js

@@ -0,0 +1,12 @@
+/** The browsers of a run that names none */
+const DEFAULT_BROWSERS = ["firefox"];
+/**
+ * The browsers a run uses, the first that is set winning: the command line, the group being run, the project, then
+ * Firefox. An empty list counts as not given.
+ */
+export function browsersFor(sources) {
+    for (const list of [sources.flag, sources.group, sources.project])
+        if (list && list.length > 0)
+            return [...list];
+    return [...DEFAULT_BROWSERS];
+}

package/dist/runner/groups.d.ts

@@ -1,3 +1,4 @@
+import type { SupportedBrowser } from "../types/browser.js";
 import type { SamuraiGroup } from "../types/config.js";
 /** The test folder when the config names none */
 export declare const DEFAULT_SRC_DIR = "./src";
@@ -22,6 +23,8 @@ export interface ResolvedGroup {
         file: string;
         title: string;
     }[];
+    /** The browsers the group's tests run in: its own `browsers`, else the project's, else Firefox */
+    browsers: SupportedBrowser[];
 }
 /**
  * The real path of `p` (symlinks resolved), or `p` itself when it does not exist. Registered test files come
@@ -33,10 +36,11 @@ export declare const toPosix: (p: string) => string;
 /** The id of a test: its spec file relative to `srcDir` with `/` separators, then `::` and its full name */
 export declare const testId: (file: string, name: string) => string;
 /** Works out which of `tests` (files relative to `srcDir`) belong to the group */
-export declare function resolveGroup(group: SamuraiGroup, tests: GroupTest[], projectDir: string, srcDir: string): ResolvedGroup;
+export declare function resolveGroup(group: SamuraiGroup, tests: GroupTest[], projectDir: string, srcDir: string, projectBrowsers?: readonly SupportedBrowser[]): ResolvedGroup;
 /** Resolves every group of the config */
 export declare function resolveGroups(config: {
     groups?: SamuraiGroup[];
+    browsers?: SupportedBrowser[];
 }, tests: GroupTest[], projectDir: string, srcDir: string): ResolvedGroup[];
 /** The group called `name`, or an error naming the groups there are */
 export declare function findGroup<T extends {

package/dist/runner/groups.js

@@ -1,5 +1,6 @@
 import { realpathSync } from "node:fs";
 import { matchesGlob, relative, resolve } from "node:path";
+import { browsersFor } from "./browsers.js";
 /** The test folder when the config names none */
 export const DEFAULT_SRC_DIR = "./src";
 /** The spec pattern when a group names none */
@@ -21,7 +22,11 @@ export const toPosix = (p) => p.replace(/\\/g, "/");
 /** The id of a test: its spec file relative to `srcDir` with `/` separators, then `::` and its full name */
 export const testId = (file, name) => `${toPosix(file)}::${name}`;
 /** Works out which of `tests` (files relative to `srcDir`) belong to the group */
-export function resolveGroup(group, tests, projectDir, srcDir) {
+export function resolveGroup(group, tests, projectDir, srcDir, projectBrowsers) {
+    const browsers = browsersFor({
+        group: group.browsers,
+        project: projectBrowsers,
+    });
     const found = tests.map((t) => ({ ...t, id: testId(t.file, t.name) }));
     // Tests picked by hand override src and testMatch
     if (group.tests) {
@@ -38,6 +43,7 @@ export function resolveGroup(group, tests, projectDir, srcDir) {
             missing: picked
                 .filter((t) => !known.has(t.id))
                 .map(({ file, title }) => ({ file, title })),
+            browsers,
         };
     }
     const base = group.src ? resolve(projectDir, group.src) : srcDir;
@@ -54,11 +60,12 @@ export function resolveGroup(group, tests, projectDir, srcDir) {
         pattern: [group.src, group.testMatch].filter(Boolean).join(" · ") || pattern,
         testIds,
         missing: [],
+        browsers,
     };
 }
 /** Resolves every group of the config */
 export function resolveGroups(config, tests, projectDir, srcDir) {
-    return (config.groups ?? []).map((group) => resolveGroup(group, tests, projectDir, srcDir));
+    return (config.groups ?? []).map((group) => resolveGroup(group, tests, projectDir, srcDir, config.browsers));
 }
 /** The group called `name`, or an error naming the groups there are */
 export function findGroup(groups, name) {

package/dist/runner/options.d.ts

@@ -0,0 +1,31 @@
+import type { SupportedBrowser } from "../types/browser.js";
+import type { RunEvent } from "./reporter.js";
+/** What decides which tests of the found files run, and how the browser starts */
+export interface RunnerOptions {
+    /** Spec files to run, absolute or relative to the project folder. Default: every `*.spec.ts` under `srcDir` */
+    files?: string[];
+    /** Only tests whose full name matches (a string must be contained in it) */
+    grep?: string | RegExp;
+    /** Only tests with exactly one of these full names (`describe` titles joined with " > ") */
+    testNames?: string[];
+    /** Only the tests of this group of the config's `groups` (unknown name: an error). Combines with the other filters */
+    group?: string;
+    /** The browsers to run in, instead of the group's or the project's `browsers` (the command line's `--browser`) */
+    browsers?: SupportedBrowser[];
+    /**
+     * How many tests run at the same time, each in a worker process: a whole number from 1 or a share of the CPUs
+     * like `"50%"` (the command line's `--workers`). Beats `SAMURAI_WORKERS` and the config's `workers`.
+     * @default the config's `workers`, else half the CPUs
+     */
+    workers?: number | string;
+    /** Run the browser without a window. @default false */
+    headless?: boolean;
+    /** Remote debugging port of the browser. @default DEFAULT_PORT (9223) */
+    port?: number;
+    /** Where the report is written; `false` writes none. @default `<project>/result/report.json` */
+    reportPath?: string | false;
+    /** Receives start and end of the run and of every test, as they happen */
+    onEvent?: (event: RunEvent) => void;
+    /** Aborting stops the running test (its browser is closed), skips the rest and reports the run as failed */
+    signal?: AbortSignal;
+}

package/dist/runner/options.js

@@ -0,0 +1 @@
+export {};

package/dist/runner/pooled-run.d.ts

@@ -0,0 +1,43 @@
+import type { SupportedBrowser } from "../types/browser.js";
+import type { SamuraiGroup } from "../types/config.js";
+import type { RegisteredTestCase, TestResult } from "../types/test.js";
+import type { ResolvedGroup } from "./groups.js";
+import type TestReporter from "./reporter.js";
+import type { RunHooks } from "./worker-pool.js";
+import type { WorkItem } from "./worker-protocol.js";
+/** What a run needs from a worker pool: `WorkerPool` itself, or a fake in tests */
+export interface PooledRunner {
+    run(items: WorkItem[], hooks?: RunHooks): Promise<TestResult[]>;
+}
+/** A test in a browser, as the run lists it: the work item at the same position says the same in a form a worker reads */
+export interface PlannedTest {
+    test: RegisteredTestCase;
+    browser: SupportedBrowser;
+}
+/**
+ * Lists the run: every selected test in the first browser, then every selected test in the next one. The
+ * position in the list is the item's `index`. `serialKey` says which group makes a test run alone.
+ */
+export declare function planItems(selected: RegisteredTestCase[], browsers: SupportedBrowser[], serialKey: (test: RegisteredTestCase) => string | undefined): {
+    items: WorkItem[];
+    planned: PlannedTest[];
+};
+/**
+ * Which key makes a test run alone: the first of the config's groups with `workers: 1` that holds it. `groups`
+ * and `configGroups` are the same list, resolved and as written.
+ */
+export declare function serialKeyOf(groups: ResolvedGroup[], configGroups: SamuraiGroup[] | undefined, srcDir: string): (test: RegisteredTestCase) => string | undefined;
+/**
+ * How a run goes: through the pool, in this process, or in this process because the workers could not read the
+ * config (it was given as an object; a worker reads `samurai.config.ts` from the project folder)
+ */
+export declare function poolMode(input: {
+    workers: number;
+    items: number;
+    inlineConfig: boolean;
+}): "pool" | "in-process" | "inline-config";
+/**
+ * Runs the planned items on the pool and reports them as they happen. An item the pool answers without events
+ * (a queued one cut short by an abort, or one whose worker died before it began) is reported here at the end.
+ */
+export declare function runPooled(pool: PooledRunner, planned: PlannedTest[], items: WorkItem[], reporter: TestReporter, signal?: AbortSignal): Promise<void>;

package/dist/runner/pooled-run.js

@@ -0,0 +1,75 @@
+import { idOf } from "./select.js";
+/**
+ * Lists the run: every selected test in the first browser, then every selected test in the next one. The
+ * position in the list is the item's `index`. `serialKey` says which group makes a test run alone.
+ */
+export function planItems(selected, browsers, serialKey) {
+    const planned = browsers.flatMap((browser) => selected.map((test) => ({ test, browser })));
+    const items = planned.map(({ test, browser }, index) => {
+        const key = serialKey(test);
+        return {
+            index,
+            file: test.file,
+            testName: test.name,
+            browser,
+            ...(key !== undefined && { serialKey: key }),
+        };
+    });
+    return { items, planned };
+}
+/**
+ * Which key makes a test run alone: the first of the config's groups with `workers: 1` that holds it. `groups`
+ * and `configGroups` are the same list, resolved and as written.
+ */
+export function serialKeyOf(groups, configGroups, srcDir) {
+    const keys = new Map();
+    groups.forEach((group, index) => {
+        if (configGroups?.[index]?.workers !== 1)
+            return;
+        for (const id of group.testIds)
+            if (!keys.has(id))
+                keys.set(id, `group:${group.name}`);
+    });
+    return (test) => keys.get(idOf(test, srcDir));
+}
+/**
+ * How a run goes: through the pool, in this process, or in this process because the workers could not read the
+ * config (it was given as an object; a worker reads `samurai.config.ts` from the project folder)
+ */
+export function poolMode(input) {
+    if (input.workers <= 1 || input.items <= 1)
+        return "in-process";
+    return input.inlineConfig ? "inline-config" : "pool";
+}
+/**
+ * Runs the planned items on the pool and reports them as they happen. An item the pool answers without events
+ * (a queued one cut short by an abort, or one whose worker died before it began) is reported here at the end.
+ */
+export async function runPooled(pool, planned, items, reporter, signal) {
+    reporter.setOrder(planned);
+    const started = new Set();
+    const ended = new Set();
+    const begin = (index) => {
+        if (started.has(index))
+            return;
+        started.add(index);
+        const { test, browser } = planned[index];
+        reporter.onTestStart(test, browser);
+    };
+    const end = (index, result) => {
+        begin(index);
+        ended.add(index);
+        const { test, browser } = planned[index];
+        reporter.onRemoteEnd(test, browser, result);
+    };
+    const results = await pool.run(items, {
+        ...(signal && { signal }),
+        onEvent: (event) => event.type === "test-start"
+            ? begin(event.item.index)
+            : end(event.item.index, event.result),
+    });
+    results.forEach((result, index) => {
+        if (!ended.has(index))
+            end(index, result);
+    });
+}

package/dist/runner/ports.d.ts

@@ -0,0 +1,2 @@
+/** The browser's debugging port when a run or a recording is given none */
+export declare const DEFAULT_PORT = 9223;

package/dist/runner/ports.js

@@ -0,0 +1,2 @@
+/** The browser's debugging port when a run or a recording is given none */
+export const DEFAULT_PORT = 9223;

package/dist/runner/registry.d.ts

@@ -3,5 +3,5 @@ import type { RegisteredTestCase, TestCaseBase } from "../types/test.js";
 export declare function describe(title: string, fn: () => void): void;
 export declare function test(title: string, fn: TestCaseBase["function"]): void;
 export declare function registeredTests(): readonly RegisteredTestCase[];
-/** Forgets every registered test (tests only) */
+/** Forgets every registered test: a run registers its specs afresh */
 export declare function clearRegistry(): void;

package/dist/runner/registry.js

@@ -26,7 +26,7 @@ export function test(title, fn) {
 export function registeredTests() {
     return registered;
 }
-/** Forgets every registered test (tests only) */
+/** Forgets every registered test: a run registers its specs afresh */
 export function clearRegistry() {
     registered.length = 0;
     titleStack.length = 0;

package/dist/runner/reporter.d.ts

@@ -1,17 +1,24 @@
 import type { RegisteredTestCase, TestError, TestLogEntry, TestResult, TestSummary } from "../types/test.js";
+import type { SupportedBrowser } from "../types/browser.js";
 /** What a run reports while it happens */
 export type RunEvent = {
     type: "run-start";
     environment: string;
+    /** Every selected test in every browser */
     total: number;
+    browsers: SupportedBrowser[];
+    /** How many tests run at the same time; absent when they run one after the other */
+    workers?: number;
 } | {
     type: "test-start";
     name: string;
     file: string;
+    browser: SupportedBrowser;
 } | {
     type: "test-end";
     name: string;
     file: string;
+    browser: SupportedBrowser;
     result: TestResult;
 } | {
     type: "run-end";
@@ -20,28 +27,50 @@ export type RunEvent = {
 export interface ReporterOptions {
     /** The environment the run uses, recorded in the report */
     environment: string;
+    /** The browsers the run uses, in the order they run; recorded in the report */
+    browsers: SupportedBrowser[];
     /** Where the report is written. @default <cwd>/result/report.json */
     output?: string | false;
     /** Called with every event, in order. A throwing listener is ignored */
     onEvent?: (event: RunEvent) => void;
 }
-export default class TestReporter {
+/** What `runOneTest` reports a test to: the reporter of a run, or a worker that relays it */
+export interface TestSink {
+    onTestStart(test: RegisteredTestCase, browser: SupportedBrowser): void;
+    onTestEnd(test: RegisteredTestCase, browser: SupportedBrowser, error?: TestError, extras?: TestEndExtras): void;
+}
+/** What a test's report entry lists besides its status */
+export interface TestEndExtras {
+    logs?: TestLogEntry[];
+    logsDropped?: number;
+    screenshots?: {
+        name: string;
+        path: string;
+    }[];
+}
+export default class TestReporter implements TestSink {
     private testResults;
     private summary;
     private environment;
+    private browsers;
     private output;
     private listener;
+    /** Keys of the run's tests in the order the report lists them; unset: the order they started in */
+    private order;
     constructor(options: ReporterOptions);
     private emit;
-    onStart(total?: number): void;
+    /** Lists the tests of the run in the order the report shows them, whichever order they end in */
+    setOrder(tests: {
+        test: RegisteredTestCase;
+        browser: SupportedBrowser;
+    }[]): void;
+    onStart(total: number, workers?: number): void;
     onEnd(): Promise<TestSummary>;
-    onTestStart(test: RegisteredTestCase): void;
-    onTestEnd(test: RegisteredTestCase, error?: TestError, extras?: {
-        logs?: TestLogEntry[];
-        logsDropped?: number;
-        screenshots?: {
-            name: string;
-            path: string;
-        }[];
-    }): void;
+    onTestStart(test: RegisteredTestCase, browser: SupportedBrowser): void;
+    /**
+     * Ends a test that ran in a worker: the worker built the result (masked, with its own duration), this keeps the
+     * start time from this process's clock, as the worker's clock has another origin
+     */
+    onRemoteEnd(test: RegisteredTestCase, browser: SupportedBrowser, result: TestResult): void;
+    onTestEnd(test: RegisteredTestCase, browser: SupportedBrowser, error?: TestError, extras?: TestEndExtras): void;
 }