@remix-run/test 0.0.0 → 0.1.0

package/dist/lib/config.js

@@ -0,0 +1,152 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as fsp from 'node:fs/promises';
+import * as util from 'node:util';
+import { tsImport } from 'tsx/esm/api';
+// prettier-ignore
+// Note: `description` is not a field used by parseArgs(), it's an additional field
+// we use for `--help`
+const cliOptions = {
+    'browser.echo': {
+        type: 'boolean',
+        description: 'Echo browser console output to stdout',
+    },
+    'browser.open': {
+        type: 'boolean',
+        description: 'Open browser window and keep open after tests finish',
+    },
+    'glob.e2e': {
+        type: 'string',
+        description: 'Glob pattern for E2E test files',
+    },
+    'glob.test': {
+        type: 'string',
+        description: 'Glob pattern for all test files',
+    },
+    concurrency: {
+        type: 'string',
+        short: 'c',
+        description: 'Max number of concurrent test workers (default: os.availableParallelism())',
+    },
+    config: {
+        type: 'string',
+        description: 'Path to config file (default: remix-test.config.ts)',
+    },
+    setup: {
+        type: 'string',
+        short: 's',
+        description: 'Path to a setup module exporting globalSetup/globalTeardown',
+    },
+    playwrightConfig: {
+        type: 'string',
+        description: 'Path to a Playwright config file',
+    },
+    project: {
+        type: 'string',
+        short: 'p',
+        description: 'Filter to a specific Playwright project (comma-separated)',
+    },
+    reporter: {
+        type: 'string',
+        short: 'r',
+        description: 'Test reporter: spec, files, tap, dot (default: spec)',
+    },
+    type: {
+        type: 'string',
+        short: 't',
+        description: 'Comma-separated test types to run (default: server,e2e)',
+    },
+    watch: {
+        type: 'boolean',
+        short: 'w',
+        description: 'Re-run tests on file changes',
+    },
+};
+const defaultValues = {
+    browser: {
+        echo: false,
+        open: false,
+    },
+    concurrency: os.availableParallelism(),
+    glob: {
+        test: '**/*.test?(.e2e).{ts,tsx}',
+        e2e: '**/*.test.e2e.{ts,tsx}',
+    },
+    reporter: process.env.CI === 'true' ? 'dot' : 'spec',
+    type: 'server,e2e',
+    setup: undefined,
+    playwrightConfig: undefined,
+    project: undefined,
+    watch: false,
+};
+export async function loadConfig() {
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+        console.log(generateHelp());
+        process.exit(0);
+    }
+    let parsed = parseCliArgs();
+    let fileConfig = await loadConfigFile(parsed.values.config);
+    let config = resolveConfig(fileConfig, parsed);
+    return config;
+}
+function generateHelp() {
+    let lines = [
+        'Usage: remix-test [glob] [options]',
+        '',
+        'Arguments:',
+        `  glob                     Glob pattern for test files (default: "${defaultValues.glob.test}")`,
+        '',
+        'Options:',
+    ];
+    for (let [long, opt] of Object.entries(cliOptions)) {
+        let short = 'short' in opt ? `/-${opt.short}` : '';
+        let label = opt.type === 'string' ? `--${long}${short} <value>` : `--${long}${short}`;
+        lines.push(`  ${label.padEnd(30)} ${opt.description}`);
+    }
+    lines.push(`  ${'-h, --help'.padEnd(30)} Show this help message`);
+    return lines.join('\n');
+}
+function parseCliArgs(args = process.argv.slice(2)) {
+    return util.parseArgs({ args, options: cliOptions, allowPositionals: true });
+}
+function resolveConfig(fileConfig, { values: cliValues, positionals }) {
+    return {
+        glob: {
+            test: positionals[0] ??
+                cliValues['glob.test'] ??
+                fileConfig.glob?.test ??
+                defaultValues.glob.test,
+            e2e: cliValues['glob.e2e'] ?? fileConfig.glob?.e2e ?? defaultValues.glob.e2e,
+        },
+        browser: {
+            echo: cliValues['browser.echo'] ?? fileConfig.browser?.echo ?? defaultValues.browser.echo,
+            open: cliValues['browser.open'] ?? fileConfig.browser?.open ?? defaultValues.browser.open,
+        },
+        concurrency: Number(cliValues.concurrency ?? fileConfig.concurrency ?? defaultValues.concurrency),
+        setup: cliValues.setup ?? fileConfig.setup ?? defaultValues.setup,
+        playwrightConfig: cliValues.playwrightConfig ?? fileConfig.playwrightConfig ?? defaultValues.playwrightConfig,
+        project: cliValues.project ?? fileConfig.project ?? defaultValues.project,
+        reporter: cliValues.reporter ?? fileConfig.reporter ?? defaultValues.reporter,
+        type: cliValues.type ?? fileConfig.type ?? defaultValues.type,
+        watch: cliValues.watch ?? fileConfig.watch ?? defaultValues.watch,
+    };
+}
+async function loadConfigFile(configPath) {
+    let candidates = configPath
+        ? [path.resolve(process.cwd(), configPath)]
+        : [
+            path.join(process.cwd(), 'remix-test.config.ts'),
+            path.join(process.cwd(), 'remix-test.config.js'),
+        ];
+    for (let candidate of candidates) {
+        try {
+            await fsp.access(candidate);
+            let mod = await tsImport(candidate, { parentURL: import.meta.url });
+            return mod.default ?? mod;
+        }
+        catch {
+            // not found or failed to load — try next
+        }
+    }
+    return {};
+}

