@itmetsam/samurai-framework 0.21.4 → 0.22.0

package/dist/runner/pool-units.d.ts

@@ -0,0 +1,34 @@
+import type { TestError, TestResult } from "../types/test.js";
+import type { WorkItem } from "./worker-protocol.js";
+/** The error a failed result carries, as the next result lists it in `previousAttempts` */
+export declare function errorOf(result: TestResult): TestError;
+/** The result of a test of a serial block that did not run, because an earlier test of the block failed */
+export declare function serialSkipped(item: WorkItem): TestResult;
+/** What the pool keeps of a queued item: the item, and whatever else it needs to find its place again */
+interface Held<E> {
+    entry: E;
+    result: TestResult;
+}
+/**
+ * A serial block as the pool runs it. With retries the results are held until the block's last attempt is known,
+ * so a test ends once, saying which attempt that was; without, the pool reports them as they come and uses this
+ * only to count the attempts.
+ */
+export declare class UnitState<E extends {
+    item: WorkItem;
+}> {
+    readonly call: unknown;
+    /** Which attempt at the block this is, counting from 0 */
+    attempt: number;
+    private held;
+    private readonly previous;
+    constructor(call: unknown);
+    hold(entry: E, result: TestResult): void;
+    /** The block failed and runs again: forgets this attempt's results, remembers the error and returns the entries to queue again, in order */
+    restart(failed: E, result: TestResult): E[];
+    /** The held results of the last attempt, each saying which attempt it was and what failed before; they are not held any more */
+    release(): Held<E>[];
+}
+/** The result of an item that ended without one: the worker died, or the run was aborted */
+export declare function failedResult(item: WorkItem, message: string, startTime?: number): TestResult;
+export {};

package/dist/runner/pool-units.js

@@ -0,0 +1,85 @@
+import { SERIAL_SKIP_REASON } from "./serial.js";
+/** The error a failed result carries, as the next result lists it in `previousAttempts` */
+export function errorOf(result) {
+    const { message, type, stack, expected, actual } = result;
+    return {
+        message: message ?? "The test failed",
+        type: type ?? "error",
+        ...(stack !== undefined && { stack }),
+        ...(expected !== undefined && { expected }),
+        ...(actual !== undefined && { actual }),
+    };
+}
+/** The result of a test of a serial block that did not run, because an earlier test of the block failed */
+export function serialSkipped(item) {
+    return {
+        name: item.testName,
+        file: item.file,
+        browser: item.browser,
+        status: "skipped",
+        startTime: Date.now(),
+        duration: 0,
+        annotation: "skip",
+        reason: SERIAL_SKIP_REASON,
+    };
+}
+/**
+ * A serial block as the pool runs it. With retries the results are held until the block's last attempt is known,
+ * so a test ends once, saying which attempt that was; without, the pool reports them as they come and uses this
+ * only to count the attempts.
+ */
+export class UnitState {
+    constructor(call) {
+        this.call = call;
+        /** Which attempt at the block this is, counting from 0 */
+        this.attempt = 0;
+        this.held = [];
+        this.previous = new Map();
+    }
+    hold(entry, result) {
+        this.held.push({ entry, result });
+    }
+    /** The block failed and runs again: forgets this attempt's results, remembers the error and returns the entries to queue again, in order */
+    restart(failed, result) {
+        const entries = this.held.map(({ entry }) => entry);
+        this.held = [];
+        const errors = this.previous.get(failed) ?? [];
+        errors.push(errorOf(result));
+        this.previous.set(failed, errors);
+        this.attempt++;
+        return entries;
+    }
+    /** The held results of the last attempt, each saying which attempt it was and what failed before; they are not held any more */
+    release() {
+        const released = this.held.map(({ entry, result }) => {
+            const before = this.previous.get(entry) ?? [];
+            return {
+                entry,
+                result: {
+                    ...result,
+                    ...(this.attempt > 0 && {
+                        retry: this.attempt,
+                        previousAttempts: [...before],
+                        ...(result.status === "success" &&
+                            before.length > 0 && { flaky: true }),
+                    }),
+                },
+            };
+        });
+        this.held = [];
+        return released;
+    }
+}
+/** The result of an item that ended without one: the worker died, or the run was aborted */
+export function failedResult(item, message, startTime = Date.now()) {
+    return {
+        name: item.testName,
+        file: item.file,
+        browser: item.browser,
+        status: "failed",
+        type: "error",
+        message,
+        startTime,
+        duration: Date.now() - startTime,
+    };
+}

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

