velocious 1.0.643 → 1.0.644

package/build/src/testing/velocious-attempt-executor.d.ts

@@ -0,0 +1,69 @@
+export type TestTimeoutError = Error & {
+    velociousTestTimeout?: true;
+};
+export default class VelociousAttemptExecutor {
+    testRunner: import("./test-runner.js").default;
+    /**
+     * Creates an executor for framework-owned attempt lifecycle work.
+     * @param {object} args - Constructor arguments.
+     * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+     */
+    constructor({ testRunner, ...restArgs }: {
+        testRunner: import("./test-runner.js").default;
+    });
+    /**
+     * Executes exactly one complete Velocious-owned test attempt.
+     * @param {object} args - Attempt arguments.
+     * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.afterEaches - Cleanup hooks.
+     * @param {number} args.attemptNumber - One-based attempt number.
+     * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.beforeEaches - Setup hooks.
+     * @param {string[]} args.descriptions - Parent descriptions.
+     * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
+     * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
+     * @param {string} args.testDescription - Test description.
+     * @param {number} [args.timeoutMs] - Whole-lifecycle timeout.
+     * @returns {Promise<{abortRemainingTests: boolean, consoleOutput: string, error: ReturnType<typeof JSON.parse>, failed: boolean}>} - Attempt outcome.
+     */
+    execute({ afterEaches, attemptNumber, beforeEaches, descriptions, testArgs, testData, testDescription, timeoutMs, ...restArgs }: {
+        afterEaches: import("./test-runner.js").AfterBeforeEachCallbackObjectType[];
+        attemptNumber: number;
+        beforeEaches: import("./test-runner.js").AfterBeforeEachCallbackObjectType[];
+        descriptions: string[];
+        testArgs: import("./velocious-test-arguments.js").TestArgs;
+        testData: import("./velocious-test-arguments.js").TestData;
+        testDescription: string;
+        timeoutMs?: number;
+    }): Promise<{
+        abortRemainingTests: boolean;
+        consoleOutput: string;
+        error: ReturnType<typeof JSON.parse>;
+        failed: boolean;
+    }>;
+    /**
+     * Runs before-each hooks in inherited declaration order.
+     * @param {object} args - Hook arguments.
+     * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.beforeEaches - Setup hooks.
+     * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
+     * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
+     * @returns {Promise<void>} - Resolves after all setup hooks complete.
+     */
+    runBeforeEaches({ beforeEaches, testArgs, testData }: {
+        beforeEaches: import("./test-runner.js").AfterBeforeEachCallbackObjectType[];
+        testArgs: import("./velocious-test-arguments.js").TestArgs;
+        testData: import("./velocious-test-arguments.js").TestData;
+    }): Promise<void>;
+    /**
+     * Runs every after-each hook while preserving all failures.
+     * @param {object} args - Hook arguments.
+     * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.afterEaches - Cleanup hooks.
+     * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
+     * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
+     * @returns {Promise<void>} - Resolves after every cleanup hook settles.
+     */
+    runAfterEaches({ afterEaches, testArgs, testData }: {
+        afterEaches: import("./test-runner.js").AfterBeforeEachCallbackObjectType[];
+        testArgs: import("./velocious-test-arguments.js").TestArgs;
+        testData: import("./velocious-test-arguments.js").TestData;
+    }): Promise<void>;
+}
+//# sourceMappingURL=velocious-attempt-executor.d.ts.map

package/build/src/testing/velocious-attempt-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"velocious-attempt-executor.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-attempt-executor.js"],"names":[],"mappings":"AASG,YAAiD,gBAAgB,GAAvD,KAAK,GAAG;IAAC,oBAAoB,CAAC,EAAE,IAAI,CAAA;CAAC,CAAkB;AA8EpE,MAAM,CAAC,OAAO,OAAO,wBAAwB;IAQpC,UAAU;IAPjB;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAGpC;IAED;;;;;;;;;;;;OAYG;IACG,OAAO,CAAC,EAAC,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,GAAG,QAAQ,EAAC,EAVhI;QAA6E,WAAW,EAAhF,OAAO,kBAAkB,EAAE,iCAAiC,EAAE,CACtE;QAAqB,aAAa,EAA1B,MAAM,CACd;QAA6E,YAAY,EAAjF,OAAO,kBAAkB,EAAE,iCAAiC,EAAE,CACtE;QAAuB,YAAY,EAA3B,MAAM,EAAE,CAChB;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAAqB,eAAe,EAA5B,MAAM,CACd;QAAsB,SAAS,AAA/B,CACA,EADQ,MAAM,CACd;KAEgI,GAFtH,OAAO,CAAC;QAAC,mBAAmB,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,CAAC,CA0QjI;IAED;;;;;;;OAOG;IACG,eAAe,CAAC,EAAC,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAC,EALrD;QAA6E,YAAY,EAAjF,OAAO,kBAAkB,EAAE,iCAAiC,EAAE,CACtE;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;KAEqD,GAF3C,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;;;;;OAOG;IACG,cAAc,CAAC,EAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAC,EALnD;QAA6E,WAAW,EAAhF,OAAO,kBAAkB,EAAE,iCAAiC,EAAE,CACtE;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;KAEmD,GAFzC,OAAO,CAAC,IAAI,CAAC,CAyBzB;CACF"}

package/build/src/testing/velocious-attempt-executor.js