package/dist/lib/context.d.ts

@@ -0,0 +1,69 @@
+import type { Browser, Page } from 'playwright';
+import { type MockFunction, type MockCall, type MockContext } from './mock.ts';
+import type { CreateServerFunction } from './e2e-server.ts';
+import type { getPlaywrightPageOptions } from './playwright.ts';
+/**
+ * Test Context providing utilities for testing via remix-test.  The context is
+ * passed as the first argument to the {@link test}/{@link it} functions.
+ *
+ * @example
+ * describe('my test suite', () => {
+ *   it('my test case', async (t) => {
+ *     let mockFn = t.mock.fn(() => 'mocked value')
+ *     // ...
+ *   })
+ * })
+ */
+export interface TestContext {
+    /**
+     * Registers a cleanup function to be called after the test completes.
+     *
+     * @param {() => void} fn - The cleanup function to execute
+     * @returns {void}
+     */
+    after(fn: () => void): void;
+    /**
+     * Mock tracker for the current test. Mirrors the shape of Node's
+     * `t.mock`. Method mocks created here are auto-restored on test completion.
+     */
+    mock: {
+        /**
+         * Creates a mock function with an optional implementation.
+         *
+         * @template T - The function type to be mocked
+         * @param {T} [impl] - Optional custom implementation for the mock
+         * @returns {MockFunction<T>} A mock function instance
+         */
+        fn<T extends (...args: any[]) => any>(impl?: T): MockFunction<T>;
+        /**
+         * Replaces `obj[methodName]` with a mock and records every call. The
+         * original method is restored automatically after the test completes.
+         *
+         * @template T - The object type
+         * @template K - The method key of the object
+         * @param {T} obj - The object to mock
+         * @param {K} methodName - The method name to mock
+         * @param {Function} [impl] - Optional implementation override (must be a function)
+         * @returns {MockFunction} A mock function instance for the mocked method
+         */
+        method<T extends object, K extends keyof T>(obj: T, methodName: K, impl?: Function): MockFunction;
+    };
+    /**
+     * Starts a test server with the provided request handler.
+     *
+     * @param {(req: Request) => Promise<Response>} handler - Function handling incoming requests
+     * @returns {Promise<Page>} A promise resolving to a page instance for the server
+     */
+    serve(handler: (req: Request) => Promise<Response>): Promise<Page>;
+}
+export declare function createTestContext(options: {
+    createServer?: CreateServerFunction;
+    browser?: Browser;
+    open?: boolean;
+    playwrightPageOptions?: ReturnType<typeof getPlaywrightPageOptions>;
+}): {
+    testContext: TestContext;
+    cleanup(): Promise<void>;
+};
+export type { MockFunction, MockCall, MockContext };
+//# sourceMappingURL=context.d.ts.map

package/dist/lib/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/lib/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAQ,KAAK,YAAY,EAAE,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAEpF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAC3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAE/D;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAE3B;;;OAGG;IACH,IAAI,EAAE;QACJ;;;;;;WAMG;QACH,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;QAEhE;;;;;;;;;;WAUG;QACH,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACxC,GAAG,EAAE,CAAC,EACN,UAAU,EAAE,CAAC,EACb,IAAI,CAAC,EAAE,QAAQ,GACd,YAAY,CAAA;KAChB,CAAA;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACnE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,YAAY,CAAC,EAAE,oBAAoB,CAAA;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,qBAAqB,CAAC,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAA;CACpE,GAAG;IAAE,WAAW,EAAE,WAAW,CAAC;IAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAkDzD;AAED,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAA"}

