@itmetsam/samurai-framework 0.21.5 → 0.22.0

package/dist/request/cookie-jar.js

@@ -0,0 +1,164 @@
+const SAME_SITE = { strict: "Strict", lax: "Lax", none: "None" };
+const INTEGER = /^-?\d+$/;
+function isLoopback(host) {
+    return (host === "localhost" || host === "[::1]" || /^127(\.\d+){3}$/.test(host));
+}
+/** The default path of a cookie set without `Path`: the directory of the request path */
+function defaultPath(pathname) {
+    const last = pathname.lastIndexOf("/");
+    return pathname.startsWith("/") && last > 0 ? pathname.slice(0, last) : "/";
+}
+function domainMatches(host, domain) {
+    return host === domain || host.endsWith(`.${domain}`);
+}
+/**
+ * One `Set-Cookie` header of a response from `url`. `undefined` for a header that is not a cookie (no name, or a
+ * `Domain` the host does not belong to, which a browser would refuse as well).
+ */
+export function parseSetCookie(header, url, now = Date.now()) {
+    const [pair = "", ...attributes] = header.split(";");
+    const eq = pair.indexOf("=");
+    if (eq < 0)
+        return undefined;
+    const name = pair.slice(0, eq).trim();
+    if (name === "")
+        return undefined;
+    const cookie = {
+        name,
+        value: pair.slice(eq + 1).trim(),
+        domain: url.hostname.toLowerCase(),
+        hostOnly: true,
+        path: defaultPath(url.pathname),
+        secure: false,
+        httpOnly: false,
+    };
+    let maxAge;
+    for (const attribute of attributes) {
+        const at = attribute.indexOf("=");
+        const key = (at < 0 ? attribute : attribute.slice(0, at))
+            .trim()
+            .toLowerCase();
+        const value = at < 0 ? "" : attribute.slice(at + 1).trim();
+        if (key === "domain" && value !== "") {
+            const domain = value.replace(/^\./, "").toLowerCase();
+            if (!domainMatches(cookie.domain, domain))
+                return undefined;
+            cookie.domain = domain;
+            cookie.hostOnly = false;
+        }
+        else if (key === "path" && value.startsWith("/"))
+            cookie.path = value;
+        else if (key === "secure")
+            cookie.secure = true;
+        else if (key === "httponly")
+            cookie.httpOnly = true;
+        else if (key === "samesite" && value.toLowerCase() in SAME_SITE)
+            cookie.sameSite =
+                SAME_SITE[value.toLowerCase()];
+        else if (key === "max-age" && INTEGER.test(value))
+            maxAge = Number(value);
+        else if (key === "expires") {
+            const time = Date.parse(value);
+            if (!Number.isNaN(time))
+                cookie.expires = Math.floor(time / 1000);
+        }
+    }
+    // Max-Age wins over Expires
+    if (maxAge !== undefined)
+        cookie.expires = maxAge <= 0 ? 0 : Math.floor(now / 1000) + maxAge;
+    return cookie;
+}
+export function isExpired(cookie, now = Date.now()) {
+    return cookie.expires !== undefined && cookie.expires * 1000 <= now;
+}
+/**
+ * Whether a request to `url` carries `cookie`: host, path, `Secure` (https, or a loopback host the browsers treat
+ * as secure) and expiry. `SameSite` is not applied: a request made by the test is not made from another site.
+ */
+export function cookieMatches(cookie, url, now = Date.now()) {
+    if (isExpired(cookie, now))
+        return false;
+    const host = url.hostname.toLowerCase();
+    if (cookie.hostOnly
+        ? host !== cookie.domain
+        : !domainMatches(host, cookie.domain))
+        return false;
+    const { path } = cookie;
+    const here = url.pathname || "/";
+    const underPath = here === path ||
+        (here.startsWith(path) &&
+            (path.endsWith("/") || here[path.length] === "/"));
+    if (!underPath)
+        return false;
+    return !cookie.secure || url.protocol === "https:" || isLoopback(host);
+}
+/** The `Cookie` header value for `cookies`: the longest path first, as a browser sends them */
+export function cookieHeaderOf(cookies) {
+    if (cookies.length === 0)
+        return undefined;
+    return [...cookies]
+        .sort((a, b) => b.path.length - a.path.length)
+        .map((cookie) => `${cookie.name}=${cookie.value}`)
+        .join("; ");
+}
+/** The cookies of an in-memory request context: what its responses set, and what a storage state seeded */
+export class CookieJar {
+    constructor(seed = []) {
+        this.cookies = [];
+        for (const cookie of seed)
+            this.put(fromStorageState(cookie));
+    }
+    cookieHeader(url) {
+        const now = Date.now();
+        this.cookies = this.cookies.filter((cookie) => !isExpired(cookie, now));
+        return Promise.resolve(cookieHeaderOf(this.cookies.filter((c) => cookieMatches(c, url, now))));
+    }
+    store(url, setCookies) {
+        for (const header of setCookies) {
+            const cookie = parseSetCookie(header, url);
+            if (cookie)
+                this.put(cookie);
+        }
+        return Promise.resolve();
+    }
+    list() {
+        const now = Date.now();
+        return Promise.resolve(this.cookies
+            .filter((cookie) => !isExpired(cookie, now))
+            .map(toStorageState));
+    }
+    /** Replaces the cookie with the same name, domain and path; an expired one only removes it */
+    put(cookie) {
+        this.cookies = this.cookies.filter((old) => old.name !== cookie.name ||
+            old.domain !== cookie.domain ||
+            old.path !== cookie.path);
+        if (!isExpired(cookie))
+            this.cookies.push(cookie);
+    }
+}
+function fromStorageState(cookie) {
+    return {
+        name: cookie.name,
+        value: cookie.value,
+        domain: cookie.domain.replace(/^\./, "").toLowerCase(),
+        hostOnly: !cookie.domain.startsWith("."),
+        path: cookie.path ?? "/",
+        secure: cookie.secure ?? false,
+        httpOnly: cookie.httpOnly ?? false,
+        ...(cookie.sameSite !== undefined && { sameSite: cookie.sameSite }),
+        ...(cookie.expires !== undefined &&
+            cookie.expires > 0 && { expires: cookie.expires }),
+    };
+}
+function toStorageState(cookie) {
+    return {
+        name: cookie.name,
+        value: cookie.value,
+        domain: cookie.hostOnly ? cookie.domain : `.${cookie.domain}`,
+        path: cookie.path,
+        expires: cookie.expires ?? -1,
+        httpOnly: cookie.httpOnly,
+        secure: cookie.secure,
+        sameSite: cookie.sameSite ?? "Lax",
+    };
+}

