@itmetsam/samurai-framework 0.12.0 → 0.15.0

package/dist/runner/pooled-run.js

@@ -1,19 +1,25 @@
 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.
  */
 export function planItems(selected, browsers, serialKey) {
     const planned = browsers.flatMap((browser) => selected.map((test) => ({ test, browser })));
-    const items = planned.map(({ test, browser }, index) => {
+    // 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);
-        return {
-            index,
-            file: test.file,
-            testName: test.name,
-            browser,
-            ...(key !== undefined && { serialKey: key }),
-        };
+        return [
+            {
+                index,
+                file: test.file,
+                testName: test.name,
+                browser,
+                ...(key !== undefined && { serialKey: key }),
+            },
+        ];
     });
     return { items, planned };
 }
@@ -32,6 +38,21 @@ 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.
+ */
+export function concurrency(items) {
+    const keys = new Set();
+    let free = 0;
+    for (const item of items) {
+        if (item.serialKey === undefined)
+            free++;
+        else
+            keys.add(item.serialKey);
+    }
+    return free + keys.size;
+}
 /**
  * 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)
@@ -42,11 +63,17 @@ export function poolMode(input) {
     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
+ * Runs the planned items on the pool and reports them as they happen. Tests that do not run (skip, fixme) are
+ * reported first, here, and never reach a worker. 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);
+    for (const { test, browser } of planned) {
+        const annotation = staticSkip(test);
+        if (annotation)
+            reporter.onTestSkipped(test, browser, { annotation });
+    }
     const started = new Set();
     const ended = new Set();
     const begin = (index) => {
@@ -68,7 +95,8 @@ export async function runPooled(pool, planned, items, reporter, signal) {
             ? begin(event.item.index)
             : end(event.item.index, event.result),
     });
-    results.forEach((result, index) => {
+    results.forEach((result, position) => {
+        const index = items[position].index;
         if (!ended.has(index))
             end(index, result);
     });

package/dist/runner/project.js

@@ -1,7 +1,9 @@
+import path from "node:path";
 import { removeGeneratedFiles } from "../browser/generated-files.js";
 import { loadConfig, projectDir, setActiveProject } from "../config/config.js";
 import { resetSecrets } from "../config/mask.js";
 import { setRunSettings } from "../config/run-settings.js";
+import { keepLogFiles } from "../logger/index.js";
 import { prepareRun } from "./prepare-run.js";
 let active = false;
 /**
@@ -14,6 +16,8 @@ export async function withProject(options, work) {
     active = true;
     const { projectDir: dir, config, dataDir, environment, timeout, expectTimeout, headless, } = options;
     const previousDir = projectDir();
+    // The log goes to the project's `logs/` folder, not to wherever this process was started
+    const releaseLogs = keepLogFiles(path.resolve(dir ?? previousDir));
     try {
         setActiveProject({ dir: dir ?? previousDir, config, dataDir });
         const loaded = config ?? (await loadConfig());
@@ -32,5 +36,6 @@ export async function withProject(options, work) {
         setRunSettings(undefined);
         setActiveProject(undefined);
         active = false;
+        releaseLogs();
     }
 }

package/dist/runner/registry.d.ts

@@ -1,7 +1,38 @@
-import type { RegisteredTestCase, TestCaseBase } from "../types/test.js";
-/** Groups the tests registered inside `fn` under `title`. `fn` runs immediately and must be synchronous. */
-export declare function describe(title: string, fn: () => void): void;
-export declare function test(title: string, fn: TestCaseBase["function"]): void;
+import type { AllHook, EachHook, RegisteredTestCase, TestCaseBase } 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;
+    /** 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;
+}
+/** With a title and a body it registers a skipped test; with a condition it skips the running test when the condition is true */
+interface SkipFunction {
+    (title: string, fn: Body): void;
+    (condition: boolean, reason?: string): void;
+}
+/** `describe(title, fn)` and the same with a modifier on every test inside */
+export interface DescribeFunction {
+    (title: string, fn: () => void): void;
+    skip(title: string, fn: () => void): void;
+    fixme(title: string, fn: () => void): void;
+    only(title: string, fn: () => void): void;
+}
+export declare const test: TestFunction;
+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;
+/** Runs after each test of the `describe` block it is written in, also when the test failed */
+export declare function afterEach(hook: EachHook): void;
+/** Runs once per worker, before the first test of its `describe` block that the worker runs. It gets no page. */
+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 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,11 +1,11 @@
 import { fileURLToPath } from "node:url";
 import logger from "../logger/index.js";