@@ -0,0 +1,402 @@
+// @ts-check
+import { TestDatabaseAccessRevokedError } from "../environment-handlers/base.js";
+import { clearDeliveries } from "../mailer.js";
+import restArgsError from "../utils/rest-args-error.js";
+import { testConfig } from "./test.js";
+/**
+ * Marks one whole-lifecycle timeout while its underlying promise keeps running.
+ * @typedef {Error & {velociousTestTimeout?: true}} TestTimeoutError
+ */
+/**
+ * Runs one promise with a lifecycle timeout.
+ * @param {Promise<ReturnType<typeof JSON.parse>> | ReturnType<typeof JSON.parse>} promise - Promise or value.
+ * @param {number} timeoutMs - Timeout in milliseconds.
+ * @param {string} testDescription - Test description.
+ * @returns {Promise<ReturnType<typeof JSON.parse>>} - Lifecycle result.
+ */
+function runWithTimeout(promise, timeoutMs, testDescription) {
+    const timeoutSeconds = (timeoutMs / 1000).toFixed(3).replace(/\.?0+$/, "");
+    /** @type {TestTimeoutError} */
+    const timeoutError = new Error(`Timed out after ${timeoutSeconds}s: ${testDescription}`);
+    timeoutError.velociousTestTimeout = true;
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(timeoutError), timeoutMs);
+        Promise.resolve(promise).then((result) => {
+            clearTimeout(timeout);
+            resolve(result);
+        }).catch((error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+}
+/**
+ * Waits for detached lifecycle cleanup up to the timeout grace period.
+ * @param {Promise<ReturnType<typeof JSON.parse>>} lifecycle - Detached lifecycle promise.
+ * @param {number} graceMs - Maximum wait.
+ * @returns {Promise<{settled: false} | {settled: true, status: "fulfilled"} | {settled: true, status: "rejected", reason: ReturnType<typeof JSON.parse>}>} - Settlement outcome.
+ */
+function awaitSettledOrGrace(lifecycle, graceMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const graceTimer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ settled: false });
+        }, graceMs);
+        Promise.resolve(lifecycle).then(() => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(graceTimer);
+            resolve({ settled: true, status: "fulfilled" });
+        }, (reason) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(graceTimer);
+            resolve({ settled: true, status: "rejected", reason });
+        });
+    });
+}
+/**
+ * Checks whether a late lifecycle stopped only because its attempt access was revoked.
+ * @param {ReturnType<typeof JSON.parse>} error - Lifecycle rejection.
+ * @returns {boolean} - Whether every contained error is expected revocation.
+ */
+function isTestDatabaseAccessRevocation(error) {
+    if (error instanceof TestDatabaseAccessRevokedError)
+        return true;
+    if (error instanceof AggregateError) {
+        return error.errors.length > 0 && error.errors.every((nestedError) => isTestDatabaseAccessRevocation(nestedError));
+    }
+    return false;
+}
+export default class VelociousAttemptExecutor {
+    /**
+     * Creates an executor for framework-owned attempt lifecycle work.
+     * @param {object} args - Constructor arguments.
+     * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+     */
+    constructor({ testRunner, ...restArgs }) {
+        restArgsError(restArgs);
+        this.testRunner = testRunner;
+    }
+    /**
+     * Executes exactly one complete Velocious-owned test attempt.
+     * @param {object} args - Attempt arguments.
+     * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.afterEaches - Cleanup hooks.
+     * @param {number} args.attemptNumber - One-based attempt number.
+     * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.beforeEaches - Setup hooks.
+     * @param {string[]} args.descriptions - Parent descriptions.
+     * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
+     * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
+     * @param {string} args.testDescription - Test description.
+     * @param {number} [args.timeoutMs] - Whole-lifecycle timeout.
+     * @returns {Promise<{abortRemainingTests: boolean, consoleOutput: string, error: ReturnType<typeof JSON.parse>, failed: boolean}>} - Attempt outcome.
+     */
+    async execute({ afterEaches, attemptNumber, beforeEaches, descriptions, testArgs, testData, testDescription, timeoutMs, ...restArgs }) {
+        restArgsError(restArgs);
+        const testRunner = this.testRunner;
+        /** @type {ReturnType<typeof JSON.parse>} */
+        let caughtError;
+        let failed = false;
+        /** @type {Promise<ReturnType<typeof JSON.parse>> | undefined} */
+        let testLifecycle;
+        /** @type {{pool: import("../database/pool/base.js").default, registration: import("../database/pool/base.js").TestSharedConnectionRegistration}[]} */
+        let testSharedConnectionRegistrations = [];
+        let testSharedConnectionsActive = false;
+        /** @type {import("./test-runner.js").SharedTransactionBrokerRegistration | undefined} */
+        let sharedTransactionBrokerRegistration;
+        /** @type {import("./test-runner.js").SharedTransactionBrokerRegistration | undefined} */
+        let sharedTransactionBrokerPreparation;
+        /** @type {import("./test-runner.js").TransactionalTenantRegistration[]} */
+        const transactionalTenantRegistrations = [];
+        /** @type {import("./test-runner.js").BrowserDummyConnectionRegistration[]} */
+        const browserDummyConnectionRegistrations = [];
+        const testDatabaseAccessScope = { revoked: false };
+        /** @type {Set<Error>} */
+        const recordedTimeoutCleanupErrors = new Set();
+        let abortRemainingTests = false;
+        let attemptTimedOut = false;
+        /** @type {string} */
+        let consoleOutput;
+        testArgs.registerTransactionalTenant = async (args) => {
+            await testRunner.registerTransactionalTenant(args, transactionalTenantRegistrations);
+        };
+        const stopConsoleCapture = testRunner.startConsoleCapture({
+            passthrough: testConfig.consoleOutput === "live"
+        });
+        const profiler = testRunner._profiler;
+        const profileAttempt = profiler?.startAttempt({
+            descriptions,
+            attemptNumber,
+            testData,
+            testDescription
+        });
+        try {
+            const runLifecycleCallback = async () => await testRunner.runWithDummyIfNeeded(testArgs, async () => {
+                const useTransaction = testArgs.databaseCleaning?.transaction === true;
+                const shouldTruncate = testArgs.databaseCleaning?.truncate ?? !useTransaction;
+                const useSharedTestConnections = useTransaction || testArgs.type == "request";
+                const useTestConnections = useSharedTestConnections || shouldTruncate;
+                const runTestAttempt = async () => {
+                    if (useSharedTestConnections) {
+                        testSharedConnectionRegistrations = testRunner.activateTestSharedConnections();
+                        testSharedConnectionsActive = true;
+                    }
+                    /** @type {ReturnType<typeof JSON.parse>[]} */
+                    const lifecycleErrors = [];
+                    let runCleanupHooks = false;
+                    try {
+                        if (useSharedTestConnections) {
+                            sharedTransactionBrokerPreparation = await testRunner.prepareSharedTransactionBroker();
+                        }
+                        runCleanupHooks = true;
+                        clearDeliveries();
+                        await this.runBeforeEaches({ beforeEaches, testArgs, testData });
+                        if (useSharedTestConnections) {
+                            const activeConnections = testRunner.sharedTransactionConnections({ transactionsOnly: true });
+                            if (sharedTransactionBrokerPreparation && !testRunner.sharedTransactionBrokerMatchesConnections(sharedTransactionBrokerPreparation, activeConnections)) {
+                                testRunner.clearTestSharedConnections(testSharedConnectionRegistrations);
+                                testSharedConnectionRegistrations = [];
+                                testSharedConnectionsActive = false;
+                            }
+                            sharedTransactionBrokerRegistration = await testRunner.startSharedTransactionBroker(sharedTransactionBrokerPreparation, activeConnections);
+                            sharedTransactionBrokerPreparation = undefined;
+                            if (sharedTransactionBrokerRegistration && !testSharedConnectionsActive) {
+                                testSharedConnectionRegistrations = testRunner.activateTestSharedConnections();
+                                testSharedConnectionsActive = true;
+                            }
+                        }
+                        testRunner._lastTestContext = {
+                            fullDescription: testRunner.buildFullDescription(descriptions, testDescription),
+                            filePath: testData.filePath ?? "<unknown>",
+                            line: testData.line ?? 0
+                        };
+                        await testRunner.runProfileSpan({ phase: "test body", filePath: testData.ownerFilePath ?? testData.filePath }, async () => {
+                            await testData.function(testArgs);
+                        });
+                    }
+                    catch (error) {
+                        lifecycleErrors.push(error);
+                    }
+                    if (runCleanupHooks) {
+                        try {
+                            await testRunner.getConfiguration().awaitPendingBroadcasts();
+                        }
+                        catch (error) {
+                            lifecycleErrors.push(error);
+                        }
+                        try {
+                            if (testSharedConnectionsActive) {
+                                testRunner.clearTestSharedConnections(testSharedConnectionRegistrations);
+                                testSharedConnectionRegistrations = [];
+                                testSharedConnectionsActive = false;
+                            }
+                        }
+                        catch (error) {
+                            lifecycleErrors.push(error);
+                        }
+                        try {
+                            await testRunner.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation);
+                            sharedTransactionBrokerRegistration = undefined;
+                            sharedTransactionBrokerPreparation = undefined;
+                        }
+                        catch (error) {
+                            lifecycleErrors.push(error);
+                        }
+                        try {
+                            await this.runAfterEaches({ afterEaches, testArgs, testData });
+                        }
+                        catch (error) {
+                            lifecycleErrors.push(error);
+                        }
+                        try {
+                            await testRunner.cleanupTransactionalTenants(transactionalTenantRegistrations);
+                        }
+                        catch (error) {
+                            lifecycleErrors.push(error);
+                        }
+                    }
+                    if (testSharedConnectionsActive) {
+                        try {
+                            testRunner.clearTestSharedConnections(testSharedConnectionRegistrations);
+                        }
+                        catch (error) {
+                            lifecycleErrors.push(error);
+                        }
+                        testSharedConnectionsActive = false;
+                    }
+                    if (lifecycleErrors.length == 1)
+                        throw lifecycleErrors[0];
+                    if (lifecycleErrors.length > 1) {
+                        throw new AggregateError(lifecycleErrors, "Test lifecycle and cleanup failed", { cause: lifecycleErrors[0] });
+                    }
+                };
+                if (useTestConnections) {
+                    await testRunner.getConfiguration().ensureConnections({ name: `Test: ${testDescription}` }, runTestAttempt);
+                }
+                else {
+                    await runTestAttempt();
+                }
+            }, browserDummyConnectionRegistrations);
+            const lifecycleCallback = async () => await testRunner.getConfiguration().runWithTestDatabaseAccessScope(testDatabaseAccessScope, runLifecycleCallback);
+            testLifecycle = profileAttempt && profiler
+                ? profiler.runAttempt(profileAttempt, lifecycleCallback)
+                : lifecycleCallback();
+            if (timeoutMs !== undefined) {
+                await runWithTimeout(testLifecycle, timeoutMs, testDescription);
+            }
+            else {
+                await testLifecycle;
+            }
+        }
+        catch (error) {
+            failed = true;
+            caughtError = error;
+            const timedOut = Boolean(/** @type {TestTimeoutError} */ (error)?.velociousTestTimeout);
+            attemptTimedOut = timedOut;
+            if (timedOut && testLifecycle) {
+                const emergencyCleanupErrors = [];
+                if (profileAttempt && profiler)
+                    profiler.finishAttempt(profileAttempt, "timed-out");
+                const lifecycleOutcome = await awaitSettledOrGrace(testLifecycle, timeoutMs ?? 60000);
+                if (lifecycleOutcome.settled && lifecycleOutcome.status === "rejected") {
+                    emergencyCleanupErrors.push(lifecycleOutcome.reason);
+                }
+                if (!lifecycleOutcome.settled) {
+                    testDatabaseAccessScope.revoked = true;
+                    void testLifecycle.catch((cleanupError) => {
+                        if (isTestDatabaseAccessRevocation(cleanupError))
+                            return;
+                        testRunner.recordTimeoutCleanupFailure(cleanupError, "test lifecycle", recordedTimeoutCleanupErrors);
+                    });
+                    const quarantine = testRunner.quarantineBrowserDummyConnections(browserDummyConnectionRegistrations);
+                    const quarantineOutcome = await awaitSettledOrGrace(quarantine, timeoutMs ?? 60000);
+                    const usesBrowserTransactions = testArgs.databaseCleaning?.transaction === true;
+                    const usesBrowserTruncation = testArgs.databaseCleaning?.truncate ?? !usesBrowserTransactions;
+                    abortRemainingTests = testRunner.isBrowserTestMode()
+                        && testRunner.hasTag(testArgs, "dummy")
+                        && (usesBrowserTransactions || usesBrowserTruncation);
+                    if (quarantineOutcome.settled && quarantineOutcome.status === "rejected") {
+                        emergencyCleanupErrors.push(quarantineOutcome.reason);
+                    }
+                    else if (!quarantineOutcome.settled) {
+                        void quarantine.catch((cleanupError) => {
+                            testRunner.recordTimeoutCleanupFailure(cleanupError, "browser dummy connection quarantine", recordedTimeoutCleanupErrors);
+                        });
+                    }
+                }
+                try {
+                    if (testSharedConnectionsActive) {
+                        testRunner.clearTestSharedConnections(testSharedConnectionRegistrations);
+                        testSharedConnectionRegistrations = [];
+                        testSharedConnectionsActive = false;
+                    }
+                }
+                catch (cleanupError) {
+                    emergencyCleanupErrors.push(cleanupError);
+                }
+                const brokerCleanup = testRunner.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation);
+                const brokerCleanupOutcome = await awaitSettledOrGrace(brokerCleanup, timeoutMs ?? 60000);
+                if (brokerCleanupOutcome.settled && brokerCleanupOutcome.status === "rejected") {
+                    emergencyCleanupErrors.push(brokerCleanupOutcome.reason);
+                }
+                else if (!brokerCleanupOutcome.settled) {
+                    void brokerCleanup.catch((cleanupError) => {
+                        testRunner.recordTimeoutCleanupFailure(cleanupError, "shared transaction broker", recordedTimeoutCleanupErrors);
+                    });
+                }
+                sharedTransactionBrokerRegistration = undefined;
+                sharedTransactionBrokerPreparation = undefined;
+                const emergencyCleanup = testRunner.cleanupTransactionalTenants(transactionalTenantRegistrations, { discard: true });
+                const emergencyCleanupOutcome = await awaitSettledOrGrace(emergencyCleanup, timeoutMs ?? 60000);
+                if (emergencyCleanupOutcome.settled && emergencyCleanupOutcome.status === "rejected") {
+                    emergencyCleanupErrors.push(emergencyCleanupOutcome.reason);
+                }
+                else if (!emergencyCleanupOutcome.settled) {
+                    void emergencyCleanup.catch((cleanupError) => {
+                        testRunner.recordTimeoutCleanupFailure(cleanupError, "transactional tenant", recordedTimeoutCleanupErrors);
+                    });
+                }
+                if (emergencyCleanupErrors.length > 0) {
+                    caughtError = new AggregateError([caughtError, ...emergencyCleanupErrors], "Test timeout and emergency cleanup failed", { cause: caughtError });
+                }
+            }
+            if (browserDummyConnectionRegistrations.some((registration) => registration.quarantined)) {
+                testDatabaseAccessScope.revoked = true;
+                abortRemainingTests = true;
+            }
+        }
+        finally {
+            testDatabaseAccessScope.revoked = true;
+            consoleOutput = stopConsoleCapture();
+            if (profileAttempt && profiler) {
+                profiler.finishAttempt(profileAttempt, failed
+                    ? (attemptTimedOut ? "timed-out" : "failed")
+                    : "passed");
+            }
+        }
+        return {
+            abortRemainingTests,
+            consoleOutput,
+            error: caughtError,
+            failed
+        };
+    }
+    /**
+     * Runs before-each hooks in inherited declaration order.
+     * @param {object} args - Hook arguments.
+     * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.beforeEaches - Setup hooks.
+     * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
+     * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
+     * @returns {Promise<void>} - Resolves after all setup hooks complete.
+     */
+    async runBeforeEaches({ beforeEaches, testArgs, testData }) {
+        for (const hook of beforeEaches) {
+            await this.testRunner.runProfileSpan({
+                phase: "beforeEach",
+                declarationIndex: hook.declarationIndex,
+                declarationScopeId: hook.declarationScopeId,
+                filePath: hook.ownerFilePath
+            }, async () => {
+                await hook.callback({ configuration: this.testRunner.getConfiguration(), testArgs, testData });
+            });
+        }
+    }
+    /**
+     * Runs every after-each hook while preserving all failures.
+     * @param {object} args - Hook arguments.
+     * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.afterEaches - Cleanup hooks.
+     * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
+     * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
+     * @returns {Promise<void>} - Resolves after every cleanup hook settles.
+     */
+    async runAfterEaches({ afterEaches, testArgs, testData }) {
+        /** @type {ReturnType<typeof JSON.parse>[]} */
+        const errors = [];
+        for (const hook of afterEaches) {
+            try {
+                await this.testRunner.runProfileSpan({
+                    phase: "afterEach",
+                    declarationIndex: hook.declarationIndex,
+                    declarationScopeId: hook.declarationScopeId,
+                    filePath: hook.ownerFilePath
+                }, async () => {
+                    await hook.callback({ configuration: this.testRunner.getConfiguration(), testArgs, testData });
+                });
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length == 1)
+            throw errors[0];
+        if (errors.length > 1) {
+            throw new AggregateError(errors, "Multiple afterEach hooks failed", { cause: errors[0] });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"velocious-attempt-executor.js","sourceRoot":"","sources":["../../../src/testing/velocious-attempt-executor.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport { TestDatabaseAccessRevokedError } from \"../environment-handlers/base.js\"\nimport { clearDeliveries } from \"../mailer.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\nimport { testConfig } from \"./test.js\"\n\n/**\n * Marks one whole-lifecycle timeout while its underlying promise keeps running.\n * @typedef {Error & {velociousTestTimeout?: true}} TestTimeoutError\n */\n\n/**\n * Runs one promise with a lifecycle timeout.\n * @param {Promise<ReturnType<typeof JSON.parse>> | ReturnType<typeof JSON.parse>} promise - Promise or value.\n * @param {number} timeoutMs - Timeout in milliseconds.\n * @param {string} testDescription - Test description.\n * @returns {Promise<ReturnType<typeof JSON.parse>>} - Lifecycle result.\n */\nfunction runWithTimeout(promise, timeoutMs, testDescription) {\n  const timeoutSeconds = (timeoutMs / 1000).toFixed(3).replace(/\\.?0+$/, \"\")\n  /** @type {TestTimeoutError} */\n  const timeoutError = new Error(`Timed out after ${timeoutSeconds}s: ${testDescription}`)\n  timeoutError.velociousTestTimeout = true\n\n  return new Promise((resolve, reject) => {\n    const timeout = setTimeout(() => reject(timeoutError), timeoutMs)\n\n    Promise.resolve(promise).then((result) => {\n      clearTimeout(timeout)\n      resolve(result)\n    }).catch((error) => {\n      clearTimeout(timeout)\n      reject(error)\n    })\n  })\n}\n\n/**\n * Waits for detached lifecycle cleanup up to the timeout grace period.\n * @param {Promise<ReturnType<typeof JSON.parse>>} lifecycle - Detached lifecycle promise.\n * @param {number} graceMs - Maximum wait.\n * @returns {Promise<{settled: false} | {settled: true, status: \"fulfilled\"} | {settled: true, status: \"rejected\", reason: ReturnType<typeof JSON.parse>}>} - Settlement outcome.\n */\nfunction awaitSettledOrGrace(lifecycle, graceMs) {\n  return new Promise((resolve) => {\n    let settled = false\n    const graceTimer = setTimeout(() => {\n      if (settled) return\n\n      settled = true\n      resolve({settled: false})\n    }, graceMs)\n\n    Promise.resolve(lifecycle).then(\n      () => {\n        if (settled) return\n\n        settled = true\n        clearTimeout(graceTimer)\n        resolve({settled: true, status: \"fulfilled\"})\n      },\n      (reason) => {\n        if (settled) return\n\n        settled = true\n        clearTimeout(graceTimer)\n        resolve({settled: true, status: \"rejected\", reason})\n      }\n    )\n  })\n}\n\n/**\n * Checks whether a late lifecycle stopped only because its attempt access was revoked.\n * @param {ReturnType<typeof JSON.parse>} error - Lifecycle rejection.\n * @returns {boolean} - Whether every contained error is expected revocation.\n */\nfunction isTestDatabaseAccessRevocation(error) {\n  if (error instanceof TestDatabaseAccessRevokedError) return true\n  if (error instanceof AggregateError) {\n    return error.errors.length > 0 && error.errors.every((nestedError) => isTestDatabaseAccessRevocation(nestedError))\n  }\n\n  return false\n}\n\nexport default class VelociousAttemptExecutor {\n  /**\n   * Creates an executor for framework-owned attempt lifecycle work.\n   * @param {object} args - Constructor arguments.\n   * @param {import(\"./test-runner.js\").default} args.testRunner - Owning Velocious runner.\n   */\n  constructor({testRunner, ...restArgs}) {\n    restArgsError(restArgs)\n    this.testRunner = testRunner\n  }\n\n  /**\n   * Executes exactly one complete Velocious-owned test attempt.\n   * @param {object} args - Attempt arguments.\n   * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} args.afterEaches - Cleanup hooks.\n   * @param {number} args.attemptNumber - One-based attempt number.\n   * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} args.beforeEaches - Setup hooks.\n   * @param {string[]} args.descriptions - Parent descriptions.\n   * @param {import(\"./velocious-test-arguments.js\").TestArgs} args.testArgs - Stable test arguments.\n   * @param {import(\"./velocious-test-arguments.js\").TestData} args.testData - Test registration.\n   * @param {string} args.testDescription - Test description.\n   * @param {number} [args.timeoutMs] - Whole-lifecycle timeout.\n   * @returns {Promise<{abortRemainingTests: boolean, consoleOutput: string, error: ReturnType<typeof JSON.parse>, failed: boolean}>} - Attempt outcome.\n   */\n  async execute({afterEaches, attemptNumber, beforeEaches, descriptions, testArgs, testData, testDescription, timeoutMs, ...restArgs}) {\n    restArgsError(restArgs)\n    const testRunner = this.testRunner\n    /** @type {ReturnType<typeof JSON.parse>} */\n    let caughtError\n    let failed = false\n    /** @type {Promise<ReturnType<typeof JSON.parse>> | undefined} */\n    let testLifecycle\n    /** @type {{pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}[]} */\n    let testSharedConnectionRegistrations = []\n    let testSharedConnectionsActive = false\n    /** @type {import(\"./test-runner.js\").SharedTransactionBrokerRegistration | undefined} */\n    let sharedTransactionBrokerRegistration\n    /** @type {import(\"./test-runner.js\").SharedTransactionBrokerRegistration | undefined} */\n    let sharedTransactionBrokerPreparation\n    /** @type {import(\"./test-runner.js\").TransactionalTenantRegistration[]} */\n    const transactionalTenantRegistrations = []\n    /** @type {import(\"./test-runner.js\").BrowserDummyConnectionRegistration[]} */\n    const browserDummyConnectionRegistrations = []\n    const testDatabaseAccessScope = {revoked: false}\n    /** @type {Set<Error>} */\n    const recordedTimeoutCleanupErrors = new Set()\n    let abortRemainingTests = false\n    let attemptTimedOut = false\n    /** @type {string} */\n    let consoleOutput\n    testArgs.registerTransactionalTenant = async (args) => {\n      await testRunner.registerTransactionalTenant(args, transactionalTenantRegistrations)\n    }\n    const stopConsoleCapture = testRunner.startConsoleCapture({\n      passthrough: testConfig.consoleOutput === \"live\"\n    })\n    const profiler = testRunner._profiler\n    const profileAttempt = profiler?.startAttempt({\n      descriptions,\n      attemptNumber,\n      testData,\n      testDescription\n    })\n\n    try {\n      const runLifecycleCallback = async () => await testRunner.runWithDummyIfNeeded(testArgs, async () => {\n        const useTransaction = testArgs.databaseCleaning?.transaction === true\n        const shouldTruncate = testArgs.databaseCleaning?.truncate ?? !useTransaction\n        const useSharedTestConnections = useTransaction || testArgs.type == \"request\"\n        const useTestConnections = useSharedTestConnections || shouldTruncate\n        const runTestAttempt = async () => {\n          if (useSharedTestConnections) {\n            testSharedConnectionRegistrations = testRunner.activateTestSharedConnections()\n            testSharedConnectionsActive = true\n          }\n          /** @type {ReturnType<typeof JSON.parse>[]} */\n          const lifecycleErrors = []\n          let runCleanupHooks = false\n\n          try {\n            if (useSharedTestConnections) {\n              sharedTransactionBrokerPreparation = await testRunner.prepareSharedTransactionBroker()\n            }\n            runCleanupHooks = true\n\n            clearDeliveries()\n            await this.runBeforeEaches({beforeEaches, testArgs, testData})\n\n            if (useSharedTestConnections) {\n              const activeConnections = testRunner.sharedTransactionConnections({transactionsOnly: true})\n              if (sharedTransactionBrokerPreparation && !testRunner.sharedTransactionBrokerMatchesConnections(sharedTransactionBrokerPreparation, activeConnections)) {\n                testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n                testSharedConnectionRegistrations = []\n                testSharedConnectionsActive = false\n              }\n\n              sharedTransactionBrokerRegistration = await testRunner.startSharedTransactionBroker(sharedTransactionBrokerPreparation, activeConnections)\n              sharedTransactionBrokerPreparation = undefined\n              if (sharedTransactionBrokerRegistration && !testSharedConnectionsActive) {\n                testSharedConnectionRegistrations = testRunner.activateTestSharedConnections()\n                testSharedConnectionsActive = true\n              }\n            }\n\n            testRunner._lastTestContext = {\n              fullDescription: testRunner.buildFullDescription(descriptions, testDescription),\n              filePath: testData.filePath ?? \"<unknown>\",\n              line: testData.line ?? 0\n            }\n            await testRunner.runProfileSpan({phase: \"test body\", filePath: testData.ownerFilePath ?? testData.filePath}, async () => {\n              await testData.function(testArgs)\n            })\n          } catch (error) {\n            lifecycleErrors.push(error)\n          }\n\n          if (runCleanupHooks) {\n            try {\n              await testRunner.getConfiguration().awaitPendingBroadcasts()\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              if (testSharedConnectionsActive) {\n                testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n                testSharedConnectionRegistrations = []\n                testSharedConnectionsActive = false\n              }\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await testRunner.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation)\n              sharedTransactionBrokerRegistration = undefined\n              sharedTransactionBrokerPreparation = undefined\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await this.runAfterEaches({afterEaches, testArgs, testData})\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n\n            try {\n              await testRunner.cleanupTransactionalTenants(transactionalTenantRegistrations)\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n          }\n\n          if (testSharedConnectionsActive) {\n            try {\n              testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n            } catch (error) {\n              lifecycleErrors.push(error)\n            }\n            testSharedConnectionsActive = false\n          }\n\n          if (lifecycleErrors.length == 1) throw lifecycleErrors[0]\n          if (lifecycleErrors.length > 1) {\n            throw new AggregateError(lifecycleErrors, \"Test lifecycle and cleanup failed\", {cause: lifecycleErrors[0]})\n          }\n        }\n\n        if (useTestConnections) {\n          await testRunner.getConfiguration().ensureConnections({name: `Test: ${testDescription}`}, runTestAttempt)\n        } else {\n          await runTestAttempt()\n        }\n      }, browserDummyConnectionRegistrations)\n      const lifecycleCallback = async () => await testRunner.getConfiguration().runWithTestDatabaseAccessScope(testDatabaseAccessScope, runLifecycleCallback)\n      testLifecycle = profileAttempt && profiler\n        ? profiler.runAttempt(profileAttempt, lifecycleCallback)\n        : lifecycleCallback()\n\n      if (timeoutMs !== undefined) {\n        await runWithTimeout(testLifecycle, timeoutMs, testDescription)\n      } else {\n        await testLifecycle\n      }\n    } catch (error) {\n      failed = true\n      caughtError = error\n      const timedOut = Boolean(/** @type {TestTimeoutError} */ (error)?.velociousTestTimeout)\n      attemptTimedOut = timedOut\n\n      if (timedOut && testLifecycle) {\n        const emergencyCleanupErrors = []\n\n        if (profileAttempt && profiler) profiler.finishAttempt(profileAttempt, \"timed-out\")\n        const lifecycleOutcome = await awaitSettledOrGrace(testLifecycle, timeoutMs ?? 60000)\n\n        if (lifecycleOutcome.settled && lifecycleOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(lifecycleOutcome.reason)\n        }\n\n        if (!lifecycleOutcome.settled) {\n          testDatabaseAccessScope.revoked = true\n          void testLifecycle.catch((cleanupError) => {\n            if (isTestDatabaseAccessRevocation(cleanupError)) return\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"test lifecycle\", recordedTimeoutCleanupErrors)\n          })\n          const quarantine = testRunner.quarantineBrowserDummyConnections(browserDummyConnectionRegistrations)\n          const quarantineOutcome = await awaitSettledOrGrace(quarantine, timeoutMs ?? 60000)\n          const usesBrowserTransactions = testArgs.databaseCleaning?.transaction === true\n          const usesBrowserTruncation = testArgs.databaseCleaning?.truncate ?? !usesBrowserTransactions\n\n          abortRemainingTests = testRunner.isBrowserTestMode()\n            && testRunner.hasTag(testArgs, \"dummy\")\n            && (usesBrowserTransactions || usesBrowserTruncation)\n\n          if (quarantineOutcome.settled && quarantineOutcome.status === \"rejected\") {\n            emergencyCleanupErrors.push(quarantineOutcome.reason)\n          } else if (!quarantineOutcome.settled) {\n            void quarantine.catch((cleanupError) => {\n              testRunner.recordTimeoutCleanupFailure(cleanupError, \"browser dummy connection quarantine\", recordedTimeoutCleanupErrors)\n            })\n          }\n        }\n\n        try {\n          if (testSharedConnectionsActive) {\n            testRunner.clearTestSharedConnections(testSharedConnectionRegistrations)\n            testSharedConnectionRegistrations = []\n            testSharedConnectionsActive = false\n          }\n        } catch (cleanupError) {\n          emergencyCleanupErrors.push(cleanupError)\n        }\n\n        const brokerCleanup = testRunner.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation)\n        const brokerCleanupOutcome = await awaitSettledOrGrace(brokerCleanup, timeoutMs ?? 60000)\n\n        if (brokerCleanupOutcome.settled && brokerCleanupOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(brokerCleanupOutcome.reason)\n        } else if (!brokerCleanupOutcome.settled) {\n          void brokerCleanup.catch((cleanupError) => {\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"shared transaction broker\", recordedTimeoutCleanupErrors)\n          })\n        }\n        sharedTransactionBrokerRegistration = undefined\n        sharedTransactionBrokerPreparation = undefined\n        const emergencyCleanup = testRunner.cleanupTransactionalTenants(transactionalTenantRegistrations, {discard: true})\n        const emergencyCleanupOutcome = await awaitSettledOrGrace(emergencyCleanup, timeoutMs ?? 60000)\n\n        if (emergencyCleanupOutcome.settled && emergencyCleanupOutcome.status === \"rejected\") {\n          emergencyCleanupErrors.push(emergencyCleanupOutcome.reason)\n        } else if (!emergencyCleanupOutcome.settled) {\n          void emergencyCleanup.catch((cleanupError) => {\n            testRunner.recordTimeoutCleanupFailure(cleanupError, \"transactional tenant\", recordedTimeoutCleanupErrors)\n          })\n        }\n\n        if (emergencyCleanupErrors.length > 0) {\n          caughtError = new AggregateError(\n            [caughtError, ...emergencyCleanupErrors],\n            \"Test timeout and emergency cleanup failed\",\n            {cause: caughtError}\n          )\n        }\n      }\n\n      if (browserDummyConnectionRegistrations.some((registration) => registration.quarantined)) {\n        testDatabaseAccessScope.revoked = true\n        abortRemainingTests = true\n      }\n    } finally {\n      testDatabaseAccessScope.revoked = true\n      consoleOutput = stopConsoleCapture()\n\n      if (profileAttempt && profiler) {\n        profiler.finishAttempt(profileAttempt, failed\n          ? (attemptTimedOut ? \"timed-out\" : \"failed\")\n          : \"passed\")\n      }\n    }\n\n    return {\n      abortRemainingTests,\n      consoleOutput,\n      error: caughtError,\n      failed\n    }\n  }\n\n  /**\n   * Runs before-each hooks in inherited declaration order.\n   * @param {object} args - Hook arguments.\n   * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} args.beforeEaches - Setup hooks.\n   * @param {import(\"./velocious-test-arguments.js\").TestArgs} args.testArgs - Stable test arguments.\n   * @param {import(\"./velocious-test-arguments.js\").TestData} args.testData - Test registration.\n   * @returns {Promise<void>} - Resolves after all setup hooks complete.\n   */\n  async runBeforeEaches({beforeEaches, testArgs, testData}) {\n    for (const hook of beforeEaches) {\n      await this.testRunner.runProfileSpan({\n        phase: \"beforeEach\",\n        declarationIndex: hook.declarationIndex,\n        declarationScopeId: hook.declarationScopeId,\n        filePath: hook.ownerFilePath\n      }, async () => {\n        await hook.callback({configuration: this.testRunner.getConfiguration(), testArgs, testData})\n      })\n    }\n  }\n\n  /**\n   * Runs every after-each hook while preserving all failures.\n   * @param {object} args - Hook arguments.\n   * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} args.afterEaches - Cleanup hooks.\n   * @param {import(\"./velocious-test-arguments.js\").TestArgs} args.testArgs - Stable test arguments.\n   * @param {import(\"./velocious-test-arguments.js\").TestData} args.testData - Test registration.\n   * @returns {Promise<void>} - Resolves after every cleanup hook settles.\n   */\n  async runAfterEaches({afterEaches, testArgs, testData}) {\n    /** @type {ReturnType<typeof JSON.parse>[]} */\n    const errors = []\n\n    for (const hook of afterEaches) {\n      try {\n        await this.testRunner.runProfileSpan({\n          phase: \"afterEach\",\n          declarationIndex: hook.declarationIndex,\n          declarationScopeId: hook.declarationScopeId,\n          filePath: hook.ownerFilePath\n        }, async () => {\n          await hook.callback({configuration: this.testRunner.getConfiguration(), testArgs, testData})\n        })\n      } catch (error) {\n        errors.push(error)\n      }\n    }\n\n    if (errors.length == 1) throw errors[0]\n    if (errors.length > 1) {\n      throw new AggregateError(errors, \"Multiple afterEach hooks failed\", {cause: errors[0]})\n    }\n  }\n}\n"]}

package/build/src/testing/velocious-runner-reporter.d.ts

@@ -0,0 +1,72 @@
+export default class VelociousRunnerReporter {
+    testRunner: import("./test-runner.js").default;
+    /**
+     * Creates the legacy event and result projection adapter.
+     * @param {object} args - Constructor arguments.
+     * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+     */
+    constructor({ testRunner, ...restArgs }: {
+        testRunner: import("./test-runner.js").default;
+    });
+    /**
+     * Projects one completed attempt into legacy events and final result accounting.
+     * Retry eligibility is decided by the caller before this method runs.
+     * @param {object} args - Completed attempt and retry metadata.
+     * @param {import("./test-runner.js").AttemptConsoleOutput[]} args.attemptConsoleOutputs - Captured output across attempts.
+     * @param {number} args.attemptNumber - Current one-based attempt.
+     * @param {string[]} args.descriptions - Parent description stack.
+     * @param {ReturnType<typeof JSON.parse>} args.error - Raw thrown or rejected value.
+     * @param {boolean} args.failed - Whether the attempt failed, independently of error truthiness.
+     * @param {string} args.leftPadding - Console indentation.
+     * @param {number} args.retriesUsed - Retry count consumed after this attempt.
+     * @param {number} args.retryCount - Configured retry limit.
+     * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
+     * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
+     * @param {string} args.testDescription - Test description.
+     * @param {boolean} args.willRetry - Whether the legacy loop will run another attempt.
+     * @returns {Promise<void>} - Resolves after all legacy listeners complete.
+     */
+    reportAttempt({ attemptConsoleOutputs, attemptNumber, descriptions, error, failed, leftPadding, retriesUsed, retryCount, testArgs, testData, testDescription, willRetry, ...restArgs }: {
+        attemptConsoleOutputs: import("./test-runner.js").AttemptConsoleOutput[];
+        attemptNumber: number;
+        descriptions: string[];
+        error: ReturnType<typeof JSON.parse>;
+        failed: boolean;
+        leftPadding: string;
+        retriesUsed: number;
+        retryCount: number;
+        testArgs: import("./velocious-test-arguments.js").TestArgs;
+        testData: import("./velocious-test-arguments.js").TestData;
+        testDescription: string;
+        willRetry: boolean;
+    }): Promise<void>;
+    /**
+     * Records and emits one final failed test result.
+     * @param {object} args - Final failure metadata.
+     * @param {import("./test-runner.js").AttemptConsoleOutput[]} args.attemptConsoleOutputs - Captured output across attempts.
+     * @param {string[]} args.descriptions - Parent description stack.
+     * @param {ReturnType<typeof JSON.parse>} args.error - Raw final failure.
+     * @param {string} args.leftPadding - Console indentation.
+     * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
+     * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
+     * @param {string} args.testDescription - Test description.
+     * @returns {Promise<void>} - Resolves after the final-failure listener completes.
+     */
+    reportFailedTest({ attemptConsoleOutputs, descriptions, error, leftPadding, testArgs, testData, testDescription }: {
+        attemptConsoleOutputs: import("./test-runner.js").AttemptConsoleOutput[];
+        descriptions: string[];
+        error: ReturnType<typeof JSON.parse>;
+        leftPadding: string;
+        testArgs: import("./velocious-test-arguments.js").TestArgs;
+        testData: import("./velocious-test-arguments.js").TestData;
+        testDescription: string;
+    }): Promise<void>;
+    /**
+     * Emits one legacy event and awaits listeners in registration order.
+     * @param {string} eventName - Event name.
+     * @param {object} payload - Event payload.
+     * @returns {Promise<void>} - Resolves when all listeners complete.
+     */
+    emitEvent(eventName: string, payload: object): Promise<void>;
+}
+//# sourceMappingURL=velocious-runner-reporter.d.ts.map

package/build/src/testing/velocious-runner-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"velocious-runner-reporter.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-runner-reporter.js"],"names":[],"mappings":"AAQA,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAQnC,UAAU;IAPjB;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAGpC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,EAAC,qBAAqB,EAAE,aAAa,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,GAAG,QAAQ,EAAC,EAdvL;QAAgE,qBAAqB,EAA7E,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CACzD;QAAqB,aAAa,EAA1B,MAAM,CACd;QAAuB,YAAY,EAA3B,MAAM,EAAE,CAChB;QAA4C,KAAK,EAAzC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACrC;QAAsB,MAAM,EAApB,OAAO,CACf;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAqB,UAAU,EAAvB,MAAM,CACd;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAAqB,eAAe,EAA5B,MAAM,CACd;QAAsB,SAAS,EAAvB,OAAO,CACf;KAEuL,GAF7K,OAAO,CAAC,IAAI,CAAC,CA2DzB;IAED;;;;;;;;;;;OAWG;IACG,gBAAgB,CAAC,EAAC,qBAAqB,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAC,EATlH;QAAgE,qBAAqB,EAA7E,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CACzD;QAAuB,YAAY,EAA3B,MAAM,EAAE,CAChB;QAA4C,KAAK,EAAzC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACrC;QAAqB,WAAW,EAAxB,MAAM,CACd;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAA+D,QAAQ,EAA/D,OAAO,+BAA+B,EAAE,QAAQ,CACxD;QAAqB,eAAe,EAA5B,MAAM,CACd;KAEkH,GAFxG,OAAO,CAAC,IAAI,CAAC,CA4CzB;IAED;;;;;OAKG;IACG,SAAS,CAAC,SAAS,EAJd,MAIc,EAAE,OAAO,EAHvB,MAGuB,GAFrB,OAAO,CAAC,IAAI,CAAC,CAQzB;CACF"}