package/dist/request/http-transport.d.ts

@@ -0,0 +1,31 @@
+import type { HeaderEntry } from "./api-response.js";
+/** One request to send, a single hop: redirects are the caller's business */
+export interface HopRequest {
+    url: URL;
+    method: string;
+    /** Names lower-cased */
+    headers: Record<string, string>;
+    body?: Buffer | undefined;
+    ignoreHTTPSErrors: boolean;
+    /** Milliseconds this hop may take; 0 is no limit */
+    timeout: number;
+    signal: AbortSignal;
+}
+export interface HopResponse {
+    status: number;
+    statusText: string;
+    headers: HeaderEntry[];
+    /** The `Set-Cookie` headers, one entry each */
+    setCookies: string[];
+    /** Decoded: `Content-Encoding` is already undone */
+    body: Buffer;
+}
+/** A request that failed before a response was complete */
+export declare class TransportError extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+/** The url without credentials or query: what an error may say about where the request went */
+export declare function describeURL(url: URL): string;
+/** Sends one request over `http` or `https` and reads the whole response. Errors never include header values. */
+export declare function sendHop(request: HopRequest): Promise<HopResponse>;

package/dist/request/http-transport.js

@@ -0,0 +1,113 @@
+import http from "node:http";
+import https from "node:https";
+import zlib from "node:zlib";
+/** A request that failed before a response was complete */
+export class TransportError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "TransportError";
+    }
+}
+function decode(body, encoding) {
+    if (body.length === 0)
+        return body;
+    switch (encoding?.trim().toLowerCase()) {
+        case "gzip":
+        case "x-gzip":
+            return zlib.gunzipSync(body);
+        case "br":
+            return zlib.brotliDecompressSync(body);
+        case "deflate":
+            try {
+                return zlib.inflateSync(body);
+            }
+            catch {
+                // Some servers send deflate without the zlib header
+                return zlib.inflateRawSync(body);
+            }
+        default:
+            return body;
+    }
+}
+/** The url without credentials or query: what an error may say about where the request went */
+export function describeURL(url) {
+    return `${url.origin}${url.pathname}`;
+}
+/** Sends one request over `http` or `https` and reads the whole response. Errors never include header values. */
+export function sendHop(request) {
+    const { url, method, headers, body, signal } = request;
+    const where = `${method} ${describeURL(url)}`;
+    return new Promise((resolve, reject) => {
+        if (signal.aborted)
+            return reject(new TransportError(`request aborted (${where})`));
+        const transport = url.protocol === "https:" ? https : http;
+        let settled = false;
+        let timer;
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const req = transport.request(url, {
+            method,
+            headers: {
+                ...headers,
+                ...(body && { "content-length": String(body.length) }),
+            },
+            // No shared pool: nothing stays open after the last request
+            agent: false,
+            ...(url.protocol === "https:" && {
+                rejectUnauthorized: !request.ignoreHTTPSErrors,
+            }),
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("error", (err) => finish(new TransportError(`${err.message} (${where})`)));
+            res.on("end", () => {
+                try {
+                    const raw = res.rawHeaders;
+                    const entries = [];
+                    for (let i = 0; i + 1 < raw.length; i += 2)
+                        entries.push({
+                            name: raw[i],
+                            value: raw[i + 1],
+                        });
+                    const decoded = method === "HEAD"
+                        ? Buffer.alloc(0)
+                        : decode(Buffer.concat(chunks), res.headers["content-encoding"]);
+                    finish(undefined, {
+                        status: res.statusCode ?? 0,
+                        statusText: res.statusMessage ?? "",
+                        headers: entries,
+                        setCookies: res.headers["set-cookie"] ?? [],
+                        body: decoded,
+                    });
+                }
+                catch (err) {
+                    finish(new TransportError(`the response body could not be decoded: ${err.message} (${where})`));
+                }
+            });
+        });
+        const onAbort = () => {
+            req.destroy();
+            finish(new TransportError(`request aborted (${where})`));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        timer =
+            request.timeout > 0
+                ? setTimeout(() => {
+                    req.destroy();
+                    finish(new TransportError(`timed out after ${request.timeout}ms (${where})`, "ETIMEDOUT"));
+                }, request.timeout)
+                : undefined;
+        req.on("error", (err) => finish(new TransportError(`${err.code ?? err.message} (${where})`, err.code)));
+        req.end(body);
+    });
+}

package/dist/request/redirect.d.ts

@@ -0,0 +1,10 @@
+/** Where a response sends the client next: its `Location` against the URL it came from; `undefined` when it does not redirect */
+export declare function redirectTarget(status: number, location: string | undefined, from: URL): URL | undefined;
+/**
+ * The method and body of the request that follows a redirect. 303 (any method but GET and HEAD) and 301/302 after
+ * a POST turn into a GET without a body; 307 and 308 keep both.
+ */
+export declare function followUp<B>(status: number, method: string, body: B | undefined): {
+    method: string;
+    body: B | undefined;
+};

package/dist/request/redirect.js

@@ -0,0 +1,21 @@
+const REDIRECTS = new Set([301, 302, 303, 307, 308]);
+/** Where a response sends the client next: its `Location` against the URL it came from; `undefined` when it does not redirect */
+export function redirectTarget(status, location, from) {
+    if (!REDIRECTS.has(status) || !location)
+        return undefined;
+    try {
+        return new URL(location, from);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The method and body of the request that follows a redirect. 303 (any method but GET and HEAD) and 301/302 after
+ * a POST turn into a GET without a body; 307 and 308 keep both.
+ */
+export function followUp(status, method, body) {
+    const upgrades = (status === 303 && method !== "GET" && method !== "HEAD") ||
+        ((status === 301 || status === 302) && method === "POST");
+    return upgrades ? { method: "GET", body: undefined } : { method, body };
+}

package/dist/request/request-body.d.ts

@@ -0,0 +1,27 @@
+/** A file in a `multipart` body */
+export interface FilePayload {
+    name: string;
+    /** @default "application/octet-stream" */
+    mimeType?: string;
+    buffer: Buffer;
+}
+type Scalar = string | number | boolean;
+/** The body options of a request: at most one is set */
+export interface BodyOptions {
+    /** Sent as it is (a string, a `Buffer`), or as JSON (anything else) */
+    data?: string | Buffer | object | number | boolean | null;
+    /** Sent as `application/x-www-form-urlencoded` */
+    form?: Record<string, Scalar> | URLSearchParams;
+    /** Sent as `multipart/form-data`: fields and files */
+    multipart?: Record<string, Scalar | FilePayload>;
+}
+export interface EncodedBody {
+    body: Buffer;
+    contentType: string;
+}
+/**
+ * The bytes of a request body and the `Content-Type` that goes with them (a header the caller sets wins over it).
+ * `undefined` when there is no body. Throws `fetch(): ...` when more than one of the options is set.
+ */
+export declare function encodeBody(options: BodyOptions): EncodedBody | undefined;
+export {};

package/dist/request/request-body.js

@@ -0,0 +1,71 @@
+import { randomBytes } from "node:crypto";
+function isFile(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Buffer.isBuffer(value.buffer));
+}
+function isJson(text) {
+    try {
+        JSON.parse(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const quoted = (text) => text.replace(/["\r\n]/g, "_");
+function multipartOf(parts) {
+    const boundary = `----samurai${randomBytes(12).toString("hex")}`;
+    const chunks = [];
+    for (const [name, value] of Object.entries(parts)) {
+        const file = isFile(value);
+        const head = file
+            ? `Content-Disposition: form-data; name="${quoted(name)}"; filename="${quoted(value.name)}"\r\nContent-Type: ${value.mimeType ?? "application/octet-stream"}`
+            : `Content-Disposition: form-data; name="${quoted(name)}"`;
+        chunks.push(Buffer.from(`--${boundary}\r\n${head}\r\n\r\n`), file ? value.buffer : Buffer.from(String(value)), Buffer.from("\r\n"));
+    }
+    chunks.push(Buffer.from(`--${boundary}--\r\n`));
+    return {
+        body: Buffer.concat(chunks),
+        contentType: `multipart/form-data; boundary=${boundary}`,
+    };
+}
+/**
+ * The bytes of a request body and the `Content-Type` that goes with them (a header the caller sets wins over it).
+ * `undefined` when there is no body. Throws `fetch(): ...` when more than one of the options is set.
+ */
+export function encodeBody(options) {
+    const given = ["data", "form", "multipart"].filter((key) => options[key] !== undefined);
+    if (given.length > 1)
+        throw new Error(`fetch(): ${given.join(" and ")} cannot be used together, pick one`);
+    const { data, form, multipart } = options;
+    if (form !== undefined) {
+        const params = form instanceof URLSearchParams
+            ? form
+            : new URLSearchParams(Object.entries(form).map(([key, value]) => [key, String(value)]));
+        return {
+            body: Buffer.from(params.toString()),
+            contentType: "application/x-www-form-urlencoded",
+        };
+    }
+    if (multipart !== undefined)
+        return multipartOf(multipart);
+    if (data === undefined)
+        return undefined;
+    if (typeof data === "string")
+        return {
+            body: Buffer.from(data),
+            contentType: isJson(data)
+                ? "application/json"
+                : "application/octet-stream",
+        };
+    if (Buffer.isBuffer(data) || data instanceof Uint8Array)
+        return {
+            body: Buffer.from(data),
+            contentType: "application/octet-stream",
+        };
+    return {
+        body: Buffer.from(JSON.stringify(data)),
+        contentType: "application/json",
+    };
+}

package/dist/request/request.d.ts

@@ -0,0 +1,16 @@
+import type { StorageState } from "../types/use.js";
+import { APIRequestContext, type RequestContextOptions } from "./api-request-context.js";
+/** Options of `request.newContext()` */
+export interface NewRequestContextOptions extends RequestContextOptions {
+    /** Cookies to start with: a JSON file (relative to the project folder) or the object itself. Local storage is not used. */
+    storageState?: string | StorageState;
+}
+/** A request context with its own cookies: the same API as `page.request`, without a browser */
+export declare function createRequestContext(options?: NewRequestContextOptions): APIRequestContext;
+/**
+ * Creates `APIRequestContext`s that belong to no page: `request.newContext({ baseURL })`. Inside a test, the
+ * `request` fixture is one already.
+ */
+export declare const request: {
+    newContext: (options?: NewRequestContextOptions) => Promise<APIRequestContext>;
+};

package/dist/request/request.js

@@ -0,0 +1,20 @@
+import path from "node:path";
+import { projectDir } from "../config/config.js";
+import { loadStorageState } from "../config/storage-state-file.js";
+import { APIRequestContext, } from "./api-request-context.js";
+import { CookieJar } from "./cookie-jar.js";
+/** A request context with its own cookies: the same API as `page.request`, without a browser */
+export function createRequestContext(options = {}) {
+    const { storageState, ...rest } = options;
+    const state = storageState === undefined
+        ? undefined
+        : loadStorageState(storageState, path.resolve(projectDir()), "newContext()");
+    return new APIRequestContext(rest, new CookieJar(state?.cookies));
+}
+/**
+ * Creates `APIRequestContext`s that belong to no page: `request.newContext({ baseURL })`. Inside a test, the
+ * `request` fixture is one already.
+ */
+export const request = {
+    newContext: (options) => Promise.resolve(createRequestContext(options)),
+};

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

@@ -1,5 +1,5 @@
 import type { SupportedBrowser } from "../types/browser.js";
-import type { AllHookFixtures, RegisteredTestCase } from "../types/test.js";
+import type { AllHookFixtures, RegisteredTestCase, Suite } from "../types/test.js";
 import { type HookError } from "./hooks.js";
 export interface AllHooksOptions {
     /** The limit of each beforeAll / afterAll hook, in ms */
@@ -21,6 +21,12 @@ export declare class AllHooks {
     ensure(test: RegisteredTestCase, browser: SupportedBrowser): Promise<void>;
     /** Runs the `afterAll` hooks of every suite entered, last entered first, and returns the errors; a second call has nothing to do */
     closeAll(): Promise<HookError[]>;
+    /**
+     * Runs the `afterAll` hooks of `root` and of the suites inside it that were entered, so the next test that arrives
+     * runs their `beforeAll` hooks again: a serial block that starts over. Returns the errors.
+     */
+    closeWithin(root: Suite): Promise<HookError[]>;
+    private runAfter;
     private enter;
     private runBefore;
 }

package/dist/runner/all-hooks.js

@@ -21,9 +21,25 @@ export class AllHooks {
     }
     /** Runs the `afterAll` hooks of every suite entered, last entered first, and returns the errors; a second call has nothing to do */
     async closeAll() {
-        const errors = [];
         const entered = this.entered.splice(0).reverse();
         this.scopes.clear();
+        return this.runAfter(entered);
+    }
+    /**
+     * Runs the `afterAll` hooks of `root` and of the suites inside it that were entered, so the next test that arrives
+     * runs their `beforeAll` hooks again: a serial block that starts over. Returns the errors.
+     */
+    async closeWithin(root) {
+        const inside = (scope) => suiteChain(scope.suite).includes(root);
+        const closing = this.entered.filter(inside).reverse();
+        for (const scope of closing) {
+            this.entered.splice(this.entered.indexOf(scope), 1);
+            this.scopes.get(scope.suite)?.delete(scope.browser);
+        }
+        return this.runAfter(closing);
+    }
+    async runAfter(entered) {
+        const errors = [];
         for (const { suite, browser, ready } of entered) {
             await ready.catch(() => undefined);
             for (const hook of suite.afterAll ?? []) {

package/dist/runner/fixture-defs.js

@@ -11,6 +11,7 @@ export const BUILT_IN_FIXTURES = new Set([
     "outputs",
     "context",
     "baseURL",
+    "request",
     "testInfo",
     "isMobile",
     "hasTouch",

package/dist/runner/fixtures.d.ts

@@ -2,6 +2,7 @@ import type { Browser } from "../browser/browser.js";
 import type Page from "../browser/page.js";
 import type { SupportedBrowser } from "../types/browser.js";
 import type { AllHookFixtures, RegisteredTestCase, TestFixtures, TestInfo } from "../types/test.js";
+import type { RequestFixture } from "./request-fixture.js";
 import type { RunnerOptions } from "./options.js";
 import type { PreparedRun } from "./prepare-run.js";
 import type { OutputSink } from "../wait/output-sink.js";
@@ -20,6 +21,8 @@ export interface FixtureSources {
     options: RunnerOptions;
     sink: OutputSink;
     info: TestInfo;
+    /** The test's `request` fixture, made on first use */
+    request: RequestFixture;
     /** What the `use` options came to in this browser */
     device: {
         isMobile: boolean;
@@ -27,7 +30,7 @@ export interface FixtureSources {
     };
 }
 /**
- * The fixtures a test body and its each-hooks receive. `context`, `baseURL` and `testInfo` are getters: nothing
+ * The fixtures a test body and its each-hooks receive. `context`, `baseURL`, `request` and `testInfo` are getters: nothing
  * is looked up until a test reads one (and `page.context()` throws for a page without one, which only a test
  * that asks for it should see).
  */

package/dist/runner/fixtures.js

@@ -12,12 +12,12 @@ export function allHookFixtures(run, browserName, workerIndex = 0) {
     };
 }
 /**
- * The fixtures a test body and its each-hooks receive. `context`, `baseURL` and `testInfo` are getters: nothing
+ * The fixtures a test body and its each-hooks receive. `context`, `baseURL`, `request` and `testInfo` are getters: nothing
  * is looked up until a test reads one (and `page.context()` throws for a page without one, which only a test
  * that asks for it should see).
  */
 export function buildTestFixtures(from) {
-    const { launched, browserName, workerIndex, run, test, options, sink, info, device, } = from;
+    const { launched, browserName, workerIndex, run, test, options, sink, info, device, request, } = from;
     const { settings, secrets } = run;
     const fixtures = {
         page: launched.page,
@@ -34,6 +34,7 @@ export function buildTestFixtures(from) {
     return Object.defineProperties(fixtures, {
         context: { enumerable: true, get: () => launched.page.context() },
         baseURL: { enumerable: true, get: () => settings.baseURL },
+        request: { enumerable: true, get: () => request.get() },
         testInfo: { enumerable: true, get: () => info },
     });
 }

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

@@ -0,0 +1,13 @@
+import type { GlobalHookConfig, SamuraiTestConfig } from "../types/config.js";
+/** The run-level hooks of a config: `setup` before the tests, `teardown` after them */
+export interface GlobalHooks {
+    /** Runs `globalSetup`. A throw is `globalSetup(): message` */
+    setup(): Promise<void>;
+    /**
+     * Runs what the setup returned, then `globalTeardown`; both even when the setup failed half way. Resolves with the
+     * first error as `globalTeardown(): message`, else undefined
+     */
+    teardown(): Promise<Error | undefined>;
+}
+/** Binds the config's `globalSetup` / `globalTeardown` to the config they receive and the project folder they load from */
+export declare function globalHooks(config: SamuraiTestConfig, hookConfig: GlobalHookConfig, projectDir: string): GlobalHooks;

package/dist/runner/global-hooks.js

@@ -0,0 +1,66 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+/** The function a hook names: given directly, or the default export of the module at `projectDir`/`hook` */
+async function loadHook(name, hook, projectDir) {
+    if (typeof hook === "function")
+        return hook;
+    const file = path.resolve(projectDir, hook);
+    let module;
+    try {
+        module = (await import(pathToFileURL(file).href));
+    }
+    catch (error) {
+        throw new Error(`${name}(): cannot load ${hook}: ${messageOf(error)}`);
+    }
+    if (typeof module.default !== "function")
+        throw new Error(`${name}(): ${hook} must export a function as default`);
+    return module.default;
+}
+/** Binds the config's `globalSetup` / `globalTeardown` to the config they receive and the project folder they load from */
+export function globalHooks(config, hookConfig, projectDir) {
+    const returned = [];
+    return {
+        async setup() {
+            if (config.globalSetup === undefined)
+                return;
+            try {
+                const setup = (await loadHook("globalSetup", config.globalSetup, projectDir));
+                const teardown = await setup(hookConfig);
+                if (typeof teardown === "function")
+                    returned.push(teardown);
+            }
+            catch (error) {
+                const message = messageOf(error);
+                throw new Error(message.startsWith("globalSetup(): ")
+                    ? message
+                    : `globalSetup(): ${message}`);
+            }
+        },
+        async teardown() {
+            let first;
+            const record = (error) => {
+                const message = messageOf(error);
+                first ??= new Error(message.startsWith("globalTeardown(): ")
+                    ? message
+                    : `globalTeardown(): ${message}`);
+            };
+            for (const teardown of returned.splice(0).reverse())
+                try {
+                    await teardown();
+                }
+                catch (error) {
+                    record(error);
+                }
+            if (config.globalTeardown !== undefined)
+                try {
+                    const teardown = (await loadHook("globalTeardown", config.globalTeardown, projectDir));
+                    await teardown(hookConfig);
+                }
+                catch (error) {
+                    record(error);
+                }
+            return first;
+        },
+    };
+}