+import { SkipSignal } from "./skip.js";
+import { addHook, currentSuite, enterSuite, leaveSuite, modifierOf, resetSuites, } from "./suite.js";
 const registered = [];
-/** Titles of the describe blocks being registered, outermost first */
-const titleStack = [];
-/** Groups the tests registered inside `fn` under `title`. `fn` runs immediately and must be synchronous. */
-export function describe(title, fn) {
-    titleStack.push(title);
+/** 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) {
+    enterSuite(file, title, modifier);
     try {
         const result = fn();
         if (result instanceof Promise) {
@@ -14,24 +14,79 @@ export function describe(title, fn) {
         }
     }
     finally {
-        titleStack.pop();
+        leaveSuite();
     }
 }
-export function test(title, fn) {
-    const titlePath = [...titleStack, title];
+function add(file, title, fn, modifier) {
+    const suite = currentSuite(file);
+    const titlePath = [...titlesOf(suite), title];
     const name = titlePath.join(" > ");
-    registered.push({ name, titlePath, function: fn, file: callerFile() });
+    const effective = modifierOf(modifier, suite);
+    registered.push({
+        name,
+        titlePath,
+        function: fn,
+        file,
+        suite,
+        ...(effective && { modifier: effective }),
+    });
     logger.debug("Registered test %s", name);
 }
+/** The `describe` titles from the file down to `suite` */
+function titlesOf(suite) {
+    const titles = [];
+    for (let s = suite; s; s = s.parent)
+        if (s.title !== undefined)
+            titles.unshift(s.title);
+    return titles;
+}
+/** `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) {
+    return ((first, second) => {
+        if (typeof first === "string") {
+            // Frames: Error, callerFile, this function, the spec
+            add(callerFile(), first, second, annotation);
+            return;
+        }
+        if (first)
+            throw new SkipSignal(annotation, second);
+    });
+}
+export const test = Object.assign((title, fn) => add(callerFile(), title, fn), {
+    skip: skipping("skip"),
+    fixme: skipping("fixme"),
+    only: (title, fn) => add(callerFile(), title, fn, "only"),
+});
+export const describe = Object.assign((title, fn) => openDescribe(callerFile(), title, fn), {
+    skip: (title, fn) => openDescribe(callerFile(), title, fn, "skip"),
+    fixme: (title, fn) => openDescribe(callerFile(), title, fn, "fixme"),
+    only: (title, fn) => openDescribe(callerFile(), title, fn, "only"),
+});
+/** Runs before each test of the `describe` block it is written in (of the file, at the top level) */
+export function beforeEach(hook) {
+    addHook(currentSuite(callerFile()), "beforeEach", hook);
+}
+/** Runs after each test of the `describe` block it is written in, also when the test failed */
+export function afterEach(hook) {
+    addHook(currentSuite(callerFile()), "afterEach", hook);
+}
+/** Runs once per worker, before the first test of its `describe` block that the worker runs. It gets no page. */
+export function beforeAll(hook) {
+    addHook(currentSuite(callerFile()), "beforeAll", hook);
+}
+/** Runs once per worker, when the worker is done, for every `describe` block it ran a `beforeAll` for */
+export function afterAll(hook) {
+    addHook(currentSuite(callerFile()), "afterAll", hook);
+}
 export function registeredTests() {
     return registered;
 }
 /** Forgets every registered test: a run registers its specs afresh */
 export function clearRegistry() {
     registered.length = 0;
-    titleStack.length = 0;
+    resetSuites();
 }
-/** File of the code that called test(): stack lines are Error, callerFile, test, caller */
+/** File of the code that called the entry point: stack lines are Error, callerFile, the entry point, the caller */
 function callerFile() {
     const caller = new Error().stack?.split("\n")[3] ?? "";
     const match = caller.match(/\((.+?):\d+:\d+\)$/) ?? caller.match(/at (.+?):\d+:\d+$/);

package/dist/runner/reporter.d.ts

@@ -38,6 +38,13 @@ export interface ReporterOptions {
 export interface TestSink {
     onTestStart(test: RegisteredTestCase, browser: SupportedBrowser): void;
     onTestEnd(test: RegisteredTestCase, browser: SupportedBrowser, error?: TestError, extras?: TestEndExtras): void;
+    /** A test that does not run: reported as started and ended at once */
+    onTestSkipped(test: RegisteredTestCase, browser: SupportedBrowser, skip: TestSkip): void;
+}
+/** Why a test was skipped */
+export interface TestSkip {
+    annotation: "skip" | "fixme";
+    reason?: string | undefined;
 }
 /** What a test's report entry lists besides its status */
 export interface TestEndExtras {
@@ -67,6 +74,7 @@ export default class TestReporter implements TestSink {
     onStart(total: number, workers?: number): void;
     onEnd(): Promise<TestSummary>;
     onTestStart(test: RegisteredTestCase, browser: SupportedBrowser): void;
+    onTestSkipped(test: RegisteredTestCase, browser: SupportedBrowser, { annotation, reason }: TestSkip): 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

package/dist/runner/reporter.js

@@ -62,7 +62,7 @@ export default class TestReporter {
             environment: this.environment,
             browsers: this.browsers,
             tests,
-            status: tests.every((r) => r.status === "success")
+            status: tests.every((r) => r.status === "success" || r.status === "skipped")
                 ? "success"
                 : "failed",
         };
@@ -92,6 +92,27 @@ export default class TestReporter {
             browser,
         });
     }
+    onTestSkipped(test, browser, { annotation, reason }) {
+        const key = keyOf(test, browser);
+        // A test skipped from inside already started; one that never ran starts and ends at once
+        if (this.testResults.get(key)?.status !== "started")
+            this.onTestStart(test, browser);
+        const result = maskDeep({
+            ...this.testResults.get(key),
+            status: "skipped",
+            duration: 0,
+            annotation,
+            ...(reason !== undefined && { reason }),
+        });
+        this.testResults.set(key, result);
+        this.emit({
+            type: "test-end",
+            name: test.name,
+            file: test.file,
+            browser,
+            result,
+        });
+    }
     /**
      * 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

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

@@ -1,6 +1,7 @@
 import type { SupportedBrowser } from "../types/browser.js";
-import type { RegisteredTestCase } from "../types/test.js";
+import type { AllHookFixtures, RegisteredTestCase } from "../types/test.js";
 import type { RunnerOptions } from "./options.js";
+import type { AllHooks } from "./all-hooks.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 */
@@ -11,6 +12,10 @@ export interface WorkerResources {
     profileDir?: string;
     /** The `workerIndex` fixture. @default 0 */
     workerIndex?: number;
+    /** The `beforeAll` / `afterAll` hooks of this worker: kept across tests, closed when the worker is done */
+    allHooks?: AllHooks;
 }
+/** What `beforeAll` and `afterAll` hooks get: no page, only what a run knows */
+export declare function allHookFixtures(run: PreparedRun, browserName: SupportedBrowser, workerIndex?: number): AllHookFixtures;
 /** 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>;

package/dist/runner/run-test.js

@@ -9,6 +9,8 @@ import logger from "../logger/index.js";
 import { ConnectionClosedError } from "../transport/bidi-connection.js";
 import { judgePageLogs } from "./page-logs-report.js";
 import { DEFAULT_PORT } from "./ports.js";
+import { runWithEachHooks } from "./hooks.js";
+import { isSkipSignal } from "./skip.js";
 import { testDirOf } from "./test-dir.js";
 import { toTestError } from "./test-error.js";
 /**
@@ -30,6 +32,16 @@ class TestOutcome {
     get isEnded() {
         return this.ended;
     }
+    /** The test skipped itself (`test.skip(condition)`): reported as skipped, not as a failure */
+    skip(signal) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.reporter.onTestSkipped(this.test, this.browser, {
+            annotation: signal.annotation,
+            reason: signal.reason,
+        });
+    }
     finish(error, logs) {
         if (this.ended)
             return;
@@ -40,6 +52,16 @@ class TestOutcome {
         });
     }
 }
