@itmetsam/samurai-framework 0.10.0 → 0.12.1

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

@@ -1,16 +1,4 @@
 import type { SupportedBrowser } from "../types/browser.js";
-import type { SamuraiTestConfig } from "../types/config.js";
-/** Every browser a config may name, in the order the messages list them */
-export declare const BROWSER_NAMES: readonly SupportedBrowser[];
-/** The browsers of a run that names none */
-export declare const DEFAULT_BROWSERS: readonly SupportedBrowser[];
-/** Throws when `list` is not a non-empty list of distinct browser names; `where` names the key in the message */
-export declare function checkBrowserList(list: unknown, where: string): void;
-/**
- * Checks the browser keys of a config: the removed `browser`, and `browsers` on the project and on each group.
- * Throws an Error that says what to write instead.
- */
-export declare function validateBrowserConfig(config: SamuraiTestConfig): void;
 /**
  * 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.

package/dist/runner/browsers.js

@@ -1,37 +1,5 @@
-/** Every browser a config may name, in the order the messages list them */
-export const BROWSER_NAMES = ["firefox", "chrome"];
 /** The browsers of a run that names none */
-export const DEFAULT_BROWSERS = ["firefox"];
-const isBrowser = (value) => typeof value === "string" &&
-    BROWSER_NAMES.includes(value);
-/** Throws when `list` is not a non-empty list of distinct browser names; `where` names the key in the message */
-export function checkBrowserList(list, where) {
-    if (!Array.isArray(list) || list.length === 0)
-        throw new Error(`${where} must list at least one browser.`);
-    const seen = new Set();
-    for (const name of list) {
-        if (!isBrowser(name))
-            throw new Error(`Unknown browser "${String(name)}" in ${where}. Choose ${BROWSER_NAMES.join(" or ")}.`);
-        if (seen.has(name))
-            throw new Error(`Browser "${name}" is listed twice in ${where}.`);
-        seen.add(name);
-    }
-}
-/**
- * Checks the browser keys of a config: the removed `browser`, and `browsers` on the project and on each group.
- * Throws an Error that says what to write instead.
- */
-export function validateBrowserConfig(config) {
-    const legacy = config.browser;
-    if (legacy !== undefined)
-        throw new Error(`"browser" was replaced by "browsers": use browsers: [${JSON.stringify(legacy)}]`);
-    if (config.browsers !== undefined)
-        checkBrowserList(config.browsers, "browsers");
-    config.groups?.forEach((group, index) => {
-        if (group.browsers !== undefined)
-            checkBrowserList(group.browsers, `groups[${index}].browsers`);
-    });
-}
+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.

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

@@ -7,6 +7,8 @@ export type RunEvent = {
     /** 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;
@@ -32,24 +34,43 @@ export interface ReporterOptions {
     /** 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, browser: SupportedBrowser): void;
-    onTestEnd(test: RegisteredTestCase, browser: SupportedBrowser, error?: TestError, extras?: {
-        logs?: TestLogEntry[];
-        logsDropped?: number;
-        screenshots?: {
-            name: string;
-            path: string;
-        }[];
-    }): 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;
 }

package/dist/runner/reporter.js

@@ -23,8 +23,12 @@ export default class TestReporter {
             // A listener must not break the run
         }
     }
-    onStart(total = 0) {
-        const t = performance.mark(`group-start`);
+    /** Lists the tests of the run in the order the report shows them, whichever order they end in */
+    setOrder(tests) {
+        this.order = tests.map(({ test, browser }) => keyOf(test, browser));
+    }
+    onStart(total, workers = 1) {
+        const t = performance.mark("run-start");
         this.summary = {
             duration: 0,
             status: "failed",
@@ -38,18 +42,27 @@ export default class TestReporter {
             environment: this.environment,
             total,
             browsers: this.browsers,
+            ...(workers > 1 && { workers }),
         });
     }
     async onEnd() {
-        performance.mark(`group-finish`);
-        const duration = performance.measure("test-duration", `group-start`, `group-finish`).duration;
+        performance.mark("run-end");
+        const duration = performance.measure("test-duration", "run-start", "run-end").duration;
+        const tests = this.order
+            ? [
+                ...this.order.flatMap((key) => this.testResults.get(key) ?? []),
+                ...[...this.testResults]
+                    .filter(([key]) => !this.order.includes(key))
+                    .map(([, result]) => result),
+            ]
+            : [...this.testResults.values()];
         this.summary = {
             ...this.summary,
             duration,
             environment: this.environment,
             browsers: this.browsers,
-            tests: Array.from(this.testResults.values()),
-            status: Array.from(this.testResults.values()).every((r) => r.status === "success")
+            tests,
+            status: tests.every((r) => r.status === "success")
                 ? "success"
                 : "failed",
         };
@@ -79,6 +92,26 @@ export default class TestReporter {
             browser,
         });
     }
+    /**
+     * 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, browser, result) {
+        const key = keyOf(test, browser);
+        const started = this.testResults.get(key);
+        const ended = {
+            ...result,
+            ...(started && { startTime: started.startTime }),
+        };
+        this.testResults.set(key, ended);
+        this.emit({
+            type: "test-end",
+            name: test.name,
+            file: test.file,
+            browser,
+            result: ended,
+        });
+    }
     onTestEnd(test, browser, error, extras) {
         const key = keyOf(test, browser);
         performance.mark(`${key}-finish`);

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

@@ -0,0 +1,16 @@
+import type { SupportedBrowser } from "../types/browser.js";
+import type { RegisteredTestCase } from "../types/test.js";
+import type { RunnerOptions } from "./options.js";
+import type { PreparedRun } from "./prepare-run.js";
+import type { TestSink } from "./reporter.js";
+/** What a worker gives its tests that the main process does not: its own port and profile, and its number */
+export interface WorkerResources {
+    /** The browser's debugging port. @default `options.port`, else DEFAULT_PORT */
+    port?: number;
+    /** The browser's profile folder. @default the browser's own */
+    profileDir?: string;
+    /** The `workerIndex` fixture. @default 0 */
+    workerIndex?: number;
+}
+/** Runs one test in one browser and reports it: launch, run the body, judge the page's logs, close the browser */
+export declare function runOneTest(test: RegisteredTestCase, browserName: SupportedBrowser, run: PreparedRun, options: RunnerOptions, srcDir: string, reporter: TestSink, resources?: WorkerResources): Promise<void>;