@@ -3,6 +3,7 @@ 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 { RunUnit } from "./serial.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 */
@@ -16,10 +17,11 @@ export interface PlannedTest {
 }
 /**
  * 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. `inputs`, the
- * run's input values, go with every item.
+ * position in the list is the item's `index`. `serialKey` says which group makes a test run alone, `unitOf` which
+ * tests must run one after the other on one worker (a serial block, a file). `inputs`, the run's input values, go
+ * with every item. `runsIn` says which browsers a test runs in (all of them unless a group names its own).
  */
-export declare function planItems(selected: RegisteredTestCase[], browsers: SupportedBrowser[], serialKey: (test: RegisteredTestCase) => string | undefined, inputs?: Record<string, string>): {
+export declare function planItems(selected: RegisteredTestCase[], browsers: SupportedBrowser[], serialKey: (test: RegisteredTestCase) => string | undefined, inputs?: Record<string, string>, unitOf?: (test: RegisteredTestCase) => RunUnit | undefined, runsIn?: (test: RegisteredTestCase, browser: SupportedBrowser) => boolean): {
     items: WorkItem[];
     planned: PlannedTest[];
 };
@@ -29,8 +31,8 @@ export declare function planItems(selected: RegisteredTestCase[], browsers: Supp
  */
 export declare function serialKeyOf(groups: ResolvedGroup[], configGroups: SamuraiGroup[] | undefined, srcDir: string): (test: RegisteredTestCase) => string | undefined;
 /**
- * How many items can run at the same time: each item alone counts one, and the items of one serial key together
- * count one. More workers than this would only sit idle.
+ * How many items can run at the same time: each item alone counts one, and the items of one unit, or of one serial
+ * key, together count one. More workers than this would only sit idle.
  */
 export declare function concurrency(items: WorkItem[]): number;
 /**

package/dist/runner/pooled-run.js

@@ -2,23 +2,31 @@ import { idOf } from "./select.js";
 import { staticSkip } from "./skip.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. `inputs`, the
- * run's input values, go with every item.
+ * position in the list is the item's `index`. `serialKey` says which group makes a test run alone, `unitOf` which
+ * tests must run one after the other on one worker (a serial block, a file). `inputs`, the run's input values, go
+ * with every item. `runsIn` says which browsers a test runs in (all of them unless a group names its own).
  */
-export function planItems(selected, browsers, serialKey, inputs) {
-    const planned = browsers.flatMap((browser) => selected.map((test) => ({ test, browser })));
+export function planItems(selected, browsers, serialKey, inputs, unitOf = () => undefined, runsIn = () => true) {
+    const planned = browsers.flatMap((browser) => selected
+        .filter((test) => runsIn(test, browser))
+        .map((test) => ({ test, browser })));
     // A test that does not run (skip, fixme) is in the plan but not in the queue; `index` is its place in the plan
     const items = planned.flatMap(({ test, browser }, index) => {
         if (staticSkip(test))
             return [];
         const key = serialKey(test);
+        const unit = unitOf(test);
         return [
             {
                 index,
                 file: test.file,
                 testName: test.name,
                 browser,
+                ...(test.group !== undefined && { group: test.group }),
                 ...(key !== undefined && { serialKey: key }),
+                // One unit per browser: the same block in two browsers is two runs
+                ...(unit && { unit: `${unit.key}@${browser}` }),
+                ...(unit?.serial && { serial: true }),
                 ...(inputs !== undefined && { inputs }),
             },
         ];
@@ -41,17 +49,19 @@ export function serialKeyOf(groups, configGroups, srcDir) {
     return (test) => keys.get(idOf(test, srcDir));
 }
 /**
- * How many items can run at the same time: each item alone counts one, and the items of one serial key together
- * count one. More workers than this would only sit idle.
+ * How many items can run at the same time: each item alone counts one, and the items of one unit, or of one serial
+ * key, together count one. More workers than this would only sit idle.
  */
 export function concurrency(items) {
     const keys = new Set();
     let free = 0;
     for (const item of items) {
-        if (item.serialKey === undefined)
-            free++;
+        if (item.unit !== undefined)
+            keys.add(`unit:${item.unit}`);
+        else if (item.serialKey !== undefined)
+            keys.add(`key:${item.serialKey}`);
         else
-            keys.add(item.serialKey);
+            free++;
     }
     return free + keys.size;
 }

package/dist/runner/registry.d.ts

@@ -1,41 +1,5 @@
-import type { AllHook, EachHook, RegisteredTestCase, TestCaseBase, TestDetails, TestOptions } from "../types/test.js";
-type Body = TestCaseBase["function"];
-/** `test(title, fn)`, `test.skip(title, fn)`, `test.skip(condition, reason)` and the other forms */
-export interface TestFunction {
-    (title: string, fn: Body): void;
-    (title: string, options: TestOptions, fn: Body): void;
-    /** Registers a test that is not run */
-    skip: SkipFunction;
-    /** Registers a test that is not run because it is known to be broken */
-    fixme: SkipFunction;
-    /** Runs only this test (and the other `only` ones) */
-    only: {
-        (title: string, fn: Body): void;
-        (title: string, options: TestOptions, fn: Body): void;
-    };
-}
-/**
- * With a title and a body it registers a skipped test, `{ reason }` saying why; with a condition it skips the
- * running test when the condition is true
- */
-interface SkipFunction {
-    (title: string, fn: Body): void;
-    (title: string, options: TestOptions, fn: Body): void;
-    (condition: boolean, reason?: string): void;
-}
-/** `describe.skip` and `describe.fixme`: every test inside gets the modifier, and `{ reason }` says why */
-interface DescribeSkipFunction {
-    (title: string, fn: () => void): void;
-    (title: string, details: TestDetails, fn: () => void): void;
-}
-/** `describe(title, fn)` and the same with a modifier on every test inside */
-export interface DescribeFunction {
-    (title: string, fn: () => void): void;
-    skip: DescribeSkipFunction;
-    fixme: DescribeSkipFunction;
-    only(title: string, fn: () => void): void;
-}
-export declare const test: TestFunction;
+import type { AllHook, EachHook, RegisteredTestCase } from "../types/test.js";
+import type { DescribeFunction, TestFunction } from "./test-function.js";
 export declare const describe: DescribeFunction;
 /** Runs before each test of the `describe` block it is written in (of the file, at the top level) */
 export declare function beforeEach(hook: EachHook): void;
@@ -45,7 +9,7 @@ export declare function afterEach(hook: EachHook): void;
 export declare function beforeAll(hook: AllHook): void;
 /** Runs once per worker, when the worker is done, for every `describe` block it ran a `beforeAll` for */
 export declare function afterAll(hook: AllHook): void;
+export declare const test: TestFunction;
 export declare function registeredTests(): readonly RegisteredTestCase[];
 /** Forgets every registered test: a run registers its specs afresh */
 export declare function clearRegistry(): void;
-export {};

package/dist/runner/registry.js

@@ -1,12 +1,17 @@
 import { fileURLToPath } from "node:url";
 import logger from "../logger/index.js";
-import { SkipSignal } from "./skip.js";
+import { extendLayers } from "./fixture-defs.js";
+import { validateUseOptions } from "../config/use-options.js";
+import { currentStepLog, currentTestInfo, infoFor, skipFromCondition, } from "./test-info.js";
+import { runStep } from "./steps.js";
+import { markTests } from "./test-annotations.js";
 import { validateTestIO } from "./test-io.js";
-import { addHook, currentSuite, enterSuite, leaveSuite, modifierOf, resetSuites, } from "./suite.js";
+import { addHook, addUse, currentSuite, enterSuite, leaveSuite, modifierOf, resetSuites, } from "./suite.js";
+import { configureSuite } from "./serial.js";
 const registered = [];
 /** Runs `fn` as the `describe` block `title`, under `modifier` when there is one. `fn` runs immediately and must be synchronous. */
-function openDescribe(file, title, fn, modifier, reason) {
-    enterSuite(file, title, modifier, reason);
+function openDescribe(file, title, fn, modifier, reason, mode) {
+    enterSuite(file, title, modifier, reason, mode);
     try {
         const result = fn();
         if (result instanceof Promise) {
@@ -18,8 +23,8 @@ function openDescribe(file, title, fn, modifier, reason) {
         leaveSuite();
     }
 }
-function add(file, title, fn, modifier, extras = {}) {
-    const { reason, inputs, outputs } = extras;
+function add({ file, line, column }, title, fn, modifier, extras = {}) {
+    const { reason, inputs, outputs, extension, expectedFail } = extras;
     const suite = currentSuite(file);
     const titlePath = [...titlesOf(suite), title];
     const name = titlePath.join(" > ");
@@ -28,10 +33,13 @@ function add(file, title, fn, modifier, extras = {}) {
         titlePath,
         function: fn,
         file,
+        ...(line !== undefined && { line, column }),
         suite,
         ...modifierOf({ modifier, ...(reason !== undefined && { reason }) }, suite),
         ...(inputs && { inputs }),
         ...(outputs && { outputs }),
+        ...(extension && { extension }),
+        ...(expectedFail && { expectedFail }),
     });
     logger.debug("Registered test %s", name);
 }
@@ -58,28 +66,59 @@ function bodyAndOptions(call, title, second, third) {
     };
 }
 /** `test()` and `test.only()`: a reason only makes sense with skip and fixme */
-function registering(call, modifier) {
+function registering(call, modifier, extension) {
     return ((title, second, third) => {
         const { fn, reason, ...io } = bodyAndOptions(call, title, second, third);
         if (reason !== undefined)
             throw new Error(`${call}(): reason only applies to skip and fixme`);
         // Frames: Error, callerFile, this function, the spec
-        add(callerFile(), title, fn, modifier, io);
+        add(callerLocation(), title, fn, modifier, {
+            ...io,
+            ...(extension && { extension }),
+        });
     });
 }
 /** `test.skip` and `test.fixme`: a title and a body register a test with the modifier; a condition skips the running test */
-function skipping(annotation) {
+function skipping(annotation, extension) {
     return ((first, second, third) => {
         if (typeof first === "string") {
             const { fn, ...extras } = bodyAndOptions(`test.${annotation}`, first, second, third);
             // Frames: Error, callerFile, this function, the spec
-            add(callerFile(), first, fn, annotation, extras);
+            add(callerLocation(), first, fn, annotation, {
+                ...extras,
+                ...(extension && { extension }),
+            });
             return;
         }
-        if (first)
-            throw new SkipSignal(annotation, second);
+        skipFromCondition(annotation, first, second);
     });
 }
+/**
+ * `test.fail`: a title and a body register a test that is expected to fail; otherwise the running test (or, in a
+ * `describe` block, every test in it) is marked
+ */
+function failing(extension) {
+    return ((first, second, third) => {
+        if (typeof first !== "string") {
+            // Frames: Error, callerFile, this function, the spec
+            const file = callerFile();
+            return markTests("fail", () => currentSuite(file), first, second);
+        }
+        const { fn, reason, ...io } = bodyAndOptions("test.fail", first, second, third);
+        // Frames: Error, callerFile, this function, the spec
+        add(callerLocation(), first, fn, undefined, {
+            ...io,
+            expectedFail: { ...(reason !== undefined && { description: reason }) },
+            ...(extension && { extension }),
+        });
+    });
+}
+/** `test.slow`: triples the timeout of the running test, or of every test of the `describe` block it is written in */
+const slow = ((condition, reason) => {
+    // Frames: Error, callerFile, this function, the spec
+    const file = callerFile();
+    markTests("slow", () => currentSuite(file), condition, reason);
+});
 /** `describe.skip` and `describe.fixme`, with or without `{ reason }` */
 function describeSkipping(annotation) {
     return ((title, second, third) => {
@@ -87,15 +126,13 @@ function describeSkipping(annotation) {
         openDescribe(callerFile(), title, fn, annotation, reason);
     });
 }
-export const test = Object.assign(registering("test"), {
-    skip: skipping("skip"),
-    fixme: skipping("fixme"),
-    only: registering("test.only", "only"),
-});
 export const describe = Object.assign((title, fn) => openDescribe(callerFile(), title, fn), {
     skip: describeSkipping("skip"),
     fixme: describeSkipping("fixme"),
     only: (title, fn) => openDescribe(callerFile(), title, fn, "only"),
+    configure: (options) => configureSuite(currentSuite(callerFile()), options),
+    serial: (title, fn) => openDescribe(callerFile(), title, fn, undefined, undefined, "serial"),
+    parallel: (title, fn) => openDescribe(callerFile(), title, fn, undefined, undefined, "parallel"),
 });
 /** Runs before each test of the `describe` block it is written in (of the file, at the top level) */
 export function beforeEach(hook) {
@@ -113,6 +150,34 @@ export function beforeAll(hook) {
 export function afterAll(hook) {
     addHook(currentSuite(callerFile()), "afterAll", hook);
 }
+/** `test.use(options)`: checked now, applied when each test of the scope runs */
+function use(options) {
+    addUse(currentSuite(callerFile()), validateUseOptions(options));
+}
+/**
+ * A `test` that registers its tests with the custom fixtures `extension`. The aliases are the same functions as
+ * the named exports: they find the spec file from the stack, so they must not be wrapped.
+ */
+function makeTest(extension) {
+    return Object.assign(registering("test", undefined, extension), {
+        skip: skipping("skip", extension),
+        fixme: skipping("fixme", extension),
+        fail: failing(extension),
+        slow,
+        setTimeout: (ms) => infoFor("setTimeout()").setTimeout(ms),
+        step: (title, body, options) => runStep(currentStepLog(), title, body, options),
+        only: registering("test.only", "only", extension),
+        info: currentTestInfo,
+        use,
+        describe,
+        beforeEach,
+        afterEach,
+        beforeAll,
+        afterAll,
+        extend: (fixtures) => makeTest(extendLayers(extension, fixtures)),
+    });
+}
+export const test = makeTest();
 export function registeredTests() {
     return registered;
 }
@@ -121,10 +186,23 @@ export function clearRegistry() {
     registered.length = 0;
     resetSuites();
 }
-/** File of the code that called the entry point: stack lines are Error, callerFile, the entry point, the caller */
-function callerFile() {
+/** The place of the caller: stack lines are Error, callerLocation, the entry point, the caller */
+function callerLocation() {
     const caller = new Error().stack?.split("\n")[3] ?? "";
-    const match = caller.match(/\((.+?):\d+:\d+\)$/) ?? caller.match(/at (.+?):\d+:\d+$/);
+    return parseFrame(caller);
+}
+/** File of the code that called the entry point (the same frames as `callerLocation`) */
+function callerFile() {
+    return parseFrame(new Error().stack?.split("\n")[3] ?? "").file;
+}
+function parseFrame(frame) {
+    const match = frame.match(/\((.+?):(\d+):(\d+)\)$/) ??
+        frame.match(/at (.+?):(\d+):(\d+)$/);
     const location = match?.[1] ?? "";
-    return location.startsWith("file://") ? fileURLToPath(location) : location;
+    const file = location.startsWith("file://")
+        ? fileURLToPath(location)
+        : location;
+    return match
+        ? { file, line: Number(match[2]), column: Number(match[3]) }
+        : { file };
 }

package/dist/runner/reporter.d.ts

@@ -1,5 +1,6 @@
-import type { RegisteredTestCase, TestError, TestLogEntry, TestResult, TestRetries, TestSummary } from "../types/test.js";
+import type { TestAnnotation, TestStepEntry, TestAttachmentEntry, RegisteredTestCase, TestError, TestLogEntry, TestResult, TestRetries, TestSummary } from "../types/test.js";
 import type { SupportedBrowser } from "../types/browser.js";
+import type { Shard } from "./shard.js";
 /** What a run reports while it happens */
 export type RunEvent = {
     type: "run-start";
@@ -9,11 +10,15 @@ export type RunEvent = {
     browsers: SupportedBrowser[];
     /** How many tests run at the same time; absent when they run one after the other */
     workers?: number;
+    /** The slice of the selected tests this run holds, when it is a shard */
+    shard?: Shard;
 } | {
     type: "test-start";
     name: string;
     file: string;
     browser: SupportedBrowser;
+    /** The group the test runs for, when the run selected groups; absent otherwise */
+    group?: string;
     /** The attempt, counting from 1, when the test is run again after a failure; absent for the first */
     retry?: number;
 } | {
@@ -21,6 +26,8 @@ export type RunEvent = {
     name: string;
     file: string;
     browser: SupportedBrowser;
+    /** The group the test ran for, when the run selected groups; absent otherwise */
+    group?: string;
     result: TestResult;
 } | {
     type: "run-end";
@@ -33,6 +40,8 @@ export interface ReporterOptions {
     browsers: SupportedBrowser[];
     /** Where the report is written. @default <cwd>/result/report.json */
     output?: string | false;
+    /** The slice of the selected tests this run holds; recorded in the report */
+    shard?: Shard;
     /** Called with every event, in order. A throwing listener is ignored */
     onEvent?: (event: RunEvent) => void;
 }
@@ -60,6 +69,12 @@ export interface TestEndExtras extends TestRetries {
     inputs?: Record<string, string>;
     /** The test's saved outputs, when it declares any */
     outputs?: Record<string, string>;
+    /** Files the test attached with `testInfo.attach`, relative to the result folder */
+    attachments?: TestAttachmentEntry[];
+    /** The notes the test pushed to `testInfo.annotations` */
+    annotations?: TestAnnotation[];
+    /** The steps the test ran with `test.step` */
+    steps?: TestStepEntry[];
 }
 export default class TestReporter implements TestSink {
     private testResults;
@@ -68,6 +83,7 @@ export default class TestReporter implements TestSink {
     private browsers;
     private output;
     private listener;
+    private shard;
     /** Keys of the run's tests in the order the report lists them; unset: the order they started in */
     private order;
     constructor(options: ReporterOptions);

package/dist/runner/reporter.js

@@ -2,10 +2,12 @@ import { mkdir, writeFile } from "fs/promises";
 import path from "path";
 import { projectDir } from "../config/config.js";
 import { maskDeep } from "../config/mask.js";
-/** Results are keyed by file, full title and browser, so equal titles in different files or describe blocks, and the same test in two browsers, stay apart */
+/** Results are keyed by file, full title, browser and group, so equal titles in different files or describe blocks, and the same test in two browsers or for two groups, stay apart */
 function keyOf(test, browser) {
-    return `${test.file}::${test.name}::${browser}`;
+    return `${test.file}::${test.name}::${browser}${test.group === undefined ? "" : `::${test.group}`}`;
 }
+/** The `group` of a test's report entry and events: nothing when no group was selected */
+const groupOf = (test) => test.group === undefined ? {} : { group: test.group };
 export default class TestReporter {
     constructor(options) {
         this.testResults = new Map();
@@ -14,6 +16,7 @@ export default class TestReporter {
         this.output =
             options.output ?? path.join(projectDir(), "result/report.json");
         this.listener = options.onEvent;
+        this.shard = options.shard;
     }
     emit(event) {
         try {
@@ -43,6 +46,7 @@ export default class TestReporter {
             total,
             browsers: this.browsers,
             ...(workers > 1 && { workers }),
+            ...(this.shard && { shard: this.shard }),
         });
     }
     async onEnd() {
@@ -61,6 +65,7 @@ export default class TestReporter {
             duration,
             environment: this.environment,
             browsers: this.browsers,
+            ...(this.shard && { shard: this.shard }),
             tests,
             status: tests.every((r) => r.status === "success" || r.status === "skipped")
                 ? "success"
@@ -82,6 +87,7 @@ export default class TestReporter {
             name: test.name,
             file: test.file,
             browser,
+            ...groupOf(test),
             status: "started",
             startTime: t.startTime,
         });
@@ -90,6 +96,7 @@ export default class TestReporter {
             name: test.name,
             file: test.file,
             browser,
+            ...groupOf(test),
             ...(retry ? { retry } : {}),
         });
     }
@@ -111,6 +118,7 @@ export default class TestReporter {
             name: test.name,
             file: test.file,
             browser,
+            ...groupOf(test),
             result,
         });
     }
@@ -131,6 +139,7 @@ export default class TestReporter {
             name: test.name,
             file: test.file,
             browser,
+            ...groupOf(test),
             result: ended,
         });
     }
@@ -148,6 +157,9 @@ export default class TestReporter {
             ...(extras?.screenshots?.length && { screenshots: extras.screenshots }),
             ...(extras?.inputs && { inputs: extras.inputs }),
             ...(extras?.outputs && { outputs: extras.outputs }),
+            ...(extras?.attachments && { attachments: extras.attachments }),
+            ...(extras?.annotations && { annotations: extras.annotations }),
+            ...(extras?.steps && { steps: extras.steps }),
             ...(extras?.retry && { retry: extras.retry }),
             ...(extras?.flaky && { flaky: true }),
             ...(extras?.previousAttempts?.length && {
@@ -160,6 +172,7 @@ export default class TestReporter {
             name: test.name,
             file: test.file,
             browser,
+            ...groupOf(test),
             result,
         });
     }

package/dist/runner/request-fixture.d.ts

@@ -0,0 +1,14 @@
+import type { APIRequestContext } from "../request/api-request-context.js";
+import type { UseOptions } from "../types/use.js";
+/**
+ * The `request` fixture of one test: an `APIRequestContext` of its own (its own cookies), made when the test first
+ * reads it, from the run's `baseURL` and the `use` options, and disposed when the test is over
+ */
+export declare class RequestFixture {
+    private readonly baseURL;
+    private readonly use;
+    private context;
+    constructor(baseURL: string | undefined, use: UseOptions);
+    get(): APIRequestContext;
+    dispose(): Promise<void>;
+}

package/dist/runner/request-fixture.js

@@ -0,0 +1,25 @@
+import { createRequestContext } from "../request/request.js";
+/**
+ * The `request` fixture of one test: an `APIRequestContext` of its own (its own cookies), made when the test first
+ * reads it, from the run's `baseURL` and the `use` options, and disposed when the test is over
+ */
+export class RequestFixture {
+    constructor(baseURL, use) {
+        this.baseURL = baseURL;
+        this.use = use;
+    }
+    get() {
+        const { use } = this;
+        return (this.context ??= createRequestContext({
+            baseURL: this.baseURL,
+            extraHTTPHeaders: use.extraHTTPHeaders,
+            ignoreHTTPSErrors: use.acceptInsecureCerts,
+            ...(use.storageState !== undefined && {
+                storageState: use.storageState,
+            }),
+        }));
+    }
+    async dispose() {
+        await this.context?.dispose();
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { RunSettings } from "../config/run-settings.js";
+import type { SamuraiTestConfig } from "../types/config.js";
+/**
+ * Runs `work` between the config's run-level steps: web servers start, then `globalSetup`, then `work`, then
+ * `globalTeardown`, then the servers stop. The teardown runs when the work or the setup throws (not when a server
+ * failed to start, since nothing was set up), and the servers are stopped whatever happens. When the config has no
+ * `baseURL` for the run, the first server's address becomes `settings.baseURL`.
+ * Errors: a failed start is `webServer(): ...`, a failed setup `globalSetup(): ...`; the work's own error wins over
+ * a teardown error, which is logged then.
+ */
+export declare function withRunHooks<T>(run: {
+    config: SamuraiTestConfig;
+    settings: RunSettings;
+    projectDir: string;
+    signal?: AbortSignal | undefined;
+}, work: () => Promise<T>): Promise<T>;