+/** What `beforeAll` and `afterAll` hooks get: no page, only what a run knows */
+export function allHookFixtures(run, browserName, workerIndex = 0) {
+    const { settings, secrets } = run;
+    return {
+        browserName,
+        workerIndex,
+        env: createEnvFixture(settings.environment, settings.variables),
+        secrets: createSecretsFixture(settings.environment, secrets),
+    };
+}
 /** Runs one test in one browser and reports it: launch, run the body, judge the page's logs, close the browser */
 export async function runOneTest(test, browserName, run, options, srcDir, reporter, resources = {}) {
     logger.verbose("Starting test: %s in %s", test.name, browserName);
@@ -81,6 +103,8 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
     /** Launches the browser, runs the test body and reports how it went */
     const runBody = async () => {
         try {
+            // The `beforeAll` hooks come first, before a browser exists
+            await resources.allHooks?.ensure(test, browserName);
             const launched = await Browser.launch(browserName, {
                 port: resources.port ?? options.port ?? DEFAULT_PORT,
                 ...(resources.profileDir && { profileDir: resources.profileDir }),
@@ -111,7 +135,7 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
                 env: createEnvFixture(settings.environment, settings.variables),
                 secrets: createSecretsFixture(settings.environment, secrets),
             };
-            await test.function(fixtures);
+            await runWithEachHooks(test.suite, fixtures, timeoutController.signal, () => test.function(fixtures));
             // Already reported as timed out
             if (timeoutController.signal.aborted)
                 return;
@@ -131,6 +155,8 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
         catch (err) {
             if (timeoutController.signal.aborted)
                 return;
+            if (isSkipSignal(err))
+                return outcome.skip(err);
             outcome.finish(outcome.browserClosed || err instanceof ConnectionClosedError
                 ? {
                     message: "The browser was closed while the test was running",

package/dist/runner/run.d.ts

@@ -1,4 +1,4 @@
-import type { TestSummary } from "../types/test.js";
+import type { Modifier, TestSummary } from "../types/test.js";
 import { type ProjectOptions } from "./project.js";
 import type { ResolvedGroup } from "./groups.js";
 import type { RunnerOptions } from "./options.js";
@@ -19,6 +19,8 @@ export interface FoundTest {
     /** Full name: `describe` titles and the test title joined with " > " */
     name: string;
     file: string;
+    /** `skip` or `fixme` (not run), or `only` (focused); absent for a plain test. A modifier on a `describe` counts. */
+    modifier?: Modifier;
 }
 /** Imports the project's specs without running anything and lists the tests the options select */
 export declare function listTests(options?: RunTestsOptions): Promise<FoundTest[]>;
@@ -27,7 +29,7 @@ export declare function listGroups(options?: RunTestsOptions): Promise<ResolvedG
 export { BROWSER_NAMES, checkBrowserList } from "../config/browsers.js";
 export { parseWorkers } from "../config/workers.js";
 export type { RunEvent } from "./reporter.js";
-export type { TestError, TestResult, TestSummary } from "../types/test.js";
+export type { Modifier, TestError, TestResult, TestSummary, } from "../types/test.js";
 export type { ResolvedGroup } from "./groups.js";
 export type { RunnerOptions } from "./options.js";
 export type { ProjectOptions } from "./project.js";

package/dist/runner/run.js

@@ -35,7 +35,11 @@ export async function runTests(options = {}) {
 }
 /** Imports the project's specs without running anything and lists the tests the options select */
 export async function listTests(options = {}) {
-    return inProject(options, async (runner) => (await runner.register()).map(({ name, file }) => ({ name, file })));
+    return inProject(options, async (runner) => (await runner.register()).map(({ name, file, modifier }) => ({
+        name,
+        file,
+        ...(modifier && { modifier }),
+    })));
 }
 /** Imports the project's specs without running anything and lists the config's groups with the tests each holds */
 export async function listGroups(options = {}) {

package/dist/runner/skip.d.ts

@@ -0,0 +1,10 @@
+import type { RegisteredTestCase } from "../types/test.js";
+/** Thrown by `test.skip(condition, reason)` and `test.fixme(condition, reason)` inside a test: the test ends as skipped */
+export declare class SkipSignal extends Error {
+    readonly annotation: "skip" | "fixme";
+    readonly reason?: string | undefined;
+    constructor(annotation: "skip" | "fixme", reason?: string | undefined);
+}
+export declare function isSkipSignal(error: unknown): error is SkipSignal;
+/** Why a test does not run at all: it is marked `skip` or `fixme`, itself or by a `describe` around it */
+export declare function staticSkip(test: Pick<RegisteredTestCase, "modifier">): "skip" | "fixme" | undefined;

package/dist/runner/skip.js

@@ -0,0 +1,18 @@
+/** Thrown by `test.skip(condition, reason)` and `test.fixme(condition, reason)` inside a test: the test ends as skipped */
+export class SkipSignal extends Error {
+    constructor(annotation, reason) {
+        super(reason ?? "skipped");
+        this.annotation = annotation;
+        this.reason = reason;
+        this.name = "SkipSignal";
+    }
+}
+export function isSkipSignal(error) {
+    return error instanceof SkipSignal;
+}
+/** Why a test does not run at all: it is marked `skip` or `fixme`, itself or by a `describe` around it */
+export function staticSkip(test) {
+    return test.modifier === "skip" || test.modifier === "fixme"
+        ? test.modifier
+        : undefined;
+}

package/dist/runner/suite.d.ts

@@ -0,0 +1,24 @@
+import type { EachHook, Modifier, Suite } from "../types/test.js";
+/** The four hook lists a suite can hold */
+export type HookKind = "beforeEach" | "afterEach" | "beforeAll" | "afterAll";
+export declare function newSuite(title?: string, parent?: Suite, modifier?: Modifier): Suite;
+/** The suite a test or hook written now belongs to: the innermost open `describe`, else the file's own */
+export declare function currentSuite(file: string): Suite;
+/** Opens a `describe` block under the current suite; `leaveSuite` closes it */
+export declare function enterSuite(file: string, title: string, modifier?: Modifier): Suite;
+export declare function leaveSuite(): void;
+/** Forgets every suite: a run registers its specs afresh */
+export declare function resetSuites(): void;
+/**
+ * What applies to a test: the innermost `skip` or `fixme` (the test's own, then its suites', inside out), else
+ * `only` when the test or any suite around it is focused. A skip beats a focus.
+ */
+export declare function modifierOf(own: Modifier | undefined, suite: Suite): Modifier | undefined;
+/** The suites from the file's root down to `suite` */
+export declare function suiteChain(suite: Suite): Suite[];
+/** The `beforeEach` hooks of a test: outermost suite first, in the order they were written */
+export declare function beforeEachOf(suite: Suite): EachHook[];
+/** The `afterEach` hooks of a test: innermost suite first, in the order they were written */
+export declare function afterEachOf(suite: Suite): EachHook[];
+/** Adds a hook to the suite being registered */
+export declare function addHook<K extends HookKind>(suite: Suite, kind: K, hook: NonNullable<Suite[K]>[number]): void;

package/dist/runner/suite.js

@@ -0,0 +1,73 @@
+/** One root suite per spec file; a `describe` block is a child of the suite it is written in */
+const roots = new Map();
+/** The `describe` blocks being registered, outermost first */
+const open = [];
+export function newSuite(title, parent, modifier) {
+    return {
+        ...(title !== undefined && { title }),
+        ...(parent && { parent }),
+        ...(modifier && { modifier }),
+    };
+}
+/** The suite a test or hook written now belongs to: the innermost open `describe`, else the file's own */
+export function currentSuite(file) {
+    const inner = open[open.length - 1];
+    if (inner)
+        return inner;
+    let root = roots.get(file);
+    if (!root) {
+        root = newSuite();
+        roots.set(file, root);
+    }
+    return root;
+}
+/** Opens a `describe` block under the current suite; `leaveSuite` closes it */
+export function enterSuite(file, title, modifier) {
+    const suite = newSuite(title, currentSuite(file), modifier);
+    open.push(suite);
+    return suite;
+}
+export function leaveSuite() {
+    open.pop();
+}
+/** Forgets every suite: a run registers its specs afresh */
+export function resetSuites() {
+    roots.clear();
+    open.length = 0;
+}
+/**
+ * What applies to a test: the innermost `skip` or `fixme` (the test's own, then its suites', inside out), else
+ * `only` when the test or any suite around it is focused. A skip beats a focus.
+ */
+export function modifierOf(own, suite) {
+    let focused = own === "only";
+    let found = own === "only" ? undefined : own;
+    for (let s = suite; s && !found; s = s.parent) {
+        if (s.modifier === "only")
+            focused = true;
+        else
+            found = s.modifier;
+    }
+    return found ?? (focused ? "only" : undefined);
+}
+/** The suites from the file's root down to `suite` */
+export function suiteChain(suite) {
+    const chain = [];
+    for (let s = suite; s; s = s.parent)
+        chain.unshift(s);
+    return chain;
+}
+/** The `beforeEach` hooks of a test: outermost suite first, in the order they were written */
+export function beforeEachOf(suite) {
+    return suiteChain(suite).flatMap((s) => s.beforeEach ?? []);
+}
+/** The `afterEach` hooks of a test: innermost suite first, in the order they were written */
+export function afterEachOf(suite) {
+    return suiteChain(suite)
+        .reverse()
+        .flatMap((s) => s.afterEach ?? []);
+}
+/** Adds a hook to the suite being registered */
+export function addHook(suite, kind, hook) {
+    (suite[kind] ??= []).push(hook);
+}

package/dist/runner/test-error.js

@@ -1,6 +1,10 @@
 import { AssertionError, toReportValue } from "../assert/assertion-error.js";
+import { HookError } from "./hooks.js";
 /** Maps anything a test threw to the error stored in the report */
 export function toTestError(err) {
+    // A hook's failure keeps what it threw (an assertion stays one) under the hook's own message
+    if (err instanceof HookError)
+        return { ...toTestError(err.cause), message: err.message };
     if (err instanceof AssertionError) {
         return {
             message: err.message,