package/dist/lib/context.js

@@ -0,0 +1,49 @@
+import { mock } from "./mock.js";
+export function createTestContext(options) {
+    let cleanups = [];
+    let testContext = {
+        mock: {
+            fn: mock.fn,
+            method(obj, methodName, impl) {
+                let mockFn = mock.method(obj, methodName, impl);
+                if (mockFn.mock.restore)
+                    cleanups.push(mockFn.mock.restore);
+                return mockFn;
+            },
+        },
+        after(fn) {
+            cleanups.push(fn);
+        },
+        async serve(handler) {
+            if (!options.createServer || !options.browser) {
+                throw new Error('t.serve() is only available in E2E test suites');
+            }
+            let server = await options.createServer(handler);
+            let page = await options.browser.newPage({
+                ...options.playwrightPageOptions,
+                baseURL: server.baseUrl,
+            });
+            if (options.playwrightPageOptions?.navigationTimeout != null) {
+                page.setDefaultNavigationTimeout(options.playwrightPageOptions.navigationTimeout);
+            }
+            if (options.playwrightPageOptions?.actionTimeout != null) {
+                page.setDefaultTimeout(options.playwrightPageOptions.actionTimeout);
+            }
+            cleanups.push(async () => {
+                if (!options.open) {
+                    await page.close();
+                }
+                await server.close();
+            });
+            return page;
+        },
+    };
+    return {
+        testContext,
+        async cleanup() {
+            for (let fn of cleanups)
+                await fn();
+            cleanups.length = 0;
+        },
+    };
+}

package/dist/lib/e2e-server.d.ts

@@ -0,0 +1,11 @@
+export interface CreateServerFunction {
+    (handler: (req: Request) => Promise<Response>): Promise<{
+        baseUrl: string;
+        close(): Promise<void>;
+    }>;
+}
+export declare function createServer(handler: (req: Request) => Promise<Response>): Promise<{
+    baseUrl: string;
+    close(): Promise<void>;
+}>;
+//# sourceMappingURL=e2e-server.d.ts.map

package/dist/lib/e2e-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e-server.d.ts","sourceRoot":"","sources":["../../src/lib/e2e-server.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,oBAAoB;IACnC,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;QACtD,OAAO,EAAE,MAAM,CAAA;QACf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KACvB,CAAC,CAAA;CACH;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;IAClF,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB,CAAC,CAcD"}

package/dist/lib/e2e-server.js

@@ -0,0 +1,15 @@
+import * as http from 'node:http';
+import { createRequestListener } from '@remix-run/node-fetch-server';
+export function createServer(handler) {
+    return new Promise((resolve, reject) => {
+        let server = http.createServer(createRequestListener(handler));
+        server.listen(0, '127.0.0.1', () => {
+            let addr = server.address();
+            resolve({
+                baseUrl: `http://127.0.0.1:${addr.port}`,
+                close: () => new Promise((r, rj) => server.close((e) => (e ? rj(e) : r()))),
+            });
+        });
+        server.on('error', reject);
+    });
+}

package/dist/lib/executor.d.ts

@@ -0,0 +1,27 @@
+import type { Browser, BrowserContextOptions } from 'playwright';
+import type { CreateServerFunction } from './e2e-server.ts';
+export interface TestResult {
+    name: string;
+    suiteName: string;
+    filePath?: string;
+    status: 'passed' | 'failed' | 'skipped' | 'todo';
+    error?: {
+        message: string;
+        stack?: string;
+    };
+    duration: number;
+}
+export interface TestResults {
+    passed: number;
+    failed: number;
+    skipped: number;
+    todo: number;
+    tests: TestResult[];
+}
+export declare function runTests(options?: {
+    createServer?: CreateServerFunction;
+    browser?: Browser;
+    open?: boolean;
+    playwrightPageOptions?: BrowserContextOptions;
+}): Promise<TestResults>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/lib/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/lib/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAEhE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAE3D,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAA;IAChD,KAAK,CAAC,EAAE;QACN,OAAO,EAAE,MAAM,CAAA;QACf,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;IACD,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB;AAED,wBAAsB,QAAQ,CAAC,OAAO,CAAC,EAAE;IACvC,YAAY,CAAC,EAAE,oBAAoB,CAAA;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,qBAAqB,CAAC,EAAE,qBAAqB,CAAA;CAC9C,GAAG,OAAO,CAAC,WAAW,CAAC,CAoIvB"}

package/dist/lib/executor.js

@@ -0,0 +1,123 @@
+import { createTestContext } from "./context.js";
+export async function runTests(options) {
+    let suites = globalThis.__testSuites || [];
+    let results = {
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        todo: 0,
+        tests: [],
+    };
+    let hasOnlySuites = suites.some((s) => s.only);
+    for (let suite of suites) {
+        // If any suite uses .only, skip all non-only suites
+        if (hasOnlySuites && !suite.only) {
+            for (let test of suite.tests) {
+                results.tests.push({
+                    name: test.name,
+                    suiteName: suite.name,
+                    status: 'skipped',
+                    duration: 0,
+                });
+                results.skipped++;
+            }
+            continue;
+        }
+        if (suite.skip || suite.todo) {
+            let status = suite.todo ? 'todo' : 'skipped';
+            for (let test of suite.tests) {
+                results.tests.push({ name: test.name, suiteName: suite.name, status, duration: 0 });
+                results[status]++;
+            }
+            // describe.todo('name') with no tests — add placeholder so suite appears in output
+            if (suite.tests.length === 0) {
+                results.tests.push({ name: '', suiteName: suite.name, status, duration: 0 });
+                results[status]++;
+            }
+            continue;
+        }
+        if (suite.beforeAll) {
+            try {
+                await suite.beforeAll();
+            }
+            catch (error) {
+                console.error(`beforeAll failed in suite "${suite.name}":`, error);
+                continue;
+            }
+        }
+        let hasOnlyTests = suite.tests.some((t) => t.only);
+        for (let test of suite.tests) {
+            // If any test uses .only, skip all non-only tests in this suite
+            if (hasOnlyTests && !test.only) {
+                results.tests.push({
+                    name: test.name,
+                    suiteName: suite.name,
+                    status: 'skipped',
+                    duration: 0,
+                });
+                results.skipped++;
+                continue;
+            }
+            if (test.skip || test.todo) {
+                let status = test.todo ? 'todo' : 'skipped';
+                results.tests.push({ name: test.name, suiteName: suite.name, status, duration: 0 });
+                results[status]++;
+                continue;
+            }
+            let startTime = performance.now();
+            let result = {
+                name: test.name,
+                suiteName: suite.name,
+                status: 'passed',
+                duration: 0,
+            };
+            let { testContext, cleanup } = createTestContext({
+                createServer: options?.createServer,
+                browser: options?.browser,
+                open: options?.open,
+                playwrightPageOptions: options?.playwrightPageOptions,
+            });
+            try {
+                if (suite.beforeEach) {
+                    await suite.beforeEach();
+                }
+                await test.fn(testContext);
+                result.status = 'passed';
+                results.passed++;
+            }
+            catch (error) {
+                result.status = 'failed';
+                result.error = {
+                    message: error.message || String(error),
+                    stack: error.stack,
+                };
+                results.failed++;
+            }
+            finally {
+                await cleanup();
+                if (suite.afterEach) {
+                    try {
+                        await suite.afterEach();
+                    }
+                    catch (error) {
+                        console.error('afterEach failed:', error);
+                    }
+                }
+                result.duration = performance.now() - startTime;
+                results.tests.push(result);
+            }
+        }
+        if (suite.afterAll) {
+            try {
+                await suite.afterAll();
+            }
+            catch (error) {
+                console.error(`afterAll failed in suite "${suite.name}":`, error);
+            }
+        }
+    }
+    // Clear suites in-place so the shared framework module is reset
+    // for the next test file (which reuses the same cached module instance)
+    suites.length = 0;
+    return results;
+}

package/dist/lib/framework.d.ts

@@ -0,0 +1,107 @@
+import type { TestContext } from './context.ts';
+/**
+ * Groups related tests into a named suite. Suites can be nested snd will be displayed
+ * as such or joined with ` > ` in reporter output. Lifecycle hooks registered inside
+ * a `describe` block apply only to tests within that block.
+ *
+ * @example
+ * describe('auth', () => {
+ *   it('logs in', async () => { ... })
+ * })
+ *
+ * // Modifiers
+ * describe.skip('skipped suite', () => { ... })
+ * describe.only('focused suite', () => { ... })
+ * describe.todo('planned suite')
+ *
+ * @param name - The suite name shown in reporter output.
+ * @param fn - A function that registers the tests and lifecycle hooks in this suite.
+ */
+export declare const describe: ((name: string, metaOrFn: SuiteMeta | (() => void), fn?: (() => void) | undefined) => void) & {
+    skip: (name: string, fn: () => void) => void;
+    only: (name: string, fn: () => void) => void;
+    todo: (name: string) => void;
+};
+type SuiteMeta = {
+    skip?: boolean;
+    only?: boolean;
+};
+type TestMeta = {
+    skip?: boolean;
+    only?: boolean;
+};
+type TestFn = (t: TestContext) => void | Promise<void>;
+/**
+ * Defines a single test case. The optional `TestContext` argument `t` provides
+ * mock helpers and per-test cleanup registration.
+ *
+ * @example
+ * it('returns 200 for the home route', async () => {
+ *   const res = await router.fetch('/')
+ *   assert.equal(res.status, 200)
+ * })
+ *
+ * // Modifiers
+ * it.skip('not ready yet', () => { ... })
+ * it.only('focused test', () => { ... })
+ * it.todo('coming soon')
+ *
+ * @param name - The test name shown in reporter output.
+ * @param fn - The test body, receiving a {@link TestContext} as its first argument.
+ */
+export declare const it: ((name: string, metaOrFn: TestFn | TestMeta, fn?: TestFn | undefined) => void) & {
+    skip: (name: string, fn?: TestFn | undefined) => void;
+    only: (name: string, fn: TestFn) => void;
+    todo: (name: string) => void;
+};
+/** Alias for {@link describe}. */
+export declare const suite: ((name: string, metaOrFn: SuiteMeta | (() => void), fn?: (() => void) | undefined) => void) & {
+    skip: (name: string, fn: () => void) => void;
+    only: (name: string, fn: () => void) => void;
+    todo: (name: string) => void;
+};
+/** Alias for {@link it}. */
+export declare const test: ((name: string, metaOrFn: TestFn | TestMeta, fn?: TestFn | undefined) => void) & {
+    skip: (name: string, fn?: TestFn | undefined) => void;
+    only: (name: string, fn: TestFn) => void;
+    todo: (name: string) => void;
+};
+/**
+ * Registers a hook that runs before **each** test in the current suite (or
+ * globally if called outside a `describe`). Multiple calls are chained in
+ * registration order.
+ *
+ * @param fn - The setup function to run before each test.
+ */
+export declare function beforeEach(fn: () => void | Promise<void>): void;
+/**
+ * Registers a hook that runs after **each** test in the current suite (or
+ * globally if called outside a `describe`). Multiple calls are chained in
+ * reverse registration order.  To run logic after a singular test, use
+ * `t.after()` from the {@link TestContext}
+ *
+ * @param fn - The teardown function to run after each test.
+ */
+export declare function afterEach(fn: () => void | Promise<void>): void;
+/**
+ * Registers a hook that runs once before **all** tests in the current suite
+ * (or globally if called outside a `describe`). Multiple calls are chained in
+ * registration order.
+ *
+ * @param fn - The setup function to run once before all tests in the suite.
+ */
+export declare function beforeAll(fn: () => void | Promise<void>): void;
+/**
+ * Registers a hook that runs once after **all** tests in the current suite (or
+ * globally if called outside a `describe`). Multiple calls are chained in
+ * reverse registration order.
+ *
+ * @param fn - The teardown function to run once after all tests in the suite.
+ */
+export declare function afterAll(fn: () => void | Promise<void>): void;
+/** Alias for {@link beforeAll} — matches the `node:test` API. */
+export declare const before: typeof beforeAll;
+/** Alias for {@link afterAll} — matches the `node:test` API. */
+export declare const after: typeof afterAll;
+export {};
+//# sourceMappingURL=framework.d.ts.map

package/dist/lib/framework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework.d.ts","sourceRoot":"","sources":["../../src/lib/framework.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAkF/C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ;;;;CAiBpB,CAAA;AAED,KAAK,SAAS,GAAG;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AACnD,KAAK,QAAQ,GAAG;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAClD,KAAK,MAAM,GAAG,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAUtD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,EAAE;;;;CAiBd,CAAA;AAED,kCAAkC;AAClC,eAAO,MAAM,KAAK;;;;CAAW,CAAA;AAC7B,4BAA4B;AAC5B,eAAO,MAAM,IAAI;;;;CAAK,CAAA;AA2BtB;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAGxD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAGvD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAGvD;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAGtD;AAED,mEAAiE;AACjE,eAAO,MAAM,MAAM,kBAAY,CAAA;AAC/B,kEAAgE;AAChE,eAAO,MAAM,KAAK,iBAAW,CAAA"}