velocious 1.0.643 → 1.0.645

package/build/src/testing/test-runner.js

@@ -1,24 +1,27 @@
 // @ts-check
-import { addTrackedStackToError } from "../utils/with-tracked-stack.js";
 import fs from "node:fs/promises";
 import path from "path";
-import { format } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { createTestContext, defaultTestContext } from "@velocious/testing";
+import { TestRunner as PackageTestRunner } from "@velocious/testing/runner";
 import Application from "../../src/application.js";
-import BacktraceCleaner from "../utils/backtrace-cleaner-node.js";
-import { TestDatabaseAccessRevokedError } from "../environment-handlers/base.js";
 import RequestClient from "./request-client.js";
 import picocolors from "picocolors";
 import restArgsError from "../utils/rest-args-error.js";
-import { testConfig, testEvents, tests } from "./test.js";
-import { pathToFileURL } from "url";
-import { clearDeliveries } from "../mailer.js";
+import { testConfig } from "./test.js";
+import { fileURLToPath, pathToFileURL } from "url";
 import SharedTransactionBroker from "./shared-transaction-broker.js";
 import { SHARED_TRANSACTION_BROKER_ENV } from "./shared-transaction-proxy-driver.js";
-import { synchronizeTestingPackageTests } from "./testing-package-adapter.js";
-/**
- * ConsoleMethodName type.
- * @typedef {"log" | "info" | "warn" | "error" | "debug"} ConsoleMethodName */
+import VelociousAttemptExecutor from "./velocious-attempt-executor.js";
+import VelociousRunnerReporter, { AbortRemainingTestsError } from "./velocious-runner-reporter.js";
+import VelociousSuiteHookExecutor from "./velocious-suite-hook-executor.js";
+import VelociousTestArguments from "./velocious-test-arguments.js";
+/** @typedef {typeof defaultTestContext} PackageTestContext */
+/** @typedef {(typeof defaultTestContext.registry.suites)[number]} PackageSuiteDeclaration */
+/** @typedef {PackageSuiteDeclaration["tests"][number]} PackageTestDeclaration */
+/** @typedef {PackageSuiteDeclaration["hooks"]["beforeAll"][number]} PackageHookDeclaration */
+/** @typedef {PackageSuiteDeclaration | PackageTestDeclaration | PackageHookDeclaration} PackageRegistration */
+/** @typedef {{hadRetries: boolean, options: PackageTestDeclaration["options"], retries: number | undefined}} PackageRetryOptionRestoration */
 /**
  * AttemptConsoleOutput type.
  * @typedef {object} AttemptConsoleOutput
@@ -60,6 +63,7 @@ import { synchronizeTestingPackageTests } from "./testing-package-adapter.js";
  * @property {number} [line] - Source line number.
  * @property {string} [ownerFilePath] - Deterministic importing test file.
  * @property {(arg: TestArgs) => (void|Promise<void>)} function - Test callback to execute.
+ * @property {PackageTestDeclaration} [declaration] - Package declaration.
  */
 /**
  * FailedTestDetail type.
@@ -71,13 +75,6 @@ import { synchronizeTestingPackageTests } from "./testing-package-adapter.js";
  * @property {string} [consoleOutput] - Captured console output while test ran.
  * @property {string} [consoleLogPath] - Saved console log path.
  */
-/**
- * ActiveAfterAllScopeEntry type.
- * @typedef {object} ActiveAfterAllScopeEntry
- * @property {TestsArgument} tests - Scope test tree.
- * @property {boolean} afterAllsRun - Whether cleanup hooks have run.
- * @property {string} [profileScopeId] - Opaque profile scope identifier.
- */
 /**
  * Defines this typedef.
  * @typedef {(args: {configuration: import("../configuration.js").default, testArgs: TestArgs, testData: TestData}) => (void|Promise<void>)} AfterBeforeEachCallbackType
@@ -118,9 +115,8 @@ import { synchronizeTestingPackageTests } from "./testing-package-adapter.js";
  * @property {Record<string, TestsArgument>} subs - Optional child nodes. Each item is another `Node`, allowing recursion.
  */
 /**
- * Marks the error thrown by {@link runWithTimeout} so the caller can tell a
- * lifecycle timeout (the promise is still running detached) apart from an
- * ordinary test failure (the promise already settled).
+ * Marks the error thrown by the attempt timeout so the runner can distinguish
+ * detached lifecycle cleanup from an ordinary test failure.
  * @typedef {Error & {velociousTestTimeout?: true}} TestTimeoutError
  */
 /**
@@ -142,89 +138,6 @@ import { synchronizeTestingPackageTests } from "./testing-package-adapter.js";
  * @property {string} reuseKey - Resolved physical configuration identity.
  * @property {import("../database/pool/base.js").TestSharedConnectionRegistration | undefined} sharedRegistration - Physical-key shared registration once published.
  */
-/**
- * Runs run with timeout.
- *
- * On timeout the wrapped `promise` is NOT cancelled — it keeps running detached.
- * The rejected error is tagged with `velociousTestTimeout` so the runner knows
- * the lifecycle (and its afterEach database cleanup) is still in flight and can
- * wait for it to settle before the next test reuses the shared connection.
- * @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>>} - Resolves or rejects based on timeout or promise 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 an abandoned (timed-out) test lifecycle to settle, bounded by a
- * grace period, so its afterEach database cleanup runs on the shared connection
- * before the next test reuses it. Returns the fulfillment/rejection outcome if
- * the lifecycle settles, or a pending outcome once the grace elapses.
- *
- * The grace timer is kept ref'd so it cannot let Node exit with an unsettled
- * top-level await when the timed-out lifecycle has no ref'd handles of its own
- * (for example a stalled mocked async API). Once the caller continues past this
- * await, the timer has already resolved and no longer anchors the event loop.
- * @param {Promise<ReturnType<typeof JSON.parse>>} lifecycle - The abandoned per-test lifecycle promise.
- * @param {number} graceMs - Maximum time to wait for the lifecycle to settle.
- * @returns {Promise<{settled: false} | {settled: true, status: "fulfilled"} | {settled: true, status: "rejected", reason: unknown}>} - 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 test access was revoked.
- * @param {unknown} 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;
-}
-/**
- * Captured console methods.
- * @type {ConsoleMethodName[]} */
-const CAPTURED_CONSOLE_METHODS = ["log", "info", "warn", "error", "debug"];
 /**
  * Runs to file slug.
  * @param {string} value - Value to sanitize.
@@ -238,10 +151,8 @@ function toFileSlug(value) {
         .slice(0, 80) || "failed-test";
 }
 export default class TestRunner {
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {ActiveAfterAllScopeEntry[]} */
-    _activeAfterAllScopes;
+    /** @type {PackageTestContext} */
+    _context;
     /**
      * Narrows the runtime value to the documented type.
      * @type {FailedTestDetail[]} */
@@ -250,6 +161,7 @@ export default class TestRunner {
      * Runs constructor.
      * @param {object} args - Options object.
      * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {PackageTestContext} [args.context] - Declaration context.
      * @param {string[] | string} [args.excludeTags] - Tags to exclude.
      * @param {string[] | string} [args.includeTags] - Tags to include.
      * @param {Array<string>} args.testFiles - Test files.
@@ -257,17 +169,16 @@ export default class TestRunner {
      * @param {RegExp[]} [args.examplePatterns] - Example patterns.
      * @param {import("./test-profiler.js").default} [args.profiler] - Opt-in profiler.
      */
-    constructor({ configuration, excludeTags, includeTags, testFiles, lineFilters, examplePatterns, profiler, ...restArgs }) {
+    constructor({ configuration, context = defaultTestContext, excludeTags, includeTags, testFiles, lineFilters, examplePatterns, profiler, ...restArgs }) {
         restArgsError(restArgs);
         if (!configuration)
             throw new Error("configuration is required");
         this._configuration = configuration;
+        this._context = context;
         this._sharedTransactionCoordinatorOwnerStorage = new AsyncLocalStorage();
         this._testDatabaseAccessScopeStorage = new AsyncLocalStorage();
         this._excludeTags = this.normalizeTags(excludeTags);
-        this._excludeTagSet = new Set(this._excludeTags);
         this._includeTags = this.normalizeTags(includeTags);
-        this._includeTagSet = new Set(this._includeTags);
         this._testFiles = testFiles;
         this._lineFilters = lineFilters || {};
         this._examplePatterns = examplePatterns || [];
@@ -276,13 +187,47 @@ export default class TestRunner {
         this._failedTests = 0;
         this._successfulTests = 0;
         this._testsCount = 0;
-        this._activeAfterAllScopes = [];
         this._failedTestDetails = [];
         /** @type {{fullDescription: string, filePath: string, line: number} | null} */
         this._lastTestContext = null;
         /** @type {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} */
         this._testDurations = [];
+        /** @type {WeakMap<PackageTestDeclaration, {testArgs: TestArgs, testData: TestData}>} */
+        this._testCompatibility = new WeakMap();
+        /** @type {WeakSet<PackageTestDeclaration>} */
+        this._injectedTests = new WeakSet();
+        /** @type {WeakSet<PackageTestDeclaration>} */
+        this._completedTests = new WeakSet();
+        /** @type {WeakMap<PackageTestDeclaration, {descriptions: string[], testDescription: string, fullDescription: string, ownerFilePath: string | undefined, suites: PackageSuiteDeclaration[]}>} */
+        this._testMetadata = new WeakMap();
+        /** @type {WeakMap<PackageHookDeclaration, {declarationIndex: number, declarationScopeId: string | undefined, ownerFilePath: string | undefined}>} */
+        this._hookMetadata = new WeakMap();
+        /** @type {WeakMap<PackageTestDeclaration, Map<number, {abortRemainingTests: boolean, error: ReturnType<typeof JSON.parse>, failed: boolean}>>} */
+        this._attemptOutcomes = new WeakMap();
+        /** @type {Array<{suite: PackageSuiteDeclaration, phase: "beforeAll" | "afterAll", error: ReturnType<typeof JSON.parse>}>} */
+        this._suiteHookFailures = [];
+        /** @type {Map<string, PackageTestDeclaration[]>} */
+        this._testsByFullName = new Map();
+        /** @type {WeakMap<PackageRegistration, string>} */
+        this._declarationOwners = new WeakMap();
+        /** @type {PackageTestRunner | undefined} */
+        this._packageRunner = undefined;
+        /** @type {import("@velocious/testing/runner").TestRunResult | undefined} */
+        this._packageResult = undefined;
+        /** @type {Map<string, TestData> | undefined} */
+        this._legacyFixtureDataByFullName = undefined;
+        /** @type {{filePath?: string, line?: number}} */
+        this._legacyFixtureLocation = {};
+        this._attemptExecutor = new VelociousAttemptExecutor({ testRunner: this });
+        this._runnerReporter = new VelociousRunnerReporter({ testRunner: this });
+        this._suiteHookExecutor = new VelociousSuiteHookExecutor({ testRunner: this });
+        this._testArguments = new VelociousTestArguments({ testRunner: this });
     }
+    /**
+     * Gets the package declaration context.
+     * @returns {PackageTestContext} - Package declaration context.
+     */
+    getTestContext() { return this._context; }
     /**
      * Runs get configuration.
      * @returns {import("../configuration.js").default} - The configuration.
@@ -319,23 +264,6 @@ export default class TestRunner {
             return await callback();
         return await this._profiler.runSpan(metadata, callback);
     }
-    /**
-     * Adds declaration metadata to hooks only for an active profile.
-     * @template {AfterBeforeEachCallbackObjectType | BeforeAfterAllCallbackObjectType} T
-     * @param {T[]} hooks - Hooks declared in one scope.
-     * @param {string | undefined} declarationScopeId - Profile scope identifier.
-     * @param {string | undefined} ownerFilePath - Scope owner file.
-     * @returns {T[]} - Profile-aware hook entries.
-     */
-    profileHookEntries(hooks, declarationScopeId, ownerFilePath) {
-        if (!this._profiler)
-            return hooks;
-        return hooks.map((hook, declarationIndex) => Object.assign({}, hook, {
-            declarationIndex: hook.declarationIndex ?? declarationIndex,
-            declarationScopeId: hook.declarationScopeId ?? declarationScopeId,
-            ownerFilePath: hook.ownerFilePath ?? ownerFilePath
-        }));
-    }
     /**
      * Runs normalize tags.
      * @param {string[] | string | undefined} tags - Tags.
@@ -612,99 +540,6 @@ export default class TestRunner {
         const configTags = Array.isArray(testConfig.excludeTags) ? testConfig.excludeTags : [];
         return new Set([...this._excludeTags, ...configTags]);
     }
-    /**
-     * Runs has matching tag.
-     * @param {string[] | string | undefined} testTags - Test tags.
-     * @param {Set<string>} tagSet - Tag set.
-     * @returns {boolean} - Whether any tags match.
-     */
-    hasMatchingTag(testTags, tagSet) {
-        if (!tagSet.size)
-            return false;
-        const normalized = this.normalizeTags(testTags);
-        for (const tag of normalized) {
-            if (tagSet.has(tag))
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Runs has runnable tests.
-     * @param {TestsArgument} tests - Tests.
-     * @param {string[]} [descriptions] - Description stack.
-     * @param {boolean} [lineMatchedInScope] - Whether line matched in scope.
-     * @returns {boolean} - Whether any tests in this scope will run.
-     */
-    hasRunnableTests(tests, descriptions = [], lineMatchedInScope = false) {
-        for (const testDescription in tests.tests) {
-            const testData = tests.tests[testDescription];
-            const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.args));
-            const includeByLine = lineMatchedInScope || this.matchesLineFilter(testData);
-            if (this._onlyFocussed && !testArgs.focus)
-                continue;
-            if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine))
-                continue;
-            return true;
-        }
-        for (const subDescription in tests.subs) {
-            const subTest = tests.subs[subDescription];
-            const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(subTest);
-            const nextDescriptions = descriptions.concat([subDescription]);
-            if (this._onlyFocussed && !subTest.anyTestsFocussed)
-                continue;
-            if (this.hasRunnableTests(subTest, nextDescriptions, scopeLineMatch))
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Runs should skip test.
-     * @param {TestArgs} testArgs - Test args.
-     * @param {TestData} testData - Test data.
-     * @param {string} testDescription - Test description.
-     * @param {string[]} descriptions - Description stack.
-     * @param {boolean} lineMatchedInScope - Whether line matched in scope.
-     * @returns {boolean} - Whether the test should be skipped.
-     */
-    shouldSkipTest(testArgs, testData, testDescription, descriptions, lineMatchedInScope) {
-        if (this.hasTag(testArgs, "browser-only") && !this.isBrowserTestMode())
-            return true;
-        if (this.hasMatchingTag(testArgs.tags, this.getExcludeTagSet()))
-            return true;
-        if (this._includeTagSet.size > 0 && !testArgs.focus) {
-            if (!this.hasMatchingTag(testArgs.tags, this._includeTagSet))
-                return true;
-        }
-        if (this.getExamplePatterns().length > 0) {
-            const fullDescription = this.buildFullDescription(descriptions, testDescription);
-            const matches = this.getExamplePatterns().some((pattern) => {
-                pattern.lastIndex = 0;
-                return pattern.test(fullDescription);
-            });
-            if (!matches)
-                return true;
-        }
-        const lineFilters = this.getLineFilters();
-        if (Object.keys(lineFilters).length > 0) {
-            if (!lineMatchedInScope && !this.matchesLineFilter(testData))
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Runs matches line filter.
-     * @param {TestData | TestsArgument} entry - Test entry.
-     * @returns {boolean} - Whether line filter matches entry.
-     */
-    matchesLineFilter(entry) {
-        if (!entry || !entry.filePath || !entry.line)
-            return false;
-        const filePath = path.resolve(entry.filePath);
-        const lines = this.getLineFilters()[filePath];
-        if (!lines || lines.length === 0)
-            return false;
-        return lines.includes(entry.line);
-    }
     /**
      * Runs build full description.
      * @param {string[]} descriptions - Description stack.
@@ -1043,63 +878,53 @@ export default class TestRunner {
         const environmentHandler = this.getConfiguration().getEnvironmentHandler();
         if (!this._profiler) {
             await environmentHandler.importTestFiles(this.getTestFiles());
-            synchronizeTestingPackageTests(tests);
             return;
         }
         for (const testFile of this.getTestFiles()) {
-            const existingRegistrations = this.testRegistrationObjects(tests);
+            const existingRegistrations = this.testRegistrationObjects();
             await this._profiler.measurePhase("imports", async () => {
                 await environmentHandler.importTestFiles([testFile]);
             }, { filePath: testFile });
-            synchronizeTestingPackageTests(tests);
-            this.assignTestRegistrationOwnership(tests, existingRegistrations, testFile);
+            this.assignTestRegistrationOwnership(existingRegistrations, testFile);
         }
     }
     /**
-     * Collects registered scope, hook, and test objects by identity.
-     * @param {TestsArgument} scope - Test scope.
-     * @param {Set<object>} [registrations] - Accumulated identities.
-     * @returns {Set<object>} - Registration identities.
+     * Collects package declaration objects by identity.
+     * @param {Set<PackageRegistration>} [registrations] - Accumulated identities.
+     * @returns {Set<PackageRegistration>} - Registration identities.
      */
-    testRegistrationObjects(scope, registrations = new Set()) {
-        registrations.add(scope);
-        for (const hook of [...scope.beforeAlls, ...scope.beforeEaches, ...scope.afterEaches, ...scope.afterAlls]) {
-            registrations.add(hook);
-        }
-        for (const testData of Object.values(scope.tests))
-            registrations.add(testData);
-        for (const childScope of Object.values(scope.subs))
-            this.testRegistrationObjects(childScope, registrations);
+    testRegistrationObjects(registrations = new Set()) {
+        const visit = (/** @type {PackageSuiteDeclaration} */ suite) => {
+            registrations.add(suite);
+            for (const hook of [...suite.hooks.beforeAll, ...suite.hooks.beforeEach, ...suite.hooks.afterEach, ...suite.hooks.afterAll]) {
+                registrations.add(hook);
+            }
+            for (const testDeclaration of suite.tests)
+                registrations.add(testDeclaration);
+            for (const childSuite of suite.suites)
+                visit(childSuite);
+        };
+        for (const suite of this.getTestContext().registry.suites)
+            visit(suite);
         return registrations;
     }
     /**
-     * Assigns deterministic ownership to registrations added by one entry file,
-     * including declarations originating in a helper imported by that entry file.
-     * @param {TestsArgument} scope - Test scope.
-     * @param {Set<object>} previousRegistrations - Identities present before import.
+     * Assigns deterministic ownership to package declarations added by one entry file.
+     * @param {Set<PackageRegistration>} previousRegistrations - Identities present before import.
      * @param {string} ownerFilePath - Importing entry file.
      * @returns {void}
      */
-    assignTestRegistrationOwnership(scope, previousRegistrations, ownerFilePath) {
-        if (!previousRegistrations.has(scope))
-            scope.ownerFilePath ??= ownerFilePath;
-        for (const hook of [...scope.beforeAlls, ...scope.beforeEaches, ...scope.afterEaches, ...scope.afterAlls]) {
-            if (!previousRegistrations.has(hook))
-                hook.ownerFilePath ??= ownerFilePath;
-        }
-        for (const testData of Object.values(scope.tests)) {
-            if (!previousRegistrations.has(testData))
-                testData.ownerFilePath ??= ownerFilePath;
-        }
-        for (const childScope of Object.values(scope.subs)) {
-            this.assignTestRegistrationOwnership(childScope, previousRegistrations, ownerFilePath);
+    assignTestRegistrationOwnership(previousRegistrations, ownerFilePath) {
+        for (const registration of this.testRegistrationObjects()) {
+            if (!previousRegistrations.has(registration))
+                this._declarationOwners.set(registration, ownerFilePath);
         }
     }
     /**
      * Runs is failed.
      * @returns {boolean} - Whether failed.
      */
-    isFailed() { return this._failedTests !== undefined && this._failedTests > 0; }
+    isFailed() { return this._failedTests !== undefined && (this._failedTests > 0 || this._packageResult?.status === "failed"); }
     /**
      * Runs get failed tests.
      * @returns {number} - The failed tests.
@@ -1177,7 +1002,7 @@ export default class TestRunner {
      * @returns {number} - The executed tests count.
      */
     getExecutedTestsCount() {
-        return this._testDurations.length;
+        return this._packageResult?.tests.length ?? this._testDurations.length;
     }
     /**
      * Returns the tests recorded during the run, slowest first.
@@ -1200,15 +1025,75 @@ export default class TestRunner {
         this._abortRemainingTests = false;
         this._failedTestDetails = [];
         this._testDurations = [];
+        this._testCompatibility = new WeakMap();
+        this._injectedTests = new WeakSet();
+        this._completedTests = new WeakSet();
+        this._testMetadata = new WeakMap();
+        this._hookMetadata = new WeakMap();
+        this._attemptOutcomes = new WeakMap();
+        this._suiteHookFailures = [];
+        this._testsByFullName = new Map();
+        this._packageResult = undefined;
+        const context = this.getTestContext();
+        /** @type {string | undefined} */
+        let ownerFilePath;
+        context.reset({ config: true });
+        context.setDeclarationLocator(() => this.captureTestDeclarationLocation(ownerFilePath));
         const testingConfigPath = this.getConfiguration().getTesting();
-        if (testingConfigPath) {
-            await this.runProfileSpan({ phase: "testing config/global setup" }, async () => {
-                await this.getConfiguration().getEnvironmentHandler().importTestingConfigPath();
-            });
+        await context.describe("", { databaseCleaning: { transaction: true } }, async () => {
+            if (testingConfigPath) {
+                await this.runProfileSpan({ phase: "testing config/global setup" }, async () => {
+                    await this.getConfiguration().getEnvironmentHandler().importTestingConfigPath();
+                });
+            }
+            if (!this._profiler) {
+                await this.importTestFiles();
+            }
+            else {
+                for (const testFile of this.getTestFiles()) {
+                    ownerFilePath = testFile;
+                    const existingRegistrations = this.testRegistrationObjects();
+                    await this._profiler.measurePhase("imports", async () => {
+                        await this.getConfiguration().getEnvironmentHandler().importTestFiles([testFile]);
+                    }, { filePath: testFile });
+                    this.assignTestRegistrationOwnership(existingRegistrations, testFile);
+                }
+            }
+        });
+        ownerFilePath = undefined;
+        this.analyzeDeclarations();
+    }
+    /**
+     * Captures a test source location without attributing package/facade frames.
+     * @param {string | undefined} ownerFilePath - Importing entry file fallback.
+     * @returns {{filePath?: string, line?: number}} - Declaration location.
+     */
+    captureTestDeclarationLocation(ownerFilePath) {
+        const stack = new Error().stack?.split("\n") || [];
+        for (const stackLine of stack) {
+            const match = stackLine.match(/(?:\(|\s)(file:\/\/.*?|\/[^"]*?):(\d+):(\d+)\)?$/u);
+            if (!match)
+                continue;
+            let filePath = match[1];
+            if (filePath.startsWith("file://")) {
+                try {
+                    filePath = fileURLToPath(filePath);
+                }
+                catch {
+                    continue;
+                }
+            }
+            const resolvedFilePath = path.resolve(filePath);
+            const portablePath = resolvedFilePath.replaceAll(path.sep, "/");
+            if (portablePath.endsWith("/src/testing/test-runner.js"))
+                continue;
+            if (portablePath.endsWith("/src/testing/test.js"))
+                continue;
+            if (portablePath.includes("/node_modules/@velocious/testing/"))
+                continue;
+            return { filePath: resolvedFilePath, line: Number(match[2]) };
         }
-        await this.importTestFiles();
-        await this.analyzeTests(tests);
-        this._onlyFocussed = this.anyTestsFocussed;
+        return ownerFilePath ? { filePath: ownerFilePath } : {};
     }
     /**
      * Runs are any tests focussed.
@@ -1320,13 +1205,7 @@ export default class TestRunner {
         process.on("unhandledRejection", onUnhandledRejection);
         process.on("uncaughtException", onUncaughtException);
         try {
-            await this.runTests({
-                afterEaches: [],
-                beforeEaches: [],
-                tests,
-                descriptions: [],
-                indentLevel: 0
-            });
+            await this.runPackageTests();
             // A rejection scheduled by the final test (a detached rejected promise,
             // or an afterCommit callback rejecting as the suite drains) is reported
             // by Node on a LATER turn. Drain a few turns while the handler is still
@@ -1346,648 +1225,389 @@ export default class TestRunner {
      * @returns {Promise<void>} - Resolves when cleanup hooks finish.
      */
     async runAfterAllsForActiveScopes() {
-        const scopes = [...this._activeAfterAllScopes].reverse();
-        /** @type {unknown[]} */
-        const afterAllErrors = [];
-        for (const scope of scopes) {
-            try {
-                await this.runAfterAllsForScope(scope);
+        const failureStart = this._suiteHookFailures.length;
+        await this._packageRunner?.cleanupActiveSuites();
+        this.throwAfterAllFailures(this._suiteHookFailures.slice(failureStart));
+    }
+    /** Builds declaration metadata used only by framework adapters and projections. */
+    analyzeDeclarations() {
+        const visit = (/** @type {PackageSuiteDeclaration} */ suite, /** @type {PackageSuiteDeclaration[]} */ ancestors, /** @type {string | undefined} */ parentProfileScopeId) => {
+            const suites = [...ancestors, suite];
+            const descriptions = suites.map((entry) => entry.name).filter((name) => name !== "");
+            const ownerFilePath = this._declarationOwners.get(suite) ?? suite.location.filePath;
+            const profileScopeId = this._profiler?.scopeId(suite, {
+                descriptions,
+                filePath: ownerFilePath,
+                line: suite.location.line,
+                parentId: parentProfileScopeId
+            });
+            for (const hooks of Object.values(suite.hooks)) {
+                hooks.forEach((hook, declarationIndex) => {
+                    this._hookMetadata.set(hook, {
+                        declarationIndex,
+                        declarationScopeId: profileScopeId,
+                        ownerFilePath: this._declarationOwners.get(hook) ?? hook.location.filePath ?? ownerFilePath
+                    });
+                });
             }
-            catch (error) {
-                afterAllErrors.push(error);
+            for (const testDeclaration of suite.tests) {
+                const fullDescription = this.buildFullDescription(descriptions, testDeclaration.name);
+                const declarations = this._testsByFullName.get(fullDescription) || [];
+                declarations.push(testDeclaration);
+                this._testsByFullName.set(fullDescription, declarations);
+                this._testMetadata.set(testDeclaration, {
+                    descriptions,
+                    testDescription: testDeclaration.name,
+                    fullDescription,
+                    ownerFilePath: this._declarationOwners.get(testDeclaration) ?? testDeclaration.location.filePath ?? ownerFilePath,
+                    suites
+                });
+                const legacyTestData = this._legacyFixtureDataByFullName?.get(fullDescription);
+                if (legacyTestData) {
+                    this._testCompatibility.set(testDeclaration, {
+                        testArgs: this._testArguments.copy(testDeclaration),
+                        testData: legacyTestData
+                    });
+                }
+                this._testsCount++;
+                if (testDeclaration.state === "run" && (testDeclaration.focus || suites.some((entry) => entry.focus))) {
+                    this.anyTestsFocussed = true;
+                }
             }
-        }
-        this._activeAfterAllScopes = [];
-        if (afterAllErrors.length == 1)
-            throw afterAllErrors[0];
-        if (afterAllErrors.length > 1) {
-            throw new AggregateError(afterAllErrors, "Multiple active afterAll scopes failed", { cause: afterAllErrors[0] });
-        }
+            for (const childSuite of suite.suites)
+                visit(childSuite, suites, profileScopeId);
+        };
+        for (const suite of this.getTestContext().registry.suites)
+            visit(suite, [], undefined);
     }
     /**
-     * Runs analyze tests.
-     * @param {TestsArgument} tests - Tests.
-     * @returns {{anyTestsFocussed: boolean}} - Whether any tests in the tree are focused.
+     * Gets package hook compatibility metadata.
+     * @param {PackageHookDeclaration} hook - Package hook declaration.
+     * @returns {{declarationIndex: number, declarationScopeId: string | undefined, ownerFilePath: string | undefined}} - Hook metadata.
      */
-    analyzeTests(tests) {
-        let anyTestsFocussedFound = false;
-        for (const testDescription in tests.tests) {
-            const testData = tests.tests[testDescription];
-            const testArgs = Object.assign({}, testData.args);
-            this._testsCount++;
-            if (testArgs.focus) {
-                anyTestsFocussedFound = true;
-                this.anyTestsFocussed = true;
-            }
+    hookMetadata(hook) {
+        return this._hookMetadata.get(hook) || { declarationIndex: 0, declarationScopeId: undefined, ownerFilePath: hook.location.filePath };
+    }
+    /**
+     * Gets package test compatibility metadata.
+     * @param {PackageTestDeclaration} test - Package test declaration.
+     * @returns {{descriptions: string[], testDescription: string, fullDescription: string, ownerFilePath: string | undefined, suites: PackageSuiteDeclaration[]}} - Declaration metadata.
+     */
+    testMetadata(test) {
+        const metadata = this._testMetadata.get(test);
+        if (!metadata)
+            throw new Error(`Missing package test metadata: ${test.name}`);
+        return metadata;
+    }
+    /**
+     * Gets stable compatibility data for a package declaration.
+     * @param {PackageTestDeclaration} test - Package test declaration.
+     * @returns {{testArgs: TestArgs, testData: TestData}} - Stable compatibility data.
+     */
+    testData(test) {
+        let compatibility = this._testCompatibility.get(test);
+        if (!compatibility) {
+            const testArgs = this._testArguments.copy(test);
+            const metadata = this.testMetadata(test);
+            const testData = {
+                args: testArgs,
+                declaration: test,
+                filePath: test.location.filePath,
+                function: test.callback,
+                line: test.location.line,
+                ownerFilePath: metadata.ownerFilePath
+            };
+            compatibility = { testArgs, testData };
+            this._testCompatibility.set(test, compatibility);
         }
-        for (const subDescription in tests.subs) {
-            const subTest = tests.subs[subDescription];
-            const { anyTestsFocussed } = this.analyzeTests(subTest);
-            if (anyTestsFocussed) {
-                anyTestsFocussedFound = true;
-            }
-            subTest.anyTestsFocussed = anyTestsFocussed;
+        return compatibility;
+    }
+    /**
+     * Injects framework collaborators into stable compatibility data once.
+     * @param {PackageTestDeclaration} test - Package test declaration.
+     * @returns {Promise<{testArgs: TestArgs, testData: TestData}>} - Injected compatibility data.
+     */
+    async testCompatibility(test) {
+        const compatibility = this.testData(test);
+        if (!this._injectedTests.has(test)) {
+            await this._testArguments.inject(compatibility.testArgs);
+            this._injectedTests.add(test);
         }
-        return { anyTestsFocussed: anyTestsFocussedFound };
+        return compatibility;
     }
     /**
-     * Runs every after-each hook while preserving the first failure.
-     * @param {object} args - Hook execution arguments.
-     * @param {AfterBeforeEachCallbackObjectType[]} args.afterEaches - Hooks to run.
-     * @param {TestArgs} args.testArgs - Current test arguments.
-     * @param {TestData} args.testData - Current test data.
-     * @returns {Promise<void>} - Resolves after every hook runs.
+     * Records a raw framework attempt outcome.
+     * @param {PackageTestDeclaration} test - Package test declaration.
+     * @param {number} attemptNumber - One-based attempt number.
+     * @param {{abortRemainingTests: boolean, error: ReturnType<typeof JSON.parse>, failed: boolean}} outcome - Raw attempt outcome.
+     * @returns {void}
      */
-    async runAfterEaches({ afterEaches, testArgs, testData }) {
-        /** @type {unknown[]} */
-        const afterEachErrors = [];
-        for (const afterEachData of afterEaches) {
-            try {
-                await this.runProfileSpan({
-                    phase: "afterEach",
-                    declarationIndex: afterEachData.declarationIndex,
-                    declarationScopeId: afterEachData.declarationScopeId,
-                    filePath: afterEachData.ownerFilePath
-                }, async () => {
-                    await afterEachData.callback({ configuration: this.getConfiguration(), testArgs, testData });
+    recordAttemptOutcome(test, attemptNumber, outcome) {
+        const outcomes = this._attemptOutcomes.get(test) || new Map();
+        outcomes.set(attemptNumber, outcome);
+        this._attemptOutcomes.set(test, outcomes);
+        if (outcome.abortRemainingTests)
+            this._abortRemainingTests = true;
+    }
+    /**
+     * Gets a raw framework attempt outcome.
+     * @param {PackageTestDeclaration} test - Package test declaration.
+     * @param {number} attemptNumber - One-based attempt number.
+     * @returns {{abortRemainingTests: boolean, error: ReturnType<typeof JSON.parse>, failed: boolean} | undefined} - Raw attempt outcome.
+     */
+    attemptOutcome(test, attemptNumber) { return this._attemptOutcomes.get(test)?.get(attemptNumber); }
+    /**
+     * Records a raw suite-hook failure.
+     * @param {object} failure - Suite-hook failure.
+     * @param {PackageSuiteDeclaration} failure.suite - Owning package suite.
+     * @param {"beforeAll" | "afterAll"} failure.phase - Hook phase.
+     * @param {ReturnType<typeof JSON.parse>} failure.error - Raw hook failure.
+     * @returns {void}
+     */
+    recordSuiteHookFailure(failure) { this._suiteHookFailures.push(failure); }
+    /**
+     * Gets the raw ancestor setup failure for a package test.
+     * @param {PackageTestDeclaration} test - Package test declaration.
+     * @returns {ReturnType<typeof JSON.parse>} - Raw setup failure.
+     */
+    setupFailureFor(test) {
+        const suites = this.testMetadata(test).suites;
+        return this._suiteHookFailures.find((failure) => failure.phase === "beforeAll" && suites.includes(failure.suite))?.error;
+    }
+    /**
+     * Finds the next incomplete declaration with a package full name.
+     * @param {string} fullName - Package full name.
+     * @returns {PackageTestDeclaration | undefined} - Next matching declaration.
+     */
+    findTestDeclaration(fullName) {
+        return this._testsByFullName.get(fullName)?.find((test) => !this._completedTests.has(test));
+    }
+    /**
+     * Marks a package declaration complete.
+     * @param {PackageTestDeclaration} test - Completed declaration.
+     * @returns {void}
+     */
+    completeTestDeclaration(test) { this._completedTests.add(test); }
+    /**
+     * Gets the effective package retry count.
+     * @param {PackageTestDeclaration} test - Package test declaration.
+     * @returns {number} - Effective retry count.
+     */
+    retryCount(test) {
+        const value = test.options.retries ?? test.options.retry ?? this.getTestContext().config.retries;
+        return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+    }
+    /**
+     * Normalizes retry inputs for the package execution boundary while retaining
+     * the declarations' original public options after the run.
+     * @returns {() => void} - Restores original declaration options.
+     */
+    normalizePackageRetriesForExecution() {
+        /** @type {PackageRetryOptionRestoration[]} */
+        const restorations = [];
+        /**
+         * Normalizes declarations in one suite.
+         * @param {PackageSuiteDeclaration} suite - Suite whose tests are normalized.
+         */
+        const visit = (suite) => {
+            for (const test of suite.tests) {
+                // Capture compatibility arguments before temporarily adapting package
+                // execution options so callbacks retain their declared values/identity.
+                this.testData(test);
+                restorations.push({
+                    hadRetries: Object.hasOwn(test.options, "retries"),
+                    options: test.options,
+                    retries: test.options.retries
                 });
+                test.options.retries = this.retryCount(test);
             }
-            catch (error) {
-                afterEachErrors.push(error);
+            for (const childSuite of suite.suites)
+                visit(childSuite);
+        };
+        for (const suite of this.getTestContext().registry.suites)
+            visit(suite);
+        return () => {
+            for (const restoration of restorations) {
+                if (restoration.hadRetries)
+                    restoration.options.retries = restoration.retries;
+                else
+                    delete restoration.options.retries;
             }
-        }
-        if (afterEachErrors.length == 1)
-            throw afterEachErrors[0];
-        if (afterEachErrors.length > 1) {
-            throw new AggregateError(afterEachErrors, "Multiple afterEach hooks failed", { cause: afterEachErrors[0] });
-        }
+        };
     }
     /**
-     * Runs run tests.
-     * @param {object} args - Options object.
-     * @param {Array<AfterBeforeEachCallbackObjectType>} args.afterEaches - After eaches.
-     * @param {Array<AfterBeforeEachCallbackObjectType>} args.beforeEaches - Before eaches.
-     * @param {TestsArgument} args.tests - Tests.
-     * @param {string[]} args.descriptions - Descriptions.
-     * @param {number} args.indentLevel - Indent level.
-     * @param {boolean} [args.lineMatchedInScope] - Whether line matched in scope.
-     * @param {string} [args.parentProfileScopeId] - Parent profile scope.
-     * @returns {Promise<void>} - Resolves when complete.
+     * Records one completed test duration.
+     * @param {{durationMs: number, filePath: string, fullDescription: string, line: number}} duration - Completed test duration.
+     * @returns {void}
+     */
+    recordTestDuration(duration) { this._testDurations.push(duration); }
+    /** Records one successful package result. */
+    recordSuccessfulTest() { this._successfulTests++; }
+    /**
+     * Records one failed package test in the legacy result projection.
+     * @param {object} args - Failed test metadata.
+     * @param {string[]} args.descriptions - Parent descriptions.
+     * @param {ReturnType<typeof JSON.parse>} args.error - Raw failure.
+     * @param {string} args.consoleOutput - Captured console output.
+     * @param {TestData} args.testData - Compatibility test data.
+     * @param {string} args.testDescription - Test description.
+     * @returns {void}
+     */
+    recordFailedTest({ descriptions, error, consoleOutput, testData, testDescription }) {
+        this._failedTests++;
+        this._failedTestDetails.push({
+            fullDescription: this.buildFullDescription(descriptions, testDescription),
+            filePath: testData.filePath,
+            line: testData.line,
+            error,
+            consoleOutput: consoleOutput || undefined
+        });
+    }
+    /**
+     * Stores the completed package result.
+     * @param {import("@velocious/testing/runner").TestRunResult} result - Package result.
+     * @returns {void}
+     */
+    recordPackageResult(result) { this._packageResult = result; }
+    /**
+     * Runs the package kernel with Velocious framework adapters.
+     * @returns {Promise<void>} - Resolves after execution and teardown.
      */
-    async runTests({ afterEaches, beforeEaches, tests, descriptions, indentLevel, lineMatchedInScope = false, parentProfileScopeId }) {
+    async runPackageTests() {
         const environmentHandler = this.getConfiguration().getEnvironmentHandler();
         environmentHandler.installSharedTransactionCoordinatorOwnerStorage(this._sharedTransactionCoordinatorOwnerStorage);
         environmentHandler.installTestDatabaseAccessScopeStorage(this._testDatabaseAccessScopeStorage);
-        const leftPadding = " ".repeat(indentLevel * 2);
-        const scopeOwnerFilePath = tests.ownerFilePath ?? tests.filePath;
-        const profileScopeId = this._profiler?.scopeId(tests, {
-            descriptions,
-            filePath: scopeOwnerFilePath,
-            line: tests.line,
-            parentId: parentProfileScopeId
+        this._packageRunner = new PackageTestRunner({
+            context: this.getTestContext(),
+            includeTags: this._includeTags,
+            excludeTags: [...this.getExcludeTagSet(), ...(this.isBrowserTestMode() ? [] : ["browser-only"])],
+            examples: this.getExamplePatterns(),
+            lineFilters: this.getLineFilters(),
+            includeTagMode: "any",
+            focusedTestsBypassIncludeTags: true,
+            omitEmptySuiteNames: true,
+            attemptExecutorOwnsTimeout: true,
+            attemptExecutor: (input) => this._attemptExecutor.execute(input),
+            testArgumentResolver: (input) => this._testArguments.resolve(input),
+            suiteHookExecutor: (input) => this._suiteHookExecutor.execute(input),
+            reporter: this._runnerReporter
         });
-        const ownAfterEaches = [...this.profileHookEntries(tests.afterEaches, profileScopeId, scopeOwnerFilePath)].reverse();
-        const ownBeforeEaches = this.profileHookEntries(tests.beforeEaches, profileScopeId, scopeOwnerFilePath);
-        const newAfterEaches = [...ownAfterEaches, ...afterEaches];
-        const newBeforeEaches = [...beforeEaches, ...ownBeforeEaches];
-        const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(tests);
-        const shouldRunAnyTests = this.hasRunnableTests(tests, descriptions, scopeLineMatch);
-        if (!shouldRunAnyTests)
-            return;
-        /** @type {ActiveAfterAllScopeEntry} */
-        const scopeEntry = { tests, afterAllsRun: false, profileScopeId };
-        this._activeAfterAllScopes.push(scopeEntry);
-        /** @type {unknown[]} */
-        const scopeErrors = [];
+        const failureStart = this._suiteHookFailures.length;
+        const restoreRetryOptions = this.normalizePackageRetriesForExecution();
+        let result;
         try {
-            const beforeAlls = this.profileHookEntries(tests.beforeAlls || [], profileScopeId, scopeOwnerFilePath);
-            for (const beforeAllData of beforeAlls) {
-                await this.runProfileSpan({
-                    phase: "beforeAll",
-                    declarationIndex: beforeAllData.declarationIndex,
-                    declarationScopeId: beforeAllData.declarationScopeId,
-                    filePath: beforeAllData.ownerFilePath
-                }, async () => {
-                    await beforeAllData.callback({ configuration: this.getConfiguration() });
-                });
-            }
-            for (const testDescription in tests.tests) {
-                const testData = tests.tests[testDescription];
-                const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.args));
-                const includeByLine = scopeLineMatch || this.matchesLineFilter(testData);
-                if (this._onlyFocussed && !testArgs.focus)
-                    continue;
-                if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine))
-                    continue;
-                if (testArgs.type == "model" || testArgs.type == "request") {
-                    testArgs.application = await this.application();
-                }
-                if (testArgs.type == "request") {
-                    testArgs.client = await this.requestClient();
-                }
-                const retryCount = typeof testArgs.retry === "number" && Number.isFinite(testArgs.retry)
-                    ? Math.max(0, Math.floor(testArgs.retry))
-                    : 0;
-                const configTimeoutSeconds = typeof testConfig.defaultTimeoutSeconds === "number" ? testConfig.defaultTimeoutSeconds : undefined;
-                const timeoutSeconds = typeof testArgs.timeoutSeconds === "number" ? testArgs.timeoutSeconds : configTimeoutSeconds;
-                const useTimeout = typeof timeoutSeconds === "number" && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0;
-                const timeoutMs = useTimeout ? timeoutSeconds * 1000 : undefined;
-                let retriesUsed = 0;
-                let attemptNumber = 1;
-                /**
-                 * Attempt console outputs.
-                 * @type {AttemptConsoleOutput[]} */
-                const attemptConsoleOutputs = [];
-                console.log(`${leftPadding}it ${testDescription}`);
-                const testStartMs = Date.now();
-                while (true) {
-                    let shouldRetry = false;
-                    /**
-                     * Defines caughtError.
-                     * @type {ReturnType<typeof JSON.parse>} */
-                    let caughtError;
-                    /**
-                     * Defines failedError.
-                     * @type {ReturnType<typeof JSON.parse>} */
-                    let failedError;
-                    /**
-                     * Defines lastError.
-                     * @type {ReturnType<typeof JSON.parse>} */
-                    let lastError;
-                    let willRetry = false;
-                    /**
-                     * The per-test lifecycle promise, hoisted so the timeout branch can
-                     * still wait for it to settle after runWithTimeout has abandoned it.
-                     * @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 {SharedTransactionBrokerRegistration | undefined} */
-                    let sharedTransactionBrokerRegistration;
-                    /** @type {SharedTransactionBrokerRegistration | undefined} */
-                    let sharedTransactionBrokerPreparation;
-                    /** @type {TransactionalTenantRegistration[]} */
-                    const transactionalTenantRegistrations = [];
-                    /** @type {BrowserDummyConnectionRegistration[]} */
-                    const browserDummyConnectionRegistrations = [];
-                    const testDatabaseAccessScope = { revoked: false };
-                    /** @type {Set<Error>} */
-                    const recordedTimeoutCleanupErrors = new Set();
-                    testArgs.registerTransactionalTenant = async (args) => {
-                        await this.registerTransactionalTenant(args, transactionalTenantRegistrations);
-                    };
-                    const stopConsoleCapture = this.startConsoleCapture({
-                        passthrough: testConfig.consoleOutput === "live"
-                    });
-                    const profiler = this._profiler;
-                    const profileAttempt = profiler?.startAttempt({
-                        descriptions,
-                        attemptNumber,
-                        testData,
-                        testDescription
-                    });
-                    let attemptTimedOut = false;
-                    try {
-                        // Run the whole per-test lifecycle (dummy/server startup, connection
-                        // acquisition, beforeEach hooks, the test body and afterEach hooks) as
-                        // one promise so the timeout below can cover all of it.
-                        const runLifecycleCallback = async () => await this.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 () => {
-                                // Register dynamic candidates before hooks so transaction state changes
-                                // made during a hook are immediately visible to any in-process work.
-                                // Prepare transaction sharing before hooks so long-lived services cannot
-                                // use the shared connection while its coordinator is still missing.
-                                if (useSharedTestConnections) {
-                                    testSharedConnectionRegistrations = this.activateTestSharedConnections();
-                                    testSharedConnectionsActive = true;
-                                }
-                                /** @type {unknown[]} */
-                                const lifecycleErrors = [];
-                                let runCleanupHooks = false;
-                                try {
-                                    if (useSharedTestConnections) {
-                                        sharedTransactionBrokerPreparation = await this.prepareSharedTransactionBroker();
-                                    }
-                                    runCleanupHooks = true;
-                                    clearDeliveries();
-                                    for (const beforeEachData of newBeforeEaches) {
-                                        await this.runProfileSpan({
-                                            phase: "beforeEach",
-                                            declarationIndex: beforeEachData.declarationIndex,
-                                            declarationScopeId: beforeEachData.declarationScopeId,
-                                            filePath: beforeEachData.ownerFilePath
-                                        }, async () => {
-                                            await beforeEachData.callback({ configuration: this.getConfiguration(), testArgs, testData });
-                                        });
-                                    }
-                                    if (useSharedTestConnections) {
-                                        const activeSharedTransactionConnections = this.sharedTransactionConnections({ transactionsOnly: true });
-                                        if (sharedTransactionBrokerPreparation && !this.sharedTransactionBrokerMatchesConnections(sharedTransactionBrokerPreparation, activeSharedTransactionConnections)) {
-                                            this.clearTestSharedConnections(testSharedConnectionRegistrations);
-                                            testSharedConnectionRegistrations = [];
-                                            testSharedConnectionsActive = false;
-                                        }
-                                        sharedTransactionBrokerRegistration = await this.startSharedTransactionBroker(sharedTransactionBrokerPreparation, activeSharedTransactionConnections);
-                                        sharedTransactionBrokerPreparation = undefined;
-                                        if (sharedTransactionBrokerRegistration && !testSharedConnectionsActive) {
-                                            testSharedConnectionRegistrations = this.activateTestSharedConnections();
-                                            testSharedConnectionsActive = true;
-                                        }
-                                    }
-                                    // Record which test is running so an async crash (an unhandled
-                                    // rejection detached from any await) that fires during or shortly
-                                    // after this test can be attributed to it in run()'s handler.
-                                    this._lastTestContext = {
-                                        fullDescription: this.buildFullDescription(descriptions, testDescription),
-                                        filePath: testData.filePath ?? "<unknown>",
-                                        line: testData.line ?? 0
-                                    };
-                                    await this.runProfileSpan({ phase: "test body", filePath: testData.ownerFilePath ?? testData.filePath }, async () => {
-                                        await testData.function(testArgs);
-                                    });
-                                }
-                                catch (error) {
-                                    lifecycleErrors.push(error);
-                                }
-                                if (runCleanupHooks) {
-                                    try {
-                                        // Framework-owned post-commit broadcasts are intentionally
-                                        // detached; drain them before test cleanup so their DB
-                                        // checkouts cannot leak into the next test's lifecycle.
-                                        await this.getConfiguration().awaitPendingBroadcasts();
-                                    }
-                                    catch (error) {
-                                        lifecycleErrors.push(error);
-                                    }
-                                    try {
-                                        if (testSharedConnectionsActive) {
-                                            this.clearTestSharedConnections(testSharedConnectionRegistrations);
-                                            testSharedConnectionRegistrations = [];
-                                            testSharedConnectionsActive = false;
-                                        }
-                                    }
-                                    catch (error) {
-                                        lifecycleErrors.push(error);
-                                    }
-                                    try {
-                                        await this.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation);
-                                        sharedTransactionBrokerRegistration = undefined;
-                                        sharedTransactionBrokerPreparation = undefined;
-                                    }
-                                    catch (error) {
-                                        lifecycleErrors.push(error);
-                                    }
-                                    try {
-                                        await this.runAfterEaches({ afterEaches: newAfterEaches, testArgs, testData });
-                                    }
-                                    catch (error) {
-                                        lifecycleErrors.push(error);
-                                    }
-                                    try {
-                                        await this.cleanupTransactionalTenants(transactionalTenantRegistrations);
-                                    }
-                                    catch (error) {
-                                        lifecycleErrors.push(error);
-                                    }
-                                }
-                                if (testSharedConnectionsActive) {
-                                    try {
-                                        this.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) {
-                                // Database cleaning requires one connection for beforeEach, the test
-                                // body and afterEach; only transactions and requests share it dynamically.
-                                await this.getConfiguration().ensureConnections({ name: `Test: ${testDescription}` }, runTestAttempt);
-                            }
-                            else {
-                                await runTestAttempt();
-                            }
-                        }, browserDummyConnectionRegistrations);
-                        const lifecycleCallback = async () => await this.getConfiguration().runWithTestDatabaseAccessScope(testDatabaseAccessScope, runLifecycleCallback);
-                        testLifecycle = profileAttempt && profiler
-                            ? profiler.runAttempt(profileAttempt, lifecycleCallback)
-                            : lifecycleCallback();
-                        // Time out the ENTIRE lifecycle, not just the test body. A hang in any
-                        // phase — a connection checkout that never resolves, a beforeEach/afterEach
-                        // waiting on a lock, or dummy server startup — would otherwise stall the
-                        // whole run indefinitely (until CI kills the build) instead of failing the
-                        // single offending test.
-                        if (useTimeout && timeoutMs !== undefined) {
-                            await runWithTimeout(testLifecycle, timeoutMs, testDescription);
-                        }
-                        else {
-                            await testLifecycle;
-                        }
-                        // A test is successful only after its complete lifecycle settles.
-                        // Cleanup failures and timed-out detached work must not overlap the
-                        // final successful and failed counters used for executed-test totals.
-                        this._successfulTests++;
-                    }
-                    catch (error) {
-                        caughtError = error;
-                        lastError = error;
-                        // A timeout REJECTS while the lifecycle keeps running detached on the
-                        // shared per-suite connection — including its afterEach database
-                        // cleanup (e.g. transaction rollback). If the next test starts before
-                        // that rollback runs, its own startTransaction() implicitly COMMITS
-                        // the timed-out test's rows on the shared connection, poisoning every
-                        // later test in the shard (duplicate-key / foreign-key cascades from
-                        // leaked fixtures). Wait — bounded — for the abandoned lifecycle to
-                        // settle so its cleanup lands first. If it remains active after the
-                        // bounded grace, quarantine its browser connections and stop running
-                        // tests rather than sharing unsafe state.
-                        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 the abandoned lifecycle never settled within the grace, its
-                            // cleanup has not completed. Quarantine browser-owned connections
-                            // before any scope cleanup can race the abandoned callback.
-                            if (!lifecycleOutcome.settled) {
-                                testDatabaseAccessScope.revoked = true;
-                                void testLifecycle.catch((cleanupError) => {
-                                    if (isTestDatabaseAccessRevocation(cleanupError))
-                                        return;
-                                    this.recordTimeoutCleanupFailure(cleanupError, "test lifecycle", recordedTimeoutCleanupErrors);
-                                });
-                                const quarantine = this.quarantineBrowserDummyConnections(browserDummyConnectionRegistrations);
-                                const quarantineOutcome = await awaitSettledOrGrace(quarantine, timeoutMs ?? 60000);
-                                const usesBrowserTransactions = testArgs.databaseCleaning?.transaction === true;
-                                const usesBrowserTruncation = testArgs.databaseCleaning?.truncate ?? !usesBrowserTransactions;
-                                this._abortRemainingTests = this.isBrowserTestMode()
-                                    && this.hasTag(testArgs, "dummy")
-                                    && (usesBrowserTransactions || usesBrowserTruncation);
-                                if (quarantineOutcome.settled && quarantineOutcome.status === "rejected") {
-                                    emergencyCleanupErrors.push(quarantineOutcome.reason);
-                                }
-                                else if (!quarantineOutcome.settled) {
-                                    void quarantine.catch((cleanupError) => {
-                                        this.recordTimeoutCleanupFailure(cleanupError, "browser dummy connection quarantine", recordedTimeoutCleanupErrors);
-                                    });
-                                }
-                            }
-                            try {
-                                if (testSharedConnectionsActive) {
-                                    this.clearTestSharedConnections(testSharedConnectionRegistrations);
-                                    testSharedConnectionRegistrations = [];
-                                    testSharedConnectionsActive = false;
-                                }
-                            }
-                            catch (cleanupError) {
-                                emergencyCleanupErrors.push(cleanupError);
-                            }
-                            const brokerCleanup = this.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) => {
-                                    this.recordTimeoutCleanupFailure(cleanupError, "shared transaction broker", recordedTimeoutCleanupErrors);
-                                });
-                            }
-                            sharedTransactionBrokerRegistration = undefined;
-                            sharedTransactionBrokerPreparation = undefined;
-                            const emergencyCleanup = this.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) {
-                                // The timed-out attempt must not block the runner indefinitely, but a
-                                // later rollback/discard failure still becomes a visible test failure.
-                                void emergencyCleanup.catch((cleanupError) => {
-                                    this.recordTimeoutCleanupFailure(cleanupError, "transactional tenant", recordedTimeoutCleanupErrors);
-                                });
-                            }
-                            if (emergencyCleanupErrors.length > 0) {
-                                caughtError = new AggregateError([caughtError, ...emergencyCleanupErrors], "Test timeout and emergency cleanup failed", { cause: caughtError });
-                                lastError = caughtError;
-                            }
-                        }
-                        if (browserDummyConnectionRegistrations.some((registration) => registration.quarantined)) {
-                            testDatabaseAccessScope.revoked = true;
-                            this._abortRemainingTests = true;
-                        }
-                        willRetry = !this._abortRemainingTests && retriesUsed < retryCount;
-                        if (willRetry) {
-                            retriesUsed++;
-                        }
-                        if (willRetry) {
-                            shouldRetry = true;
-                        }
-                        else {
-                            failedError = caughtError;
-                        }
-                    }
-                    finally {
-                        testDatabaseAccessScope.revoked = true;
-                        const consoleOutput = stopConsoleCapture();
-                        if (profileAttempt && profiler) {
-                            profiler.finishAttempt(profileAttempt, caughtError === undefined
-                                ? "passed"
-                                : (attemptTimedOut ? "timed-out" : "failed"));
-                        }
-                        if (consoleOutput) {
-                            attemptConsoleOutputs.push({ attemptNumber, output: consoleOutput });
-                        }
-                    }
-                    if (caughtError !== undefined) {
-                        await this.emitEvent("testAttemptFailed", {
-                            configuration: this.getConfiguration(),
-                            descriptions,
-                            error: caughtError,
-                            attemptNumber,
-                            nextAttempt: willRetry ? attemptNumber + 1 : undefined,
-                            retriesUsed,
-                            retryCount,
-                            testArgs,
-                            testData,
-                            testDescription,
-                            testRunner: this,
-                            willRetry
-                        });
-                    }
-                    if (shouldRetry) {
-                        console.warn(picocolors.red(`${leftPadding}  Retrying (${retriesUsed}/${retryCount}) after error: ${lastError instanceof Error ? lastError.message : String(lastError)}`));
-                        await this.emitEvent("testRetrying", {
-                            configuration: this.getConfiguration(),
-                            descriptions,
-                            error: lastError,
-                            nextAttempt: attemptNumber + 1,
-                            retriesUsed,
-                            retryCount,
-                            testArgs,
-                            testData,
-                            testDescription,
-                            testRunner: this
-                        });
-                    }
-                    if (attemptNumber > 1) {
-                        await this.emitEvent("testRetried", {
-                            configuration: this.getConfiguration(),
-                            descriptions,
-                            error: lastError,
-                            attemptNumber,
-                            retriesUsed,
-                            retryCount,
-                            testArgs,
-                            testData,
-                            testDescription,
-                            testRunner: this
-                        });
-                    }
-                    attemptNumber++;
-                    if (shouldRetry)
-                        continue;
-                    if (failedError) {
-                        const consoleOutput = this.buildConsoleOutput(attemptConsoleOutputs);
-                        if (failedError instanceof Error) {
-                            console.error(picocolors.red(`${leftPadding}  Test failed: ${failedError.message}`));
-                            addTrackedStackToError(failedError);
-                            const backtraceCleaner = new BacktraceCleaner(failedError);
-                            const cleanedStack = backtraceCleaner.getCleanedStack();
-                            const stackLines = cleanedStack?.split("\n");
-                            if (stackLines) {
-                                for (const stackLine of stackLines) {
-                                    console.error(picocolors.red(`${leftPadding}  ${stackLine}`));
-                                }
-                            }
-                        }
-                        else {
-                            console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof failedError}: ${String(failedError)}`));
-                        }
-                        this.printFailedConsoleOutput({ consoleOutput, leftPadding });
-                        this._failedTests++;
-                        this._failedTestDetails.push({
-                            fullDescription: this.buildFullDescription(descriptions, testDescription),
-                            filePath: testData.filePath,
-                            line: testData.line,
-                            error: failedError,
-                            consoleOutput: consoleOutput || undefined
-                        });
-                        await this.emitEvent("testFailed", {
-                            configuration: this.getConfiguration(),
-                            descriptions,
-                            error: failedError,
-                            testArgs,
-                            testData,
-                            testDescription,
-                            testRunner: this
-                        });
-                        this.printRerunCommand({ descriptions, testDescription, testData, leftPadding });
-                    }
-                    break;
-                }
-                this._testDurations.push({
-                    fullDescription: this.buildFullDescription(descriptions, testDescription),
-                    filePath: testData.filePath ?? "<unknown>",
-                    line: testData.line ?? 0,
-                    durationMs: Date.now() - testStartMs
-                });
-                if (this._abortRemainingTests)
-                    break;
+            try {
+                result = await this._packageRunner.run();
             }
-            for (const subDescription in tests.subs) {
-                if (this._abortRemainingTests)
-                    break;
-                const subTest = tests.subs[subDescription];
-                const newDecriptions = descriptions.concat([subDescription]);
-                const childScopeLineMatch = scopeLineMatch || this.matchesLineFilter(subTest);
-                if (!this._onlyFocussed || subTest.anyTestsFocussed) {
-                    console.log(`${leftPadding}${subDescription}`);
-                    await this.runTests({
-                        afterEaches: newAfterEaches,
-                        beforeEaches: newBeforeEaches,
-                        tests: subTest,
-                        descriptions: newDecriptions,
-                        indentLevel: indentLevel + 1,
-                        lineMatchedInScope: childScopeLineMatch,
-                        parentProfileScopeId: profileScopeId
-                    });
-                }
+            catch (error) {
+                if (!(error instanceof AbortRemainingTestsError))
+                    throw error;
+                const afterAll = this.afterAllOutcome(this._suiteHookFailures.slice(failureStart));
+                if (afterAll.failed)
+                    this.recordTimeoutCleanupFailure(afterAll.error, "afterAll");
+                return;
             }
+            this.recordPackageResult(result);
+            this.throwAfterAllFailures(this._suiteHookFailures.slice(failureStart));
         }
-        catch (error) {
-            scopeErrors.push(error);
+        finally {
+            restoreRetryOptions();
         }
+    }
+    /**
+     * Aggregates raw after-all failures without using error truthiness.
+     * @param {Array<{phase: "beforeAll" | "afterAll", error: ReturnType<typeof JSON.parse>}>} failures - Hook failures.
+     * @returns {{failed: false} | {failed: true, error: ReturnType<typeof JSON.parse>}} - Explicit afterAll outcome.
+     */
+    afterAllOutcome(failures) {
+        const afterAllErrors = failures.filter((failure) => failure.phase === "afterAll").map((failure) => failure.error);
+        if (afterAllErrors.length === 0)
+            return { failed: false };
+        if (afterAllErrors.length === 1)
+            return { failed: true, error: afterAllErrors[0] };
+        return {
+            failed: true,
+            error: new AggregateError(afterAllErrors, "Multiple active afterAll scopes failed", { cause: afterAllErrors[0] })
+        };
+    }
+    /**
+     * Throws one raw or aggregated after-all failure.
+     * @param {Array<{phase: "beforeAll" | "afterAll", error: ReturnType<typeof JSON.parse>}>} failures - Hook failures.
+     * @returns {void}
+     */
+    throwAfterAllFailures(failures) {
+        const afterAll = this.afterAllOutcome(failures);
+        if (afterAll.failed)
+            throw afterAll.error;
+    }
+    /**
+     * Compatibility helper for focused framework lifecycle specs. It converts an
+     * explicit legacy fixture into isolated package declarations; the package
+     * runner remains the sole execution engine.
+     * @param {object} args - Legacy fixture arguments.
+     * @param {TestsArgument} args.tests - Fixture tree.
+     * @returns {Promise<void>} - Resolves after package execution.
+     */
+    async runTests({ tests }) {
+        const context = createTestContext();
+        const originalContext = this._context;
+        context.configureTests({
+            consoleOutput: originalContext.config.consoleOutput,
+            defaultTimeoutMs: originalContext.config.defaultTimeoutMs,
+            excludeTags: originalContext.config.excludeTags,
+            failedConsoleOutputMaxLines: originalContext.config.failedConsoleOutputMaxLines,
+            retries: originalContext.config.retries
+        });
+        this._context = context;
+        this._testsCount = 0;
+        this._testCompatibility = new WeakMap();
+        this._injectedTests = new WeakSet();
+        this._completedTests = new WeakSet();
+        this._testMetadata = new WeakMap();
+        this._hookMetadata = new WeakMap();
+        this._attemptOutcomes = new WeakMap();
+        this._suiteHookFailures = [];
+        this._testsByFullName = new Map();
+        this._legacyFixtureDataByFullName = new Map();
+        context.setDeclarationLocator(() => this._legacyFixtureLocation);
+        this.declareLegacyFixture(context, "", tests, []);
+        this.analyzeDeclarations();
         try {
-            await this.runAfterAllsForScope(scopeEntry);
-        }
-        catch (error) {
-            scopeErrors.push(error);
-        }
-        const scopeIndex = this._activeAfterAllScopes.indexOf(scopeEntry);
-        if (scopeIndex >= 0) {
-            this._activeAfterAllScopes.splice(scopeIndex, 1);
+            await this.runPackageTests();
         }
-        if (scopeErrors.length > 0 && this._abortRemainingTests) {
-            const error = scopeErrors.length == 1
-                ? scopeErrors[0]
-                : new AggregateError(scopeErrors, "Test scope and afterAll cleanup failed", { cause: scopeErrors[0] });
-            this.recordTimeoutCleanupFailure(error, "afterAll");
-            return;
+        finally {
+            this._context = originalContext;
         }
-        if (scopeErrors.length == 1)
-            throw scopeErrors[0];
-        if (scopeErrors.length > 1)
-            throw new AggregateError(scopeErrors, "Test scope and afterAll cleanup failed", { cause: scopeErrors[0] });
     }
     /**
-     * Runs run after alls for scope.
-     * @param {ActiveAfterAllScopeEntry} scopeEntry - Scope entry.
-     * @returns {Promise<void>} - Resolves when scope cleanup finishes.
+     * Declares an isolated legacy-shaped test fixture into a package context.
+     * @param {PackageTestContext} context - Isolated package context.
+     * @param {string} name - Suite name.
+     * @param {TestsArgument} scope - Legacy fixture scope.
+     * @param {string[]} descriptions - Ancestor descriptions.
+     * @returns {void}
      */
-    async runAfterAllsForScope(scopeEntry) {
-        if (scopeEntry.afterAllsRun)
-            return;
-        scopeEntry.afterAllsRun = true;
-        const scopeOwnerFilePath = scopeEntry.tests.ownerFilePath ?? scopeEntry.tests.filePath;
-        const afterAlls = [...this.profileHookEntries(scopeEntry.tests.afterAlls || [], scopeEntry.profileScopeId, scopeOwnerFilePath)].reverse();
-        /** @type {unknown[]} */
-        const afterAllErrors = [];
-        for (const afterAllData of afterAlls) {
-            try {
-                await this.runProfileSpan({
-                    phase: "afterAll",
-                    declarationIndex: afterAllData.declarationIndex,
-                    declarationScopeId: afterAllData.declarationScopeId,
-                    filePath: afterAllData.ownerFilePath
-                }, async () => {
-                    await afterAllData.callback({ configuration: this.getConfiguration() });
-                });
+    declareLegacyFixture(context, name, scope, descriptions) {
+        this._legacyFixtureLocation = { filePath: scope.filePath, line: scope.line };
+        context.describe(name, scope.args || {}, () => {
+            for (const hook of scope.beforeAlls || [])
+                context.beforeAll(hook.callback);
+            for (const hook of scope.beforeEaches || [])
+                context.beforeEach(hook.callback);
+            for (const hook of scope.afterEaches || [])
+                context.afterEach(hook.callback);
+            for (const hook of scope.afterAlls || [])
+                context.afterAll(hook.callback);
+            const nextDescriptions = name === "" ? descriptions : [...descriptions, name];
+            for (const [testName, testData] of Object.entries(scope.tests || {})) {
+                this._legacyFixtureLocation = { filePath: testData.filePath, line: testData.line };
+                this._legacyFixtureDataByFullName?.set(this.buildFullDescription(nextDescriptions, testName), testData);
+                context.it(testName, testData.args, testData.function);
             }
-            catch (error) {
-                afterAllErrors.push(error);
+            for (const [suiteName, childScope] of Object.entries(scope.subs || {})) {
+                this.declareLegacyFixture(context, suiteName, childScope, nextDescriptions);
             }
-        }
-        if (afterAllErrors.length == 1)
-            throw afterAllErrors[0];
-        if (afterAllErrors.length > 1) {
-            throw new AggregateError(afterAllErrors, "Multiple afterAll hooks failed", { cause: afterAllErrors[0] });
-        }
+        });
     }
     /**
      * Runs emit event.
@@ -1996,10 +1616,7 @@ export default class TestRunner {
      * @returns {Promise<void>} - Resolves when all listeners complete.
      */
     async emitEvent(eventName, payload) {
-        const listeners = testEvents.listeners(eventName);
-        for (const listener of listeners) {
-            await listener(payload);
-        }
+        await this._runnerReporter.emitEvent(eventName, payload);
     }
     /**
      * Runs print rerun command.
@@ -2101,52 +1718,5 @@ export default class TestRunner {
             console.error(picocolors.red(`${leftPadding}    ${line}`));
         }
     }
-    /**
-     * Runs start console capture.
-     * @param {object} [args] - Options object.
-     * @param {boolean} [args.passthrough] - Whether to pass through to the original console.
-     * @returns {() => string} - Stops the capture and returns captured text.
-     */
-    startConsoleCapture({ passthrough = false } = {}) {
-        /**
-         * Lines.
-         * @type {string[]} */
-        const lines = [];
-        /**
-         * Console object.
-         * @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */
-        const consoleObject = /** @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */ (console);
-        /**
-         * Original console methods captured as direct references so stopping restores
-         * the exact method that was installed at capture start.
-         * @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */
-        const originalConsoleMethods = {
-            debug: consoleObject.debug,
-            error: consoleObject.error,
-            info: consoleObject.info,
-            log: consoleObject.log,
-            warn: consoleObject.warn
-        };
-        let stopped = false;
-        let outputText = "";
-        for (const methodName of CAPTURED_CONSOLE_METHODS) {
-            consoleObject[methodName] = (...args) => {
-                lines.push(`[${new Date().toISOString()}] [${methodName}] ${format(...args)}`);
-                if (passthrough) {
-                    originalConsoleMethods[methodName].apply(consoleObject, args);
-                }
-            };
-        }
-        return () => {
-            if (!stopped) {
-                stopped = true;
-                for (const methodName of CAPTURED_CONSOLE_METHODS) {
-                    consoleObject[methodName] = originalConsoleMethods[methodName];
-                }
-                outputText = lines.join("\n");
-            }
-            return outputText;
-        };
-    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-runner.js","sourceRoot":"","sources":["../../../src/testing/test-runner.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {addTrackedStackToError} from \"../utils/with-tracked-stack.js\"\nimport fs from \"node:fs/promises\"\nimport path from \"path\"\nimport {format} from \"node:util\"\nimport {AsyncLocalStorage} from \"node:async_hooks\"\nimport Application from \"../../src/application.js\"\nimport BacktraceCleaner from \"../utils/backtrace-cleaner-node.js\"\nimport {TestDatabaseAccessRevokedError} from \"../environment-handlers/base.js\"\nimport RequestClient from \"./request-client.js\"\nimport picocolors from \"picocolors\"\nimport restArgsError from \"../utils/rest-args-error.js\"\nimport {testConfig, testEvents, tests} from \"./test.js\"\nimport {pathToFileURL} from \"url\"\nimport {clearDeliveries} from \"../mailer.js\"\nimport SharedTransactionBroker from \"./shared-transaction-broker.js\"\nimport { SHARED_TRANSACTION_BROKER_ENV } from \"./shared-transaction-proxy-driver.js\"\nimport {synchronizeTestingPackageTests} from \"./testing-package-adapter.js\"\n\n/**\n * ConsoleMethodName type.\n * @typedef {\"log\" | \"info\" | \"warn\" | \"error\" | \"debug\"} ConsoleMethodName */\n/**\n * AttemptConsoleOutput type.\n * @typedef {object} AttemptConsoleOutput\n * @property {number} attemptNumber - Attempt number.\n * @property {string} output - Captured console output.\n */\n/**\n * TestArgs type.\n * @typedef {object} TestArgs\n * @property {Application} [application] - Application instance for integration tests.\n * @property {RequestClient} [client] - HTTP client for request tests.\n * @property {object} [databaseCleaning] - Database cleanup options for tests.\n * @property {boolean} [databaseCleaning.transaction] - Use transactions to rollback between tests.\n * @property {boolean} [databaseCleaning.truncate] - Truncate tables between tests.\n * @property {boolean} [databaseCleaning.truncateBefore] - Truncate tables before each test, in addition to the default cleanup.\n * @property {boolean} [focus] - Whether this test is focused.\n * @property {() => (void|Promise<void>)} [function] - Test callback function.\n * @property {number} [retry] - Number of retries when a test fails.\n * @property {string[] | string} [tags] - Tags for filtering.\n * @property {number} [timeoutSeconds] - Timeout in seconds for the test.\n * @property {string} [type] - Test type identifier.\n * @property {(args: {databaseIdentifier: string, tenant: object}) => Promise<void>} [registerTransactionalTenant] - Registers one resolved tenant database transaction for this attempt.\n */\n/**\n * BrowserDummyConnectionRegistration type.\n * @typedef {object} BrowserDummyConnectionRegistration\n * @property {import(\"../database/drivers/base.js\").default} db - Attempt-owned connection.\n * @property {string} databaseIdentifier - Configured database identifier.\n * @property {Promise<void>} [quarantinePromise] - Shared connection-discard promise.\n * @property {boolean} quarantined - Whether the connection is unsafe to reuse.\n * @property {Promise<void>} [rollbackPromise] - Shared rollback promise.\n * @property {Promise<void>} [startPromise] - Transaction startup promise when transaction cleaning is enabled.\n */\n/**\n * TestData type.\n * @typedef {object} TestData\n * @property {TestArgs} args - Arguments passed to the test.\n * @property {string} [filePath] - Source file path.\n * @property {number} [line] - Source line number.\n * @property {string} [ownerFilePath] - Deterministic importing test file.\n * @property {(arg: TestArgs) => (void|Promise<void>)} function - Test callback to execute.\n */\n/**\n * FailedTestDetail type.\n * @typedef {object} FailedTestDetail\n * @property {string} fullDescription - Full test description.\n * @property {string} [filePath] - Source file path.\n * @property {number} [line] - Source line number.\n * @property {ReturnType<typeof JSON.parse>} error - Failure error.\n * @property {string} [consoleOutput] - Captured console output while test ran.\n * @property {string} [consoleLogPath] - Saved console log path.\n */\n/**\n * ActiveAfterAllScopeEntry type.\n * @typedef {object} ActiveAfterAllScopeEntry\n * @property {TestsArgument} tests - Scope test tree.\n * @property {boolean} afterAllsRun - Whether cleanup hooks have run.\n * @property {string} [profileScopeId] - Opaque profile scope identifier.\n */\n/**\n * Defines this typedef.\n * @typedef {(args: {configuration: import(\"../configuration.js\").default, testArgs: TestArgs, testData: TestData}) => (void|Promise<void>)} AfterBeforeEachCallbackType\n */\n/**\n * AfterBeforeEachCallbackObjectType type.\n * @typedef {object} AfterBeforeEachCallbackObjectType\n * @property {AfterBeforeEachCallbackType} callback - Hook callback to execute.\n * @property {number} [declarationIndex] - Hook index within its declaration scope.\n * @property {string} [declarationScopeId] - Opaque profile scope identifier.\n * @property {string} [ownerFilePath] - Deterministic importing test file.\n */\n/**\n * Defines this typedef.\n * @typedef {(args: {configuration: import(\"../configuration.js\").default}) => (void|Promise<void>)} BeforeAfterAllCallbackType\n */\n/**\n * BeforeAfterAllCallbackObjectType type.\n * @typedef {object} BeforeAfterAllCallbackObjectType\n * @property {BeforeAfterAllCallbackType} callback - Hook callback to execute.\n * @property {number} [declarationIndex] - Hook index within its declaration scope.\n * @property {string} [declarationScopeId] - Opaque profile scope identifier.\n * @property {string} [ownerFilePath] - Deterministic importing test file.\n */\n/**\n * TestsArgument type.\n * @typedef {object} TestsArgument\n * @property {TestArgs} args - Arguments inherited by tests in this scope.\n * @property {boolean} [anyTestsFocussed] - Whether any tests in the tree are focused.\n * @property {AfterBeforeEachCallbackObjectType[]} afterEaches - After-each hooks for this scope.\n * @property {BeforeAfterAllCallbackObjectType[]} afterAlls - After-all hooks for this scope.\n * @property {BeforeAfterAllCallbackObjectType[]} beforeAlls - Before-all hooks for this scope.\n * @property {AfterBeforeEachCallbackObjectType[]} beforeEaches - Before-each hooks for this scope.\n * @property {string} [filePath] - Source file path.\n * @property {number} [line] - Source line number.\n * @property {string} [ownerFilePath] - Deterministic importing test file.\n * @property {Record<string, TestData>} tests - A unique identifier for the node.\n * @property {Record<string, TestsArgument>} subs - Optional child nodes. Each item is another `Node`, allowing recursion.\n */\n/**\n * Marks the error thrown by {@link runWithTimeout} so the caller can tell a\n * lifecycle timeout (the promise is still running detached) apart from an\n * ordinary test failure (the promise already settled).\n * @typedef {Error & {velociousTestTimeout?: true}} TestTimeoutError\n */\n/**\n * SharedTransactionBrokerRegistration type.\n * @typedef {object} SharedTransactionBrokerRegistration\n * @property {SharedTransactionBroker} broker - Attempt broker and connection coordinator.\n * @property {boolean} environmentPublished - Whether child-process coordinates were published.\n * @property {string | undefined} previousEnvironment - Environment value to restore after publication.\n */\n/**\n * TransactionalTenantRegistration type.\n * @typedef {object} TransactionalTenantRegistration\n * @property {Promise<{connection: import(\"../database/drivers/base.js\").default | undefined, error: Error | undefined}> | undefined} [checkoutPromise] - Attempt-owned physical checkout outcome.\n * @property {import(\"../database/drivers/base.js\").default | undefined} connection - Attempt-owned physical connection once checkout resolves.\n * @property {Promise<void> | undefined} [cleanupPromise] - Single cleanup operation shared by emergency and eventual lifecycle cleanup.\n * @property {boolean | undefined} [discardOnCleanup] - Whether timeout emergency cleanup must quarantine this connection.\n * @property {import(\"../database/pool/base.js\").default} pool - Owning logical pool.\n * @property {boolean} revoked - Whether this attempt may still publish the physical registration.\n * @property {string} reuseKey - Resolved physical configuration identity.\n * @property {import(\"../database/pool/base.js\").TestSharedConnectionRegistration | undefined} sharedRegistration - Physical-key shared registration once published.\n */\n\n/**\n * Runs run with timeout.\n *\n * On timeout the wrapped `promise` is NOT cancelled — it keeps running detached.\n * The rejected error is tagged with `velociousTestTimeout` so the runner knows\n * the lifecycle (and its afterEach database cleanup) is still in flight and can\n * wait for it to settle before the next test reuses the shared connection.\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>>} - Resolves or rejects based on timeout or promise 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 an abandoned (timed-out) test lifecycle to settle, bounded by a\n * grace period, so its afterEach database cleanup runs on the shared connection\n * before the next test reuses it. Returns the fulfillment/rejection outcome if\n * the lifecycle settles, or a pending outcome once the grace elapses.\n *\n * The grace timer is kept ref'd so it cannot let Node exit with an unsettled\n * top-level await when the timed-out lifecycle has no ref'd handles of its own\n * (for example a stalled mocked async API). Once the caller continues past this\n * await, the timer has already resolved and no longer anchors the event loop.\n * @param {Promise<ReturnType<typeof JSON.parse>>} lifecycle - The abandoned per-test lifecycle promise.\n * @param {number} graceMs - Maximum time to wait for the lifecycle to settle.\n * @returns {Promise<{settled: false} | {settled: true, status: \"fulfilled\"} | {settled: true, status: \"rejected\", reason: unknown}>} - 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 test access was revoked.\n * @param {unknown} 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\n/**\n * Captured console methods.\n * @type {ConsoleMethodName[]} */\nconst CAPTURED_CONSOLE_METHODS = [\"log\", \"info\", \"warn\", \"error\", \"debug\"]\n\n/**\n * Runs to file slug.\n * @param {string} value - Value to sanitize.\n * @returns {string} - Slug-safe value.\n */\nfunction toFileSlug(value) {\n  return value\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-+|-+$/g, \"\")\n    .slice(0, 80) || \"failed-test\"\n}\n\nexport default class TestRunner {\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {ActiveAfterAllScopeEntry[]} */\n  _activeAfterAllScopes\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {FailedTestDetail[]} */\n  _failedTestDetails\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n   * @param {string[] | string} [args.includeTags] - Tags to include.\n   * @param {Array<string>} args.testFiles - Test files.\n   * @param {Record<string, number[]>} [args.lineFilters] - Line filters by file.\n   * @param {RegExp[]} [args.examplePatterns] - Example patterns.\n   * @param {import(\"./test-profiler.js\").default} [args.profiler] - Opt-in profiler.\n   */\n  constructor({configuration, excludeTags, includeTags, testFiles, lineFilters, examplePatterns, profiler, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!configuration) throw new Error(\"configuration is required\")\n\n    this._configuration = configuration\n    this._sharedTransactionCoordinatorOwnerStorage = new AsyncLocalStorage()\n    this._testDatabaseAccessScopeStorage = new AsyncLocalStorage()\n    this._excludeTags = this.normalizeTags(excludeTags)\n    this._excludeTagSet = new Set(this._excludeTags)\n    this._includeTags = this.normalizeTags(includeTags)\n    this._includeTagSet = new Set(this._includeTags)\n    this._testFiles = testFiles\n    this._lineFilters = lineFilters || {}\n    this._examplePatterns = examplePatterns || []\n    this._profiler = profiler\n    this._abortRemainingTests = false\n\n    this._failedTests = 0\n    this._successfulTests = 0\n    this._testsCount = 0\n    this._activeAfterAllScopes = []\n    this._failedTestDetails = []\n    /** @type {{fullDescription: string, filePath: string, line: number} | null} */\n    this._lastTestContext = null\n    /** @type {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} */\n    this._testDurations = []\n  }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"../configuration.js\").default} - The configuration.\n   */\n  getConfiguration() { return this._configuration }\n\n  /**\n   * Runs get test files.\n   * @returns {string[]} - The test files.\n   */\n  getTestFiles() { return this._testFiles }\n\n  /**\n   * Runs get line filters.\n   * @returns {Record<string, number[]>} - Line filters.\n   */\n  getLineFilters() { return this._lineFilters }\n\n  /**\n   * Runs get example patterns.\n   * @returns {RegExp[]} - Example patterns.\n   */\n  getExamplePatterns() { return this._examplePatterns }\n\n  /**\n   * Runs a profiler span only when profiling was explicitly enabled.\n   * @template T\n   * @param {object} metadata - Span metadata.\n   * @param {string} metadata.phase - Phase name.\n   * @param {number} [metadata.declarationIndex] - Hook declaration index.\n   * @param {string} [metadata.declarationScopeId] - Hook declaration scope.\n   * @param {string} [metadata.filePath] - Source ownership.\n   * @param {() => (T | Promise<T>)} callback - Timed callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async runProfileSpan(metadata, callback) {\n    if (!this._profiler) return await callback()\n\n    return await this._profiler.runSpan(metadata, callback)\n  }\n\n  /**\n   * Adds declaration metadata to hooks only for an active profile.\n   * @template {AfterBeforeEachCallbackObjectType | BeforeAfterAllCallbackObjectType} T\n   * @param {T[]} hooks - Hooks declared in one scope.\n   * @param {string | undefined} declarationScopeId - Profile scope identifier.\n   * @param {string | undefined} ownerFilePath - Scope owner file.\n   * @returns {T[]} - Profile-aware hook entries.\n   */\n  profileHookEntries(hooks, declarationScopeId, ownerFilePath) {\n    if (!this._profiler) return hooks\n\n    return hooks.map((hook, declarationIndex) => Object.assign({}, hook, {\n      declarationIndex: hook.declarationIndex ?? declarationIndex,\n      declarationScopeId: hook.declarationScopeId ?? declarationScopeId,\n      ownerFilePath: hook.ownerFilePath ?? ownerFilePath\n    }))\n  }\n\n  /**\n   * Runs normalize tags.\n   * @param {string[] | string | undefined} tags - Tags.\n   * @returns {string[]} - Normalized tags.\n   */\n  normalizeTags(tags) {\n    if (!tags) return []\n\n    const values = []\n    const rawTags = Array.isArray(tags) ? tags : [tags]\n\n    for (const rawTag of rawTags) {\n      if (rawTag === undefined || rawTag === null) continue\n\n      const parts = String(rawTag).split(\",\")\n\n      for (const part of parts) {\n        const trimmed = part.trim()\n\n        if (trimmed) values.push(trimmed)\n      }\n    }\n\n    return Array.from(new Set(values))\n  }\n\n  /**\n   * Runs has tag.\n   * @param {TestArgs} testArgs - Test args.\n   * @param {string} tag - Tag to check for.\n   * @returns {boolean} - Whether tag is present.\n   */\n  hasTag(testArgs, tag) {\n    return this.normalizeTags(testArgs?.tags).includes(tag)\n  }\n\n  /**\n   * Runs is browser test mode.\n   * @returns {boolean} - Whether running browser tests.\n   */\n  isBrowserTestMode() {\n    return process.env.VELOCIOUS_BROWSER_TESTS === \"true\"\n  }\n\n  /**\n   * Runs run with dummy if needed.\n   * @param {TestArgs} testArgs - Test args.\n   * @param {() => Promise<void>} callback - Callback to run.\n   * @param {BrowserDummyConnectionRegistration[]} [browserDummyConnectionRegistrations] - Attempt-owned browser connections.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runWithDummyIfNeeded(testArgs, callback, browserDummyConnectionRegistrations = []) {\n    if (!this.hasTag(testArgs, \"dummy\")) {\n      await callback()\n      return\n    }\n\n    if (this.isBrowserTestMode()) {\n      await this.runBrowserDummy(testArgs, callback, browserDummyConnectionRegistrations)\n      return\n    }\n\n    await this.runNodeDummy(callback)\n  }\n\n  /**\n   * Runs run node dummy.\n   * @param {() => Promise<void>} callback - Callback to run.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runNodeDummy(callback) {\n    const dummyPath = process.env.VELOCIOUS_DUMMY_PATH || this.defaultDummyPath()\n    const dummyImport = await import(pathToFileURL(dummyPath).href)\n    const Dummy = dummyImport.default\n\n    if (!Dummy?.run) {\n      throw new Error(`Dummy helper not found at ${dummyPath}`)\n    }\n\n    // Persistent server resources must not inherit an attempt scope that will be revoked.\n    await this.getConfiguration().getEnvironmentHandler().runWithCapturedTestDatabaseAccessScope(undefined, async () => {\n      await Dummy.run(async () => {})\n    })\n    this.getConfiguration().assertDatabaseAccessAllowed()\n    await callback()\n  }\n\n  /**\n   * Runs default dummy path.\n   * @returns {string} - Default dummy helper path.\n   */\n  defaultDummyPath() {\n    const cwd = path.resolve(process.cwd())\n    const normalized = cwd.split(path.sep).join(\"/\")\n\n    if (normalized.endsWith(\"/spec/dummy\")) {\n      return path.join(cwd, \"index.js\")\n    }\n\n    return path.join(cwd, \"spec/dummy/index.js\")\n  }\n\n  /**\n   * Runs run browser dummy.\n   * @param {TestArgs} testArgs - Test args.\n   * @param {() => Promise<void>} callback - Callback to run.\n   * @param {BrowserDummyConnectionRegistration[]} connectionRegistrations - Attempt-owned browser connections.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runBrowserDummy(testArgs, callback, connectionRegistrations) {\n    const useTransaction = testArgs.databaseCleaning?.transaction === true\n    const truncate = testArgs.databaseCleaning?.truncate\n    const shouldTruncate = truncate === undefined ? !useTransaction : truncate\n\n    if (!useTransaction && !shouldTruncate) {\n      await callback()\n      return\n    }\n\n    await this.getConfiguration().ensureConnections({name: \"Test runner browser dummy\"}, async (dbs) => {\n      const newRegistrations = Object.entries(dbs).map(([databaseIdentifier, db]) => {\n        /** @type {BrowserDummyConnectionRegistration} */\n        const registration = {\n          databaseIdentifier,\n          db,\n          quarantined: false\n        }\n\n        connectionRegistrations.push(registration)\n\n        return registration\n      })\n\n      if (shouldTruncate) {\n        this.getConfiguration().assertDatabaseAccessAllowed()\n        await this.truncateDatabases(dbs)\n      }\n      /** @type {unknown[]} */\n      const lifecycleErrors = []\n\n      try {\n        if (useTransaction) {\n          const startPromises = newRegistrations.map((registration) => {\n            const startPromise = registration.db.startTransaction()\n\n            registration.startPromise = startPromise\n            return startPromise\n          })\n          const startResults = await Promise.allSettled(startPromises)\n          const startErrors = startResults\n            .filter((result) => result.status === \"rejected\")\n            .map((result) => result.reason)\n\n          if (startErrors.length == 1) throw startErrors[0]\n          if (startErrors.length > 1) {\n            throw new AggregateError(startErrors, \"Browser dummy transaction startup failed\", {cause: startErrors[0]})\n          }\n        }\n\n        this.getConfiguration().assertDatabaseAccessAllowed()\n        await callback()\n      } catch (error) {\n        lifecycleErrors.push(error)\n      }\n\n      try {\n        await this.rollbackBrowserDummyTransactions(connectionRegistrations)\n      } catch (error) {\n        if (error instanceof AggregateError) {\n          lifecycleErrors.push(...error.errors)\n        } else {\n          lifecycleErrors.push(error)\n        }\n      }\n\n      try {\n        if (shouldTruncate) {\n          this.getConfiguration().assertDatabaseAccessAllowed()\n          await this.truncateDatabases(dbs)\n        }\n      } catch (error) {\n        lifecycleErrors.push(error)\n      }\n\n      if (lifecycleErrors.length == 1) throw lifecycleErrors[0]\n      if (lifecycleErrors.length > 1) {\n        throw new AggregateError(lifecycleErrors, \"Browser dummy lifecycle and cleanup failed\", {cause: lifecycleErrors[0]})\n      }\n    })\n  }\n\n  /**\n   * Rolls back every attempt-owned browser transaction exactly once.\n   * @param {BrowserDummyConnectionRegistration[]} registrations - Browser connections.\n   * @returns {Promise<void>} - Resolves after all rollbacks settle.\n   */\n  async rollbackBrowserDummyTransactions(registrations) {\n    const rollbackResults = await Promise.allSettled([...registrations].reverse().map((registration) => {\n      const startPromise = registration.startPromise\n\n      if (!startPromise) return\n\n      registration.rollbackPromise ??= (async () => {\n        if (registration.quarantined) return\n\n        try {\n          await startPromise\n        } catch {\n          try {\n            await this.quarantineBrowserDummyConnection(registration)\n          } catch (quarantineError) {\n            throw new Error(`Failed to quarantine browser dummy database after transaction startup failed: ${registration.databaseIdentifier}`, {cause: quarantineError})\n          }\n          return\n        }\n        if (registration.quarantined) return\n\n        try {\n          await registration.db.rollbackTransaction()\n        } catch (rollbackError) {\n          try {\n            await this.quarantineBrowserDummyConnection(registration)\n          } catch (quarantineError) {\n            throw new AggregateError(\n              [rollbackError, quarantineError],\n              `Failed to roll back and quarantine browser dummy database: ${registration.databaseIdentifier}`,\n              {cause: quarantineError}\n            )\n          }\n          throw rollbackError\n        }\n      })()\n\n      return registration.rollbackPromise\n    }))\n    const errors = rollbackResults\n      .filter((result) => result.status === \"rejected\")\n      .map((result) => result.reason)\n\n    if (errors.length == 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Browser dummy transaction cleanup failed\", {cause: errors[0]})\n  }\n\n  /**\n   * Permanently removes one browser connection that cannot be shared safely.\n   * @param {BrowserDummyConnectionRegistration} registration - Browser connection registration.\n   * @returns {Promise<void>} - Resolves after the connection is discarded.\n   */\n  async quarantineBrowserDummyConnection(registration) {\n    registration.quarantined = true\n    registration.quarantinePromise ??= this.discardBrowserDummyConnection(registration.databaseIdentifier, registration.db)\n    await registration.quarantinePromise\n  }\n\n  /**\n   * Discards one browser dummy connection through its owning pool.\n   * @param {string} databaseIdentifier - Configured database identifier.\n   * @param {import(\"../database/drivers/base.js\").default} db - Unsafe connection.\n   * @returns {Promise<void>} - Resolves after discard.\n   */\n  async discardBrowserDummyConnection(databaseIdentifier, db) {\n    await this.getConfiguration().getDatabasePool(databaseIdentifier).discard(db)\n  }\n\n  /**\n   * Quarantines all browser connections concurrently.\n   * @param {BrowserDummyConnectionRegistration[]} registrations - Browser connection registrations.\n   * @returns {Promise<void>} - Resolves after every connection is discarded.\n   */\n  async quarantineBrowserDummyConnections(registrations) {\n    const quarantineResults = await Promise.allSettled(registrations.map(async (registration) => {\n      await this.quarantineBrowserDummyConnection(registration)\n    }))\n    const errors = quarantineResults\n      .filter((result) => result.status === \"rejected\")\n      .map((result) => result.reason)\n\n    if (errors.length == 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Browser dummy connection quarantine failed\", {cause: errors[0]})\n  }\n\n  /**\n   * Runs truncate databases.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} dbs - Database connections.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async truncateDatabases(dbs) {\n    for (const identifier of Object.keys(dbs)) {\n      await dbs[identifier].truncateAllTables()\n    }\n  }\n\n  /**\n   * Runs get exclude tag set.\n   * @returns {Set<string>} - Exclude tag set.\n   */\n  getExcludeTagSet() {\n    /**\n     * Config tags.\n     * @type {string[]} */\n    const configTags = Array.isArray(testConfig.excludeTags) ? testConfig.excludeTags : []\n\n    return new Set([...this._excludeTags, ...configTags])\n  }\n\n  /**\n   * Runs has matching tag.\n   * @param {string[] | string | undefined} testTags - Test tags.\n   * @param {Set<string>} tagSet - Tag set.\n   * @returns {boolean} - Whether any tags match.\n   */\n  hasMatchingTag(testTags, tagSet) {\n    if (!tagSet.size) return false\n\n    const normalized = this.normalizeTags(testTags)\n\n    for (const tag of normalized) {\n      if (tagSet.has(tag)) return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs has runnable tests.\n   * @param {TestsArgument} tests - Tests.\n   * @param {string[]} [descriptions] - Description stack.\n   * @param {boolean} [lineMatchedInScope] - Whether line matched in scope.\n   * @returns {boolean} - Whether any tests in this scope will run.\n   */\n  hasRunnableTests(tests, descriptions = [], lineMatchedInScope = false) {\n    for (const testDescription in tests.tests) {\n      const testData = tests.tests[testDescription]\n      const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.args))\n      const includeByLine = lineMatchedInScope || this.matchesLineFilter(testData)\n\n      if (this._onlyFocussed && !testArgs.focus) continue\n      if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine)) continue\n\n      return true\n    }\n\n    for (const subDescription in tests.subs) {\n      const subTest = tests.subs[subDescription]\n      const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(subTest)\n      const nextDescriptions = descriptions.concat([subDescription])\n\n      if (this._onlyFocussed && !subTest.anyTestsFocussed) continue\n      if (this.hasRunnableTests(subTest, nextDescriptions, scopeLineMatch)) return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs should skip test.\n   * @param {TestArgs} testArgs - Test args.\n   * @param {TestData} testData - Test data.\n   * @param {string} testDescription - Test description.\n   * @param {string[]} descriptions - Description stack.\n   * @param {boolean} lineMatchedInScope - Whether line matched in scope.\n   * @returns {boolean} - Whether the test should be skipped.\n   */\n  shouldSkipTest(testArgs, testData, testDescription, descriptions, lineMatchedInScope) {\n    if (this.hasTag(testArgs, \"browser-only\") && !this.isBrowserTestMode()) return true\n    if (this.hasMatchingTag(testArgs.tags, this.getExcludeTagSet())) return true\n\n    if (this._includeTagSet.size > 0 && !testArgs.focus) {\n      if (!this.hasMatchingTag(testArgs.tags, this._includeTagSet)) return true\n    }\n\n    if (this.getExamplePatterns().length > 0) {\n      const fullDescription = this.buildFullDescription(descriptions, testDescription)\n      const matches = this.getExamplePatterns().some((pattern) => {\n        pattern.lastIndex = 0\n        return pattern.test(fullDescription)\n      })\n\n      if (!matches) return true\n    }\n\n    const lineFilters = this.getLineFilters()\n\n    if (Object.keys(lineFilters).length > 0) {\n      if (!lineMatchedInScope && !this.matchesLineFilter(testData)) return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs matches line filter.\n   * @param {TestData | TestsArgument} entry - Test entry.\n   * @returns {boolean} - Whether line filter matches entry.\n   */\n  matchesLineFilter(entry) {\n    if (!entry || !entry.filePath || !entry.line) return false\n\n    const filePath = path.resolve(entry.filePath)\n    const lines = this.getLineFilters()[filePath]\n\n    if (!lines || lines.length === 0) return false\n\n    return lines.includes(entry.line)\n  }\n\n  /**\n   * Runs build full description.\n   * @param {string[]} descriptions - Description stack.\n   * @param {string} testDescription - Test description.\n   * @returns {string} - Full description.\n   */\n  buildFullDescription(descriptions, testDescription) {\n    const parts = descriptions.concat([testDescription])\n\n    return parts.join(\" \").trim()\n  }\n\n  /**\n   * Runs application.\n   * @returns {Promise<Application>} - Resolves with the application.\n   */\n  async application() {\n    if (!this._application) {\n      this._application = new Application({\n        configuration: this.getConfiguration(),\n        // Run request handlers in the main thread (not worker threads) so they\n        // resolve DB work to the per-test shared connection set by\n        // {@link activateTestSharedConnections}. This lets request-type specs use\n        // transaction-based cleaning (their writes land inside the test's\n        // transaction and roll back) instead of truncating every table.\n        httpServer: {inProcess: true, port: 31006},\n        type: \"test-runner\"\n      })\n\n      await this._application.initialize()\n      await this._application.startHttpServer()\n    }\n\n    return this._application\n  }\n\n  /**\n   * Registers each non-tenant per-test connection as a dynamic candidate for in-process\n   * request sharing. The pool evaluates transaction state when each request is dispatched,\n   * so a transaction started or ended during a hook callback takes effect immediately.\n   * Inactive and tenant-only connections remain independently pooled. Pair with\n   * {@link clearTestSharedConnections} in a finally.\n   * @returns {{pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}[]} - Lifecycle-owned registrations.\n   */\n  activateTestSharedConnections() {\n    const configuration = this.getConfiguration()\n    const currentConnections = configuration.getCurrentConnections()\n    /** @type {{pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}[]} */\n    const registrations = []\n\n    for (const identifier of Object.keys(currentConnections)) {\n      const pool = configuration.getDatabasePool(identifier)\n\n      // Tenant-scoped pools resolve a different connection per request tenant\n      // (via runWithTenant), so forcing a single shared connection would break\n      // per-request tenant resolution. Only share non-tenant pools; the tenant\n      // pool keeps resolving its own connection per request.\n      if (pool.getConfiguration().tenantOnly) {\n        continue\n      }\n\n      const connection = currentConnections[identifier]\n\n      const registration = pool.setTestSharedConnectionProvider(() => {\n        return connection.insideTransaction() ? connection : undefined\n      })\n\n      if (registration) registrations.push({pool, registration})\n    }\n\n    return registrations\n  }\n\n  /**\n   * Clears the in-process test shared connection on every configured pool. Idempotent and\n   * safe to call when none was set.\n   * @param {{pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}[]} [registrations] - Lifecycle-owned registrations to clear conditionally.\n   * @returns {void}\n   */\n  clearTestSharedConnections(registrations) {\n    if (registrations) {\n      for (const {pool, registration} of registrations) {\n        pool.clearTestSharedConnection(registration)\n      }\n      return\n    }\n\n    const configuration = this.getConfiguration()\n\n    for (const identifier of configuration.getDatabaseIdentifiers()) {\n      configuration.getDatabasePool(identifier).clearTestSharedConnection()\n    }\n  }\n\n  /**\n   * Checks out and registers one physical tenant transaction for the current attempt.\n   * @param {{databaseIdentifier: string, tenant: object}} args - Logical identifier and tenant descriptor.\n   * @param {TransactionalTenantRegistration[]} registrations - Current attempt registrations.\n   * @returns {Promise<void>}\n   */\n  async registerTransactionalTenant({databaseIdentifier, tenant, ...restArgs}, registrations) {\n    restArgsError(restArgs)\n    if (!databaseIdentifier) throw new Error(\"registerTransactionalTenant requires a databaseIdentifier\")\n    if (!tenant) throw new Error(\"registerTransactionalTenant requires a tenant\")\n\n    const configuration = this.getConfiguration()\n    const pool = configuration.getDatabasePool(databaseIdentifier)\n    const databaseConfiguration = configuration.resolveDatabaseConfiguration(databaseIdentifier, tenant)\n    if (!databaseConfiguration.tenantOnly) {\n      throw new Error(`registerTransactionalTenant requires a tenantOnly database: ${databaseIdentifier}`)\n    }\n    const reuseKey = pool.getConfigurationReuseKey(databaseConfiguration)\n    if (registrations.some((registration) => registration.pool === pool && registration.reuseKey === reuseKey)) return\n\n    /** @type {TransactionalTenantRegistration} */\n    const registration = {\n      connection: undefined,\n      pool,\n      reuseKey,\n      revoked: false,\n      sharedRegistration: undefined\n    }\n\n    registrations.push(registration)\n    registration.checkoutPromise = pool\n      .checkoutForConfiguration(databaseConfiguration, {name: \"Transactional tenant test registration\"})\n      .then(\n        (connection) => ({connection, error: undefined}),\n        (error) => ({\n          connection: undefined,\n          error: error instanceof Error ? error : new Error(\"Transactional tenant connection checkout failed\", {cause: error})\n        })\n      )\n\n    try {\n      const checkoutOutcome = await registration.checkoutPromise\n\n      if (checkoutOutcome.error) throw checkoutOutcome.error\n      if (!checkoutOutcome.connection) throw new Error(\"Transactional tenant connection checkout returned no connection\")\n      registration.connection = checkoutOutcome.connection\n      if (registration.revoked) throw new Error(\"Transactional tenant test registration attempt is no longer active\")\n\n      await registration.connection.startTransaction()\n      if (registration.revoked) throw new Error(\"Transactional tenant test registration attempt is no longer active\")\n\n      const sharedRegistration = pool.setTestSharedConnectionForConfiguration(registration.connection, reuseKey)\n      if (!sharedRegistration) throw new Error(`Database pool does not support transactional tenant test connections: ${databaseIdentifier}`)\n      registration.sharedRegistration = sharedRegistration\n      if (registration.revoked) {\n        pool.clearTestSharedConnection(sharedRegistration)\n        throw new Error(\"Transactional tenant test registration attempt is no longer active\")\n      }\n    } catch (error) {\n      registration.revoked = true\n      try {\n        await this.cleanupTransactionalTenants([registration], {discard: registration.discardOnCleanup === true})\n      } catch (cleanupError) {\n        throw new AggregateError([error, cleanupError], \"Failed to register and clean up a transactional tenant test connection\", {cause: cleanupError})\n      }\n      throw error\n    }\n  }\n\n  /**\n   * Revokes attempt registrations before rolling back and releasing their connections.\n   * @param {TransactionalTenantRegistration[]} registrations - Attempt registrations.\n   * @param {{discard?: boolean}} [options] - Whether connections must be discarded instead of returned to the pool.\n   * @returns {Promise<void>}\n   */\n  async cleanupTransactionalTenants(registrations, {discard = false} = {}) {\n    for (const registration of registrations) {\n      registration.revoked = true\n      if (discard) registration.discardOnCleanup = true\n      if (registration.sharedRegistration) registration.pool.clearTestSharedConnection(registration.sharedRegistration)\n    }\n    const cleanupResults = await Promise.allSettled([...registrations].reverse().map((registration) => {\n      registration.cleanupPromise ??= this.cleanupTransactionalTenantRegistration(registration)\n\n      return registration.cleanupPromise\n    }))\n    const errors = cleanupResults\n      .filter((result) => result.status === \"rejected\")\n      .map((result) => result.reason)\n\n    if (errors.length === 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Failed to clean up transactional tenant test connections\")\n  }\n\n  /**\n   * Cleans one attempt registration exactly once, including a checkout that was still pending at revocation.\n   * @param {TransactionalTenantRegistration} registration - Attempt-owned registration.\n   * @returns {Promise<void>} - Resolves after rollback and release or quarantine.\n   */\n  async cleanupTransactionalTenantRegistration(registration) {\n    let connection = registration.connection\n\n    if (!connection && registration.checkoutPromise) {\n      const checkoutOutcome = await registration.checkoutPromise\n\n      if (checkoutOutcome.error) return\n      connection = checkoutOutcome.connection\n      registration.connection = connection\n    }\n    if (!connection) return\n\n    const errors = []\n\n    try {\n      if (connection.insideTransaction()) await connection.rollbackTransaction()\n    } catch (error) {\n      errors.push(error)\n    } finally {\n      try {\n        if (registration.discardOnCleanup) {\n          await registration.pool.discard(connection)\n        } else {\n          await registration.pool.checkin(connection)\n        }\n      } catch (error) {\n        errors.push(error)\n      }\n    }\n    if (errors.length === 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Failed to clean up a transactional tenant test connection\")\n  }\n\n  /**\n   * Selects the current non-tenant connections eligible for shared transaction work.\n   * @param {{transactionsOnly: boolean}} args - Selection options.\n   * @returns {Record<string, import(\"../database/drivers/base.js\").default>} - Eligible connections by identifier.\n   */\n  sharedTransactionConnections({transactionsOnly}) {\n    const configuration = this.getConfiguration()\n    const currentConnections = configuration.getCurrentConnections()\n    /** @type {Record<string, import(\"../database/drivers/base.js\").default>} */\n    const connections = {}\n\n    for (const [identifier, connection] of Object.entries(currentConnections)) {\n      const pool = configuration.getDatabasePool(identifier)\n\n      if (pool.getConfiguration().tenantOnly) continue\n      if (transactionsOnly && !connection.insideTransaction()) continue\n      connections[identifier] = connection\n    }\n\n    return connections\n  }\n\n  /**\n   * Installs physical-connection coordination before a transaction-opening hook\n   * can expose the shared connection to a long-lived in-process service.\n   * Child-process coordinates remain unpublished until the transaction exists.\n   * @returns {Promise<SharedTransactionBrokerRegistration | undefined>} - Prepared coordinator.\n   */\n  async prepareSharedTransactionBroker() {\n    const connections = this.sharedTransactionConnections({transactionsOnly: false})\n\n    if (Object.keys(connections).length === 0) return undefined\n\n    return {\n      broker: await SharedTransactionBroker.start({connections}),\n      environmentPublished: false,\n      previousEnvironment: undefined\n    }\n  }\n\n  /**\n   * Checks whether a prepared broker coordinates exactly the selected physical connections.\n   * @param {SharedTransactionBrokerRegistration | undefined} registration - Prepared coordinator.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} connections - Selected connections.\n   * @returns {boolean} - Whether the identifier set and physical connections match exactly.\n   */\n  sharedTransactionBrokerMatchesConnections(registration, connections) {\n    const identifiers = Object.keys(connections)\n\n    if (!registration || identifiers.length === 0) return false\n    if (Object.keys(registration.broker.connections).length !== identifiers.length) return false\n\n    for (const [identifier, connection] of Object.entries(connections)) {\n      if (registration.broker.connections[identifier] !== connection) return false\n    }\n\n    return true\n  }\n\n  /**\n   * Starts a capability-scoped broker for the active non-tenant physical\n   * transaction connections. No broker/env is installed for truncation-only or\n   * other transaction-disabled attempts.\n   * @param {SharedTransactionBrokerRegistration} [preparedRegistration] - Coordinator prepared before hooks.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} [selectedConnections] - Post-hook active connections.\n   * @returns {Promise<SharedTransactionBrokerRegistration | undefined>} - Attempt registration.\n   */\n  async startSharedTransactionBroker(preparedRegistration, selectedConnections) {\n    const connections = selectedConnections || this.sharedTransactionConnections({transactionsOnly: true})\n\n    const databaseIdentifiers = Object.keys(connections)\n    if (databaseIdentifiers.length === 0) {\n      await this.stopSharedTransactionBroker(preparedRegistration)\n      return undefined\n    }\n\n    let broker\n\n    if (preparedRegistration && this.sharedTransactionBrokerMatchesConnections(preparedRegistration, connections)) {\n      broker = preparedRegistration.broker\n    } else {\n      await this.stopSharedTransactionBroker(preparedRegistration)\n      broker = await SharedTransactionBroker.start({connections})\n    }\n\n    const previousEnvironment = process.env[SHARED_TRANSACTION_BROKER_ENV]\n    process.env[SHARED_TRANSACTION_BROKER_ENV] = Buffer.from(JSON.stringify({\n      address: broker.address(),\n      capability: broker.capability(),\n      databaseIdentifiers,\n      expected: true\n    })).toString(\"base64url\")\n\n    return {broker, environmentPublished: true, previousEnvironment}\n  }\n\n  /**\n   * Revokes an attempt broker before database rollback hooks run and restores\n   * the caller's environment so later pooled/spawned children cannot inherit it.\n   * @param {SharedTransactionBrokerRegistration | undefined} registration - Attempt registration.\n   */\n  async stopSharedTransactionBroker(registration) {\n    if (!registration) return\n\n    if (registration.environmentPublished) {\n      if (registration.previousEnvironment === undefined) {\n        delete process.env[SHARED_TRANSACTION_BROKER_ENV]\n      } else {\n        process.env[SHARED_TRANSACTION_BROKER_ENV] = registration.previousEnvironment\n      }\n    }\n    await registration.broker.close()\n  }\n\n  /**\n   * Runs request client.\n   * @returns {Promise<RequestClient>} - Resolves with the request client.\n   */\n  async requestClient() {\n    if (!this._requestClient) {\n      this._requestClient = new RequestClient()\n    }\n\n    return this._requestClient\n  }\n\n  /**\n   * Runs import test files.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async importTestFiles() {\n    const environmentHandler = this.getConfiguration().getEnvironmentHandler()\n\n    if (!this._profiler) {\n      await environmentHandler.importTestFiles(this.getTestFiles())\n      synchronizeTestingPackageTests(tests)\n      return\n    }\n\n    for (const testFile of this.getTestFiles()) {\n      const existingRegistrations = this.testRegistrationObjects(tests)\n\n      await this._profiler.measurePhase(\"imports\", async () => {\n        await environmentHandler.importTestFiles([testFile])\n      }, {filePath: testFile})\n      synchronizeTestingPackageTests(tests)\n      this.assignTestRegistrationOwnership(tests, existingRegistrations, testFile)\n    }\n  }\n\n  /**\n   * Collects registered scope, hook, and test objects by identity.\n   * @param {TestsArgument} scope - Test scope.\n   * @param {Set<object>} [registrations] - Accumulated identities.\n   * @returns {Set<object>} - Registration identities.\n   */\n  testRegistrationObjects(scope, registrations = new Set()) {\n    registrations.add(scope)\n\n    for (const hook of [...scope.beforeAlls, ...scope.beforeEaches, ...scope.afterEaches, ...scope.afterAlls]) {\n      registrations.add(hook)\n    }\n\n    for (const testData of Object.values(scope.tests)) registrations.add(testData)\n    for (const childScope of Object.values(scope.subs)) this.testRegistrationObjects(childScope, registrations)\n\n    return registrations\n  }\n\n  /**\n   * Assigns deterministic ownership to registrations added by one entry file,\n   * including declarations originating in a helper imported by that entry file.\n   * @param {TestsArgument} scope - Test scope.\n   * @param {Set<object>} previousRegistrations - Identities present before import.\n   * @param {string} ownerFilePath - Importing entry file.\n   * @returns {void}\n   */\n  assignTestRegistrationOwnership(scope, previousRegistrations, ownerFilePath) {\n    if (!previousRegistrations.has(scope)) scope.ownerFilePath ??= ownerFilePath\n\n    for (const hook of [...scope.beforeAlls, ...scope.beforeEaches, ...scope.afterEaches, ...scope.afterAlls]) {\n      if (!previousRegistrations.has(hook)) hook.ownerFilePath ??= ownerFilePath\n    }\n\n    for (const testData of Object.values(scope.tests)) {\n      if (!previousRegistrations.has(testData)) testData.ownerFilePath ??= ownerFilePath\n    }\n\n    for (const childScope of Object.values(scope.subs)) {\n      this.assignTestRegistrationOwnership(childScope, previousRegistrations, ownerFilePath)\n    }\n  }\n\n  /**\n   * Runs is failed.\n   * @returns {boolean} - Whether failed.\n   */\n  isFailed() { return this._failedTests !== undefined && this._failedTests > 0 }\n\n  /**\n   * Runs get failed tests.\n   * @returns {number} - The failed tests.\n   */\n  getFailedTests() {\n    if (this._failedTests === undefined) throw new Error(\"Tests hasn't been run yet\")\n\n    return this._failedTests\n  }\n\n  /**\n   * Runs get failed test details.\n   * @returns {FailedTestDetail[]} - Failed test details.\n   */\n  getFailedTestDetails() {\n    return this._failedTestDetails\n  }\n\n  /**\n   * Runs persist failed test console outputs to assets.\n   * @param {object} [args] - Options object.\n   * @param {string} [args.assetsPath] - Assets directory path.\n   * @returns {Promise<string[]>} - Written log file paths.\n   */\n  async persistFailedTestConsoleOutputsToAssets({assetsPath = path.join(process.cwd(), \"tmp/screenshots\")} = {}) {\n    const failedTestDetails = this.getFailedTestDetails()\n    const writtenLogPaths = []\n    let createdDirectory = false\n\n    for (let index = 0; index < failedTestDetails.length; index++) {\n      const failedTestDetail = failedTestDetails[index]\n      const consoleOutput = failedTestDetail.consoleOutput\n\n      if (!consoleOutput) continue\n\n      if (!createdDirectory) {\n        await fs.mkdir(assetsPath, {recursive: true})\n        createdDirectory = true\n      }\n\n      const now = new Date()\n      const timestamp = [\n        String(now.getFullYear()),\n        String(now.getMonth() + 1).padStart(2, \"0\"),\n        String(now.getDate()).padStart(2, \"0\"),\n        String(now.getHours()).padStart(2, \"0\"),\n        String(now.getMinutes()).padStart(2, \"0\"),\n        String(now.getSeconds()).padStart(2, \"0\"),\n        String(now.getMilliseconds()).padStart(3, \"0\")\n      ].join(\"\")\n      const slug = toFileSlug(failedTestDetail.fullDescription)\n      const fileName = `${timestamp}-${String(index + 1).padStart(2, \"0\")}-${slug}.console.log`\n      const filePath = path.join(assetsPath, fileName)\n\n      await fs.writeFile(filePath, consoleOutput, \"utf8\")\n      failedTestDetail.consoleLogPath = filePath\n      writtenLogPaths.push(filePath)\n    }\n\n    return writtenLogPaths\n  }\n\n  /**\n   * Runs get successful tests.\n   * @returns {number} - The successful tests.\n   */\n  getSuccessfulTests() {\n    if (this._successfulTests === undefined) throw new Error(\"Tests hasn't been run yet\")\n\n    return this._successfulTests\n  }\n\n  /**\n   * Runs get tests count.\n   * @returns {number} - The tests count.\n   */\n  getTestsCount() {\n    if (this._testsCount === undefined) throw new Error(\"Tests hasn't been run yet\")\n\n    return this._testsCount\n  }\n\n  /**\n   * Runs get executed tests count.\n   * @returns {number} - The executed tests count.\n   */\n  getExecutedTestsCount() {\n    return this._testDurations.length\n  }\n\n  /**\n   * Returns the tests recorded during the run, slowest first.\n   * @param {number} [limit] - Maximum number of tests to return (0 returns all).\n   * @returns {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} - Slowest tests, slowest first.\n   */\n  getSlowestTests(limit = 10) {\n    const sorted = [...this._testDurations].sort((testA, testB) => testB.durationMs - testA.durationMs)\n\n    return limit > 0 ? sorted.slice(0, limit) : sorted\n  }\n\n  /**\n   * Runs prepare.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async prepare() {\n    this.anyTestsFocussed = false\n    this._failedTests = 0\n    this._successfulTests = 0\n    this._testsCount = 0\n    this._abortRemainingTests = false\n    this._failedTestDetails = []\n    this._testDurations = []\n    const testingConfigPath = this.getConfiguration().getTesting()\n\n    if (testingConfigPath) {\n      await this.runProfileSpan({phase: \"testing config/global setup\"}, async () => {\n        await this.getConfiguration().getEnvironmentHandler().importTestingConfigPath()\n      })\n    }\n\n    await this.importTestFiles()\n    await this.analyzeTests(tests)\n    this._onlyFocussed = this.anyTestsFocussed\n  }\n\n  /**\n   * Runs are any tests focussed.\n   * @returns {boolean} - Whether any tests focussed.\n   */\n  areAnyTestsFocussed() {\n    if (this.anyTestsFocussed === undefined) {\n      throw new Error(\"Hasn't been detected yet\")\n    }\n\n    return this.anyTestsFocussed\n  }\n\n  /**\n   * Runs run.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  /**\n   * Records an asynchronous crash (an unhandled promise rejection detached from\n   * any await, e.g. a `void connection.afterCommit(async () => broadcast(...))`\n   * frontend-model publish — or a synchronous throw inside a detached callback\n   * such as a driver socket or timer callback) as a real, visible, attributed\n   * test failure.\n   *\n   * Without this, such a rejection/exception has no handler, so on modern Node\n   * the process is TERMINATED — the run ends with no reported failures and CI\n   * just sees a crashed/retried shard with an empty result (the recurring\n   * \"silent test-runner death\": invisible and impossible to diagnose). Turning\n   * it into a failure makes the run go red with something debuggable instead of\n   * vanishing.\n   * @param {\"uncaughtException\" | \"unhandledRejection\"} kind - Async-crash kind.\n   * @param {unknown} reason - Rejection reason or thrown error.\n   * @returns {void}\n   */\n  recordAsyncCrash(kind, reason) {\n    const error = reason instanceof Error ? reason : new Error(`${kind}: ${String(reason)}`)\n    const near = this._lastTestContext\n    const attribution = near ? `, near test: ${near.fullDescription} (${near.filePath}:${near.line})` : \"\"\n\n    this._failedTests = (this._failedTests || 0) + 1\n    this._failedTestDetails.push({\n      fullDescription: `<${kind} during test run${attribution}>`,\n      filePath: near ? near.filePath : \"<test runner>\",\n      line: near ? near.line : 0,\n      error,\n      consoleOutput: undefined\n    })\n\n    console.error(picocolors.red(`\\n[test-runner] ${kind} during the test run — this would otherwise terminate the process silently and surface only as a crashed/retried shard with zero reported failures.${attribution}`))\n    console.error(error)\n  }\n\n  /**\n   * Records a cleanup failure after timeout handling has begun.\n   * @param {unknown} reason - Detached cleanup rejection.\n   * @param {string} cleanupName - Cleanup operation name.\n   * @param {Set<Error>} [recordedErrors] - Attempt-owned cleanup errors already reported.\n   * @returns {void}\n   */\n  recordTimeoutCleanupFailure(reason, cleanupName, recordedErrors) {\n    const error = reason instanceof Error ? reason : new Error(`${cleanupName} cleanup failed: ${String(reason)}`)\n\n    if (recordedErrors) {\n      // Multiple bounded observers can receive the same detached cleanup rejection.\n      if (recordedErrors.has(error)) return\n      recordedErrors.add(error)\n    }\n\n    const near = this._lastTestContext\n    const attribution = near ? `, near test: ${near.fullDescription} (${near.filePath}:${near.line})` : \"\"\n\n    this._failedTests = (this._failedTests || 0) + 1\n    this._failedTestDetails.push({\n      fullDescription: `<${cleanupName} emergency cleanup failure${attribution}>`,\n      filePath: near ? near.filePath : \"<test runner>\",\n      line: near ? near.line : 0,\n      error,\n      consoleOutput: undefined\n    })\n\n    console.error(picocolors.red(`\\n[test-runner] ${cleanupName} cleanup failed after timeout handling began.${attribution}`))\n    console.error(error)\n  }\n\n  async run() {\n    /**\n     * Handles a process-level unhandled rejection during the run.\n     * @param {unknown} reason - Rejection reason.\n     * @returns {void}\n     */\n    const onUnhandledRejection = (reason) => {\n      // If a test attached its OWN unhandledRejection listener, it is\n      // intentionally observing/triggering the rejection (e.g. beacon\n      // error-reporting-spec.js) — Node dispatches to EVERY listener, so also\n      // failing the suite here would break those tests. Defer to the test's\n      // handler; only treat a rejection as a silent-death crash when ours is the\n      // sole listener (no persistent framework listener exists to mask this).\n      if (process.listenerCount(\"unhandledRejection\") > 1) return\n\n      this.recordAsyncCrash(\"unhandledRejection\", reason)\n    }\n\n    /**\n     * Handles a process-level uncaught exception during the run — a\n     * synchronous throw inside a detached callback (driver socket, timer,\n     * event emitter) that no test await observes. Same silent-death mode as\n     * unhandled rejections: without a handler the process dies mid-run and CI\n     * sees a crashed shard with zero reported failures.\n     * @param {unknown} error - Thrown error.\n     * @returns {void}\n     */\n    const onUncaughtException = (error) => {\n      // Mirror the unhandledRejection deferral: a test observing/triggering\n      // uncaught exceptions with its own listener owns them.\n      if (process.listenerCount(\"uncaughtException\") > 1) return\n\n      this.recordAsyncCrash(\"uncaughtException\", error)\n    }\n\n    process.on(\"unhandledRejection\", onUnhandledRejection)\n    process.on(\"uncaughtException\", onUncaughtException)\n\n    try {\n      await this.runTests({\n        afterEaches: [],\n        beforeEaches: [],\n        tests,\n        descriptions: [],\n        indentLevel: 0\n      })\n\n      // A rejection scheduled by the final test (a detached rejected promise,\n      // or an afterCommit callback rejecting as the suite drains) is reported\n      // by Node on a LATER turn. Drain a few turns while the handler is still\n      // attached so those late rejections are recorded instead of escaping to\n      // the default crash path after cleanup.\n      for (let drainTurn = 0; drainTurn < 3; drainTurn++) {\n        await new Promise((resolve) => setImmediate(resolve))\n      }\n    } finally {\n      process.off(\"unhandledRejection\", onUnhandledRejection)\n      process.off(\"uncaughtException\", onUncaughtException)\n    }\n  }\n\n  /**\n   * Runs run after alls for active scopes.\n   * @returns {Promise<void>} - Resolves when cleanup hooks finish.\n   */\n  async runAfterAllsForActiveScopes() {\n    const scopes = [...this._activeAfterAllScopes].reverse()\n    /** @type {unknown[]} */\n    const afterAllErrors = []\n\n    for (const scope of scopes) {\n      try {\n        await this.runAfterAllsForScope(scope)\n      } catch (error) {\n        afterAllErrors.push(error)\n      }\n    }\n\n    this._activeAfterAllScopes = []\n\n    if (afterAllErrors.length == 1) throw afterAllErrors[0]\n    if (afterAllErrors.length > 1) {\n      throw new AggregateError(afterAllErrors, \"Multiple active afterAll scopes failed\", {cause: afterAllErrors[0]})\n    }\n  }\n\n  /**\n   * Runs analyze tests.\n   * @param {TestsArgument} tests - Tests.\n   * @returns {{anyTestsFocussed: boolean}} - Whether any tests in the tree are focused.\n   */\n  analyzeTests(tests) {\n    let anyTestsFocussedFound = false\n\n    for (const testDescription in tests.tests) {\n      const testData = tests.tests[testDescription]\n      const testArgs = Object.assign({}, testData.args)\n\n      this._testsCount++\n\n      if (testArgs.focus) {\n        anyTestsFocussedFound = true\n        this.anyTestsFocussed = true\n      }\n    }\n\n    for (const subDescription in tests.subs) {\n      const subTest = tests.subs[subDescription]\n      const {anyTestsFocussed} = this.analyzeTests(subTest)\n\n      if (anyTestsFocussed) {\n        anyTestsFocussedFound = true\n      }\n\n      subTest.anyTestsFocussed = anyTestsFocussed\n    }\n\n    return {anyTestsFocussed: anyTestsFocussedFound}\n  }\n\n  /**\n   * Runs every after-each hook while preserving the first failure.\n   * @param {object} args - Hook execution arguments.\n   * @param {AfterBeforeEachCallbackObjectType[]} args.afterEaches - Hooks to run.\n   * @param {TestArgs} args.testArgs - Current test arguments.\n   * @param {TestData} args.testData - Current test data.\n   * @returns {Promise<void>} - Resolves after every hook runs.\n   */\n  async runAfterEaches({afterEaches, testArgs, testData}) {\n    /** @type {unknown[]} */\n    const afterEachErrors = []\n\n    for (const afterEachData of afterEaches) {\n      try {\n        await this.runProfileSpan({\n          phase: \"afterEach\",\n          declarationIndex: afterEachData.declarationIndex,\n          declarationScopeId: afterEachData.declarationScopeId,\n          filePath: afterEachData.ownerFilePath\n        }, async () => {\n          await afterEachData.callback({configuration: this.getConfiguration(), testArgs, testData})\n        })\n      } catch (error) {\n        afterEachErrors.push(error)\n      }\n    }\n\n    if (afterEachErrors.length == 1) throw afterEachErrors[0]\n    if (afterEachErrors.length > 1) {\n      throw new AggregateError(afterEachErrors, \"Multiple afterEach hooks failed\", {cause: afterEachErrors[0]})\n    }\n  }\n\n  /**\n   * Runs run tests.\n   * @param {object} args - Options object.\n   * @param {Array<AfterBeforeEachCallbackObjectType>} args.afterEaches - After eaches.\n   * @param {Array<AfterBeforeEachCallbackObjectType>} args.beforeEaches - Before eaches.\n   * @param {TestsArgument} args.tests - Tests.\n   * @param {string[]} args.descriptions - Descriptions.\n   * @param {number} args.indentLevel - Indent level.\n   * @param {boolean} [args.lineMatchedInScope] - Whether line matched in scope.\n   * @param {string} [args.parentProfileScopeId] - Parent profile scope.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runTests({afterEaches, beforeEaches, tests, descriptions, indentLevel, lineMatchedInScope = false, parentProfileScopeId}) {\n    const environmentHandler = this.getConfiguration().getEnvironmentHandler()\n\n    environmentHandler.installSharedTransactionCoordinatorOwnerStorage(this._sharedTransactionCoordinatorOwnerStorage)\n    environmentHandler.installTestDatabaseAccessScopeStorage(this._testDatabaseAccessScopeStorage)\n    const leftPadding = \" \".repeat(indentLevel * 2)\n    const scopeOwnerFilePath = tests.ownerFilePath ?? tests.filePath\n    const profileScopeId = this._profiler?.scopeId(tests, {\n      descriptions,\n      filePath: scopeOwnerFilePath,\n      line: tests.line,\n      parentId: parentProfileScopeId\n    })\n    const ownAfterEaches = [...this.profileHookEntries(tests.afterEaches, profileScopeId, scopeOwnerFilePath)].reverse()\n    const ownBeforeEaches = this.profileHookEntries(tests.beforeEaches, profileScopeId, scopeOwnerFilePath)\n    const newAfterEaches = [...ownAfterEaches, ...afterEaches]\n    const newBeforeEaches = [...beforeEaches, ...ownBeforeEaches]\n    const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(tests)\n    const shouldRunAnyTests = this.hasRunnableTests(tests, descriptions, scopeLineMatch)\n\n    if (!shouldRunAnyTests) return\n\n    /** @type {ActiveAfterAllScopeEntry} */\n    const scopeEntry = {tests, afterAllsRun: false, profileScopeId}\n    this._activeAfterAllScopes.push(scopeEntry)\n    /** @type {unknown[]} */\n    const scopeErrors = []\n\n    try {\n      const beforeAlls = this.profileHookEntries(tests.beforeAlls || [], profileScopeId, scopeOwnerFilePath)\n\n      for (const beforeAllData of beforeAlls) {\n        await this.runProfileSpan({\n          phase: \"beforeAll\",\n          declarationIndex: beforeAllData.declarationIndex,\n          declarationScopeId: beforeAllData.declarationScopeId,\n          filePath: beforeAllData.ownerFilePath\n        }, async () => {\n          await beforeAllData.callback({configuration: this.getConfiguration()})\n        })\n      }\n\n      for (const testDescription in tests.tests) {\n        const testData = tests.tests[testDescription]\n        const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.args))\n        const includeByLine = scopeLineMatch || this.matchesLineFilter(testData)\n\n        if (this._onlyFocussed && !testArgs.focus) continue\n        if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine)) continue\n\n        if (testArgs.type == \"model\" || testArgs.type == \"request\") {\n          testArgs.application = await this.application()\n        }\n\n        if (testArgs.type == \"request\") {\n          testArgs.client = await this.requestClient()\n        }\n\n        const retryCount = typeof testArgs.retry === \"number\" && Number.isFinite(testArgs.retry)\n          ? Math.max(0, Math.floor(testArgs.retry))\n          : 0\n        const configTimeoutSeconds = typeof testConfig.defaultTimeoutSeconds === \"number\" ? testConfig.defaultTimeoutSeconds : undefined\n        const timeoutSeconds = typeof testArgs.timeoutSeconds === \"number\" ? testArgs.timeoutSeconds : configTimeoutSeconds\n        const useTimeout = typeof timeoutSeconds === \"number\" && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0\n        const timeoutMs = useTimeout ? timeoutSeconds * 1000 : undefined\n        let retriesUsed = 0\n        let attemptNumber = 1\n        /**\n         * Attempt console outputs.\n         * @type {AttemptConsoleOutput[]} */\n        const attemptConsoleOutputs = []\n\n        console.log(`${leftPadding}it ${testDescription}`)\n\n        const testStartMs = Date.now()\n\n        while (true) {\n          let shouldRetry = false\n          /**\n           * Defines caughtError.\n           * @type {ReturnType<typeof JSON.parse>} */\n          let caughtError\n          /**\n           * Defines failedError.\n           * @type {ReturnType<typeof JSON.parse>} */\n          let failedError\n          /**\n           * Defines lastError.\n           * @type {ReturnType<typeof JSON.parse>} */\n          let lastError\n          let willRetry = false\n          /**\n           * The per-test lifecycle promise, hoisted so the timeout branch can\n           * still wait for it to settle after runWithTimeout has abandoned it.\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 {SharedTransactionBrokerRegistration | undefined} */\n          let sharedTransactionBrokerRegistration\n          /** @type {SharedTransactionBrokerRegistration | undefined} */\n          let sharedTransactionBrokerPreparation\n          /** @type {TransactionalTenantRegistration[]} */\n          const transactionalTenantRegistrations = []\n          /** @type {BrowserDummyConnectionRegistration[]} */\n          const browserDummyConnectionRegistrations = []\n          const testDatabaseAccessScope = {revoked: false}\n          /** @type {Set<Error>} */\n          const recordedTimeoutCleanupErrors = new Set()\n          testArgs.registerTransactionalTenant = async (args) => {\n            await this.registerTransactionalTenant(args, transactionalTenantRegistrations)\n          }\n          const stopConsoleCapture = this.startConsoleCapture({\n            passthrough: testConfig.consoleOutput === \"live\"\n          })\n          const profiler = this._profiler\n          const profileAttempt = profiler?.startAttempt({\n            descriptions,\n            attemptNumber,\n            testData,\n            testDescription\n          })\n          let attemptTimedOut = false\n\n          try {\n            // Run the whole per-test lifecycle (dummy/server startup, connection\n            // acquisition, beforeEach hooks, the test body and afterEach hooks) as\n            // one promise so the timeout below can cover all of it.\n            const runLifecycleCallback = async () => await this.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                // Register dynamic candidates before hooks so transaction state changes\n                // made during a hook are immediately visible to any in-process work.\n                // Prepare transaction sharing before hooks so long-lived services cannot\n                // use the shared connection while its coordinator is still missing.\n                if (useSharedTestConnections) {\n                  testSharedConnectionRegistrations = this.activateTestSharedConnections()\n                  testSharedConnectionsActive = true\n                }\n                /** @type {unknown[]} */\n                const lifecycleErrors = []\n                let runCleanupHooks = false\n\n                try {\n                  if (useSharedTestConnections) {\n                    sharedTransactionBrokerPreparation = await this.prepareSharedTransactionBroker()\n                  }\n                  runCleanupHooks = true\n\n                  clearDeliveries()\n                  for (const beforeEachData of newBeforeEaches) {\n                    await this.runProfileSpan({\n                      phase: \"beforeEach\",\n                      declarationIndex: beforeEachData.declarationIndex,\n                      declarationScopeId: beforeEachData.declarationScopeId,\n                      filePath: beforeEachData.ownerFilePath\n                    }, async () => {\n                      await beforeEachData.callback({configuration: this.getConfiguration(), testArgs, testData})\n                    })\n                  }\n\n                  if (useSharedTestConnections) {\n                    const activeSharedTransactionConnections = this.sharedTransactionConnections({transactionsOnly: true})\n                    if (sharedTransactionBrokerPreparation && !this.sharedTransactionBrokerMatchesConnections(sharedTransactionBrokerPreparation, activeSharedTransactionConnections)) {\n                      this.clearTestSharedConnections(testSharedConnectionRegistrations)\n                      testSharedConnectionRegistrations = []\n                      testSharedConnectionsActive = false\n                    }\n\n                    sharedTransactionBrokerRegistration = await this.startSharedTransactionBroker(sharedTransactionBrokerPreparation, activeSharedTransactionConnections)\n                    sharedTransactionBrokerPreparation = undefined\n                    if (sharedTransactionBrokerRegistration && !testSharedConnectionsActive) {\n                      testSharedConnectionRegistrations = this.activateTestSharedConnections()\n                      testSharedConnectionsActive = true\n                    }\n                  }\n\n                  // Record which test is running so an async crash (an unhandled\n                  // rejection detached from any await) that fires during or shortly\n                  // after this test can be attributed to it in run()'s handler.\n                  this._lastTestContext = {\n                    fullDescription: this.buildFullDescription(descriptions, testDescription),\n                    filePath: testData.filePath ?? \"<unknown>\",\n                    line: testData.line ?? 0\n                  }\n                  await this.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                    // Framework-owned post-commit broadcasts are intentionally\n                    // detached; drain them before test cleanup so their DB\n                    // checkouts cannot leak into the next test's lifecycle.\n                    await this.getConfiguration().awaitPendingBroadcasts()\n                  } catch (error) {\n                    lifecycleErrors.push(error)\n                  }\n\n                  try {\n                    if (testSharedConnectionsActive) {\n                      this.clearTestSharedConnections(testSharedConnectionRegistrations)\n                      testSharedConnectionRegistrations = []\n                      testSharedConnectionsActive = false\n                    }\n                  } catch (error) {\n                    lifecycleErrors.push(error)\n                  }\n\n                  try {\n                    await this.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: newAfterEaches, testArgs, testData})\n                  } catch (error) {\n                    lifecycleErrors.push(error)\n                  }\n\n                  try {\n                    await this.cleanupTransactionalTenants(transactionalTenantRegistrations)\n                  } catch (error) {\n                    lifecycleErrors.push(error)\n                  }\n                }\n\n                if (testSharedConnectionsActive) {\n                  try {\n                    this.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                // Database cleaning requires one connection for beforeEach, the test\n                // body and afterEach; only transactions and requests share it dynamically.\n                await this.getConfiguration().ensureConnections({name: `Test: ${testDescription}`}, runTestAttempt)\n              } else {\n                await runTestAttempt()\n              }\n            }, browserDummyConnectionRegistrations)\n            const lifecycleCallback = async () => await this.getConfiguration().runWithTestDatabaseAccessScope(testDatabaseAccessScope, runLifecycleCallback)\n            testLifecycle = profileAttempt && profiler\n              ? profiler.runAttempt(profileAttempt, lifecycleCallback)\n              : lifecycleCallback()\n\n            // Time out the ENTIRE lifecycle, not just the test body. A hang in any\n            // phase — a connection checkout that never resolves, a beforeEach/afterEach\n            // waiting on a lock, or dummy server startup — would otherwise stall the\n            // whole run indefinitely (until CI kills the build) instead of failing the\n            // single offending test.\n            if (useTimeout && timeoutMs !== undefined) {\n              await runWithTimeout(testLifecycle, timeoutMs, testDescription)\n            } else {\n              await testLifecycle\n            }\n\n            // A test is successful only after its complete lifecycle settles.\n            // Cleanup failures and timed-out detached work must not overlap the\n            // final successful and failed counters used for executed-test totals.\n            this._successfulTests++\n          } catch (error) {\n            caughtError = error\n            lastError = error\n\n            // A timeout REJECTS while the lifecycle keeps running detached on the\n            // shared per-suite connection — including its afterEach database\n            // cleanup (e.g. transaction rollback). If the next test starts before\n            // that rollback runs, its own startTransaction() implicitly COMMITS\n            // the timed-out test's rows on the shared connection, poisoning every\n            // later test in the shard (duplicate-key / foreign-key cascades from\n            // leaked fixtures). Wait — bounded — for the abandoned lifecycle to\n            // settle so its cleanup lands first. If it remains active after the\n            // bounded grace, quarantine its browser connections and stop running\n            // tests rather than sharing unsafe state.\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 the abandoned lifecycle never settled within the grace, its\n              // cleanup has not completed. Quarantine browser-owned connections\n              // before any scope cleanup can race the abandoned callback.\n              if (!lifecycleOutcome.settled) {\n                testDatabaseAccessScope.revoked = true\n                void testLifecycle.catch((cleanupError) => {\n                  if (isTestDatabaseAccessRevocation(cleanupError)) return\n                  this.recordTimeoutCleanupFailure(cleanupError, \"test lifecycle\", recordedTimeoutCleanupErrors)\n                })\n                const quarantine = this.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                this._abortRemainingTests = this.isBrowserTestMode()\n                  && this.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                    this.recordTimeoutCleanupFailure(cleanupError, \"browser dummy connection quarantine\", recordedTimeoutCleanupErrors)\n                  })\n                }\n              }\n\n              try {\n                if (testSharedConnectionsActive) {\n                  this.clearTestSharedConnections(testSharedConnectionRegistrations)\n                  testSharedConnectionRegistrations = []\n                  testSharedConnectionsActive = false\n                }\n              } catch (cleanupError) {\n                emergencyCleanupErrors.push(cleanupError)\n              }\n\n              const brokerCleanup = this.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                  this.recordTimeoutCleanupFailure(cleanupError, \"shared transaction broker\", recordedTimeoutCleanupErrors)\n                })\n              }\n              sharedTransactionBrokerRegistration = undefined\n              sharedTransactionBrokerPreparation = undefined\n              const emergencyCleanup = this.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                // The timed-out attempt must not block the runner indefinitely, but a\n                // later rollback/discard failure still becomes a visible test failure.\n                void emergencyCleanup.catch((cleanupError) => {\n                  this.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                lastError = caughtError\n              }\n            }\n\n            if (browserDummyConnectionRegistrations.some((registration) => registration.quarantined)) {\n              testDatabaseAccessScope.revoked = true\n              this._abortRemainingTests = true\n            }\n\n            willRetry = !this._abortRemainingTests && retriesUsed < retryCount\n\n            if (willRetry) {\n              retriesUsed++\n            }\n\n            if (willRetry) {\n              shouldRetry = true\n            } else {\n              failedError = caughtError\n            }\n          } finally {\n            testDatabaseAccessScope.revoked = true\n            const consoleOutput = stopConsoleCapture()\n\n            if (profileAttempt && profiler) {\n              profiler.finishAttempt(profileAttempt, caughtError === undefined\n                ? \"passed\"\n                : (attemptTimedOut ? \"timed-out\" : \"failed\"))\n            }\n\n            if (consoleOutput) {\n              attemptConsoleOutputs.push({attemptNumber, output: consoleOutput})\n            }\n          }\n\n          if (caughtError !== undefined) {\n            await this.emitEvent(\"testAttemptFailed\", {\n              configuration: this.getConfiguration(),\n              descriptions,\n              error: caughtError,\n              attemptNumber,\n              nextAttempt: willRetry ? attemptNumber + 1 : undefined,\n              retriesUsed,\n              retryCount,\n              testArgs,\n              testData,\n              testDescription,\n              testRunner: this,\n              willRetry\n            })\n          }\n\n          if (shouldRetry) {\n            console.warn(picocolors.red(`${leftPadding}  Retrying (${retriesUsed}/${retryCount}) after error: ${lastError instanceof Error ? lastError.message : String(lastError)}`))\n            await this.emitEvent(\"testRetrying\", {\n              configuration: this.getConfiguration(),\n              descriptions,\n              error: lastError,\n              nextAttempt: attemptNumber + 1,\n              retriesUsed,\n              retryCount,\n              testArgs,\n              testData,\n              testDescription,\n              testRunner: this\n            })\n          }\n\n          if (attemptNumber > 1) {\n            await this.emitEvent(\"testRetried\", {\n              configuration: this.getConfiguration(),\n              descriptions,\n              error: lastError,\n              attemptNumber,\n              retriesUsed,\n              retryCount,\n              testArgs,\n              testData,\n              testDescription,\n              testRunner: this\n            })\n          }\n\n          attemptNumber++\n\n          if (shouldRetry) continue\n\n          if (failedError) {\n            const consoleOutput = this.buildConsoleOutput(attemptConsoleOutputs)\n\n            if (failedError instanceof Error) {\n              console.error(picocolors.red(`${leftPadding}  Test failed: ${failedError.message}`))\n              addTrackedStackToError(failedError)\n\n              const backtraceCleaner = new BacktraceCleaner(failedError)\n              const cleanedStack = backtraceCleaner.getCleanedStack()\n              const stackLines = cleanedStack?.split(\"\\n\")\n\n              if (stackLines) {\n                for (const stackLine of stackLines) {\n                  console.error(picocolors.red(`${leftPadding}  ${stackLine}`))\n                }\n              }\n            } else {\n              console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof failedError}: ${String(failedError)}`))\n            }\n\n            this.printFailedConsoleOutput({consoleOutput, leftPadding})\n            this._failedTests++\n            this._failedTestDetails.push({\n              fullDescription: this.buildFullDescription(descriptions, testDescription),\n              filePath: testData.filePath,\n              line: testData.line,\n              error: failedError,\n              consoleOutput: consoleOutput || undefined\n            })\n\n            await this.emitEvent(\"testFailed\", {\n              configuration: this.getConfiguration(),\n              descriptions,\n              error: failedError,\n              testArgs,\n              testData,\n              testDescription,\n              testRunner: this\n            })\n\n            this.printRerunCommand({descriptions, testDescription, testData, leftPadding})\n          }\n\n          break\n        }\n\n        this._testDurations.push({\n          fullDescription: this.buildFullDescription(descriptions, testDescription),\n          filePath: testData.filePath ?? \"<unknown>\",\n          line: testData.line ?? 0,\n          durationMs: Date.now() - testStartMs\n        })\n\n        if (this._abortRemainingTests) break\n      }\n\n      for (const subDescription in tests.subs) {\n        if (this._abortRemainingTests) break\n\n        const subTest = tests.subs[subDescription]\n        const newDecriptions = descriptions.concat([subDescription])\n        const childScopeLineMatch = scopeLineMatch || this.matchesLineFilter(subTest)\n\n        if (!this._onlyFocussed || subTest.anyTestsFocussed) {\n          console.log(`${leftPadding}${subDescription}`)\n          await this.runTests({\n            afterEaches: newAfterEaches,\n            beforeEaches: newBeforeEaches,\n            tests: subTest,\n            descriptions: newDecriptions,\n            indentLevel: indentLevel + 1,\n            lineMatchedInScope: childScopeLineMatch,\n            parentProfileScopeId: profileScopeId\n          })\n        }\n      }\n    } catch (error) {\n      scopeErrors.push(error)\n    }\n\n    try {\n      await this.runAfterAllsForScope(scopeEntry)\n    } catch (error) {\n      scopeErrors.push(error)\n    }\n    const scopeIndex = this._activeAfterAllScopes.indexOf(scopeEntry)\n\n    if (scopeIndex >= 0) {\n      this._activeAfterAllScopes.splice(scopeIndex, 1)\n    }\n\n    if (scopeErrors.length > 0 && this._abortRemainingTests) {\n      const error = scopeErrors.length == 1\n        ? scopeErrors[0]\n        : new AggregateError(scopeErrors, \"Test scope and afterAll cleanup failed\", {cause: scopeErrors[0]})\n\n      this.recordTimeoutCleanupFailure(error, \"afterAll\")\n      return\n    }\n    if (scopeErrors.length == 1) throw scopeErrors[0]\n    if (scopeErrors.length > 1) throw new AggregateError(scopeErrors, \"Test scope and afterAll cleanup failed\", {cause: scopeErrors[0]})\n  }\n\n  /**\n   * Runs run after alls for scope.\n   * @param {ActiveAfterAllScopeEntry} scopeEntry - Scope entry.\n   * @returns {Promise<void>} - Resolves when scope cleanup finishes.\n   */\n  async runAfterAllsForScope(scopeEntry) {\n    if (scopeEntry.afterAllsRun) return\n\n    scopeEntry.afterAllsRun = true\n\n    const scopeOwnerFilePath = scopeEntry.tests.ownerFilePath ?? scopeEntry.tests.filePath\n    const afterAlls = [...this.profileHookEntries(\n      scopeEntry.tests.afterAlls || [],\n      scopeEntry.profileScopeId,\n      scopeOwnerFilePath\n    )].reverse()\n    /** @type {unknown[]} */\n    const afterAllErrors = []\n\n    for (const afterAllData of afterAlls) {\n      try {\n        await this.runProfileSpan({\n          phase: \"afterAll\",\n          declarationIndex: afterAllData.declarationIndex,\n          declarationScopeId: afterAllData.declarationScopeId,\n          filePath: afterAllData.ownerFilePath\n        }, async () => {\n          await afterAllData.callback({configuration: this.getConfiguration()})\n        })\n      } catch (error) {\n        afterAllErrors.push(error)\n      }\n    }\n\n    if (afterAllErrors.length == 1) throw afterAllErrors[0]\n    if (afterAllErrors.length > 1) {\n      throw new AggregateError(afterAllErrors, \"Multiple afterAll hooks failed\", {cause: afterAllErrors[0]})\n    }\n  }\n\n  /**\n   * Runs emit event.\n   * @param {string} eventName - Event name.\n   * @param {object} payload - Event payload.\n   * @returns {Promise<void>} - Resolves when all listeners complete.\n   */\n  async emitEvent(eventName, payload) {\n    const listeners = testEvents.listeners(eventName)\n\n    for (const listener of listeners) {\n      await listener(payload)\n    }\n  }\n\n  /**\n   * Runs print rerun command.\n   * @param {object} args - Options object.\n   * @param {string[]} args.descriptions - Description stack.\n   * @param {string} args.testDescription - Test description.\n   * @param {TestData} args.testData - Test data.\n   * @param {string} args.leftPadding - Left padding.\n   * @returns {void} - No return value.\n   */\n  printRerunCommand({descriptions, testDescription, testData, leftPadding}) {\n    const rerun = this.buildRerunCommand({descriptions, testDescription, testData})\n\n    if (rerun) {\n      console.error(`${leftPadding}  Re-run: ${rerun}`)\n    }\n  }\n\n  /**\n   * Runs build rerun command.\n   * @param {object} args - Options object.\n   * @param {string[]} args.descriptions - Description stack.\n   * @param {string} args.testDescription - Test description.\n   * @param {TestData} args.testData - Test data.\n   * @returns {string | undefined} - Rerun command.\n   */\n  buildRerunCommand({descriptions, testDescription, testData}) {\n    const baseCommand = \"npx velocious test\"\n    const filePath = testData.filePath\n    const line = testData.line\n\n    if (filePath && line) {\n      const relativePath = path.relative(process.cwd(), filePath)\n      return `${baseCommand} ${relativePath}:${line}`\n    }\n\n    const fullDescription = this.buildFullDescription(descriptions, testDescription)\n\n    if (fullDescription) {\n      return `${baseCommand} --example ${JSON.stringify(fullDescription)}`\n    }\n\n    return undefined\n  }\n\n  /**\n   * Runs build console output.\n   * @param {AttemptConsoleOutput[]} attemptConsoleOutputs - Attempt output entries.\n   * @returns {string} - Combined console output.\n   */\n  buildConsoleOutput(attemptConsoleOutputs) {\n    if (attemptConsoleOutputs.length === 0) return \"\"\n    if (attemptConsoleOutputs.length === 1) return attemptConsoleOutputs[0].output\n\n    return attemptConsoleOutputs.map((attemptConsoleOutput) => {\n      return `--- Attempt ${attemptConsoleOutput.attemptNumber} ---\\n${attemptConsoleOutput.output}`\n    }).join(\"\\n\")\n  }\n\n  /**\n   * Runs get failed console output max lines.\n   * @returns {number} - Maximum failed console lines.\n   */\n  getFailedConsoleOutputMaxLines() {\n    const maxLines = testConfig.failedConsoleOutputMaxLines\n\n    if (typeof maxLines !== \"number\" || !Number.isFinite(maxLines)) return 200\n\n    return Math.max(0, Math.floor(maxLines))\n  }\n\n  /**\n   * Runs truncate failed console output lines.\n   * @param {string} consoleOutput - Console output.\n   * @returns {string[]} - Lines for inline output.\n   */\n  truncateFailedConsoleOutputLines(consoleOutput) {\n    const lines = consoleOutput.split(\"\\n\")\n    const maxLines = this.getFailedConsoleOutputMaxLines()\n\n    if (maxLines === 0) return []\n    if (lines.length <= maxLines) return lines\n\n    const omittedLines = lines.length - maxLines\n    const plural = omittedLines === 1 ? \"\" : \"s\"\n\n    return [\n      `... ${omittedLines} console output line${plural} omitted ...`,\n      ...lines.slice(-maxLines)\n    ]\n  }\n\n  /**\n   * Runs print failed console output.\n   * @param {object} args - Options object.\n   * @param {string} args.consoleOutput - Console output.\n   * @param {string} args.leftPadding - Left padding.\n   * @returns {void} - No return value.\n   */\n  printFailedConsoleOutput({consoleOutput, leftPadding}) {\n    if (testConfig.consoleOutput !== \"failure\") return\n    if (!consoleOutput) return\n\n    const lines = this.truncateFailedConsoleOutputLines(consoleOutput)\n\n    if (lines.length === 0) return\n\n    console.error(picocolors.red(`${leftPadding}  Console output:`))\n\n    for (const line of lines) {\n      console.error(picocolors.red(`${leftPadding}    ${line}`))\n    }\n  }\n\n  /**\n   * Runs start console capture.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.passthrough] - Whether to pass through to the original console.\n   * @returns {() => string} - Stops the capture and returns captured text.\n   */\n  startConsoleCapture({passthrough = false} = {}) {\n    /**\n     * Lines.\n     * @type {string[]} */\n    const lines = []\n    /**\n     * Console object.\n     * @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */\n    const consoleObject = /** @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */ (console)\n    /**\n     * Original console methods captured as direct references so stopping restores\n     * the exact method that was installed at capture start.\n     * @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */\n    const originalConsoleMethods = {\n      debug: consoleObject.debug,\n      error: consoleObject.error,\n      info: consoleObject.info,\n      log: consoleObject.log,\n      warn: consoleObject.warn\n    }\n    let stopped = false\n    let outputText = \"\"\n\n    for (const methodName of CAPTURED_CONSOLE_METHODS) {\n      consoleObject[methodName] = (...args) => {\n        lines.push(`[${new Date().toISOString()}] [${methodName}] ${format(...args)}`)\n\n        if (passthrough) {\n          originalConsoleMethods[methodName].apply(consoleObject, args)\n        }\n      }\n    }\n\n    return () => {\n      if (!stopped) {\n        stopped = true\n\n        for (const methodName of CAPTURED_CONSOLE_METHODS) {\n          consoleObject[methodName] = originalConsoleMethods[methodName]\n        }\n\n        outputText = lines.join(\"\\n\")\n      }\n\n      return outputText\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-runner.js","sourceRoot":"","sources":["../../../src/testing/test-runner.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport fs from \"node:fs/promises\"\nimport path from \"path\"\nimport {AsyncLocalStorage} from \"node:async_hooks\"\nimport {createTestContext, defaultTestContext} from \"@velocious/testing\"\nimport {TestRunner as PackageTestRunner} from \"@velocious/testing/runner\"\nimport Application from \"../../src/application.js\"\nimport RequestClient from \"./request-client.js\"\nimport picocolors from \"picocolors\"\nimport restArgsError from \"../utils/rest-args-error.js\"\nimport {testConfig} from \"./test.js\"\nimport {fileURLToPath, pathToFileURL} from \"url\"\nimport SharedTransactionBroker from \"./shared-transaction-broker.js\"\nimport { SHARED_TRANSACTION_BROKER_ENV } from \"./shared-transaction-proxy-driver.js\"\nimport VelociousAttemptExecutor from \"./velocious-attempt-executor.js\"\nimport VelociousRunnerReporter, {AbortRemainingTestsError} from \"./velocious-runner-reporter.js\"\nimport VelociousSuiteHookExecutor from \"./velocious-suite-hook-executor.js\"\nimport VelociousTestArguments from \"./velocious-test-arguments.js\"\n\n/** @typedef {typeof defaultTestContext} PackageTestContext */\n/** @typedef {(typeof defaultTestContext.registry.suites)[number]} PackageSuiteDeclaration */\n/** @typedef {PackageSuiteDeclaration[\"tests\"][number]} PackageTestDeclaration */\n/** @typedef {PackageSuiteDeclaration[\"hooks\"][\"beforeAll\"][number]} PackageHookDeclaration */\n/** @typedef {PackageSuiteDeclaration | PackageTestDeclaration | PackageHookDeclaration} PackageRegistration */\n/** @typedef {{hadRetries: boolean, options: PackageTestDeclaration[\"options\"], retries: number | undefined}} PackageRetryOptionRestoration */\n\n/**\n * AttemptConsoleOutput type.\n * @typedef {object} AttemptConsoleOutput\n * @property {number} attemptNumber - Attempt number.\n * @property {string} output - Captured console output.\n */\n/**\n * TestArgs type.\n * @typedef {object} TestArgs\n * @property {Application} [application] - Application instance for integration tests.\n * @property {RequestClient} [client] - HTTP client for request tests.\n * @property {object} [databaseCleaning] - Database cleanup options for tests.\n * @property {boolean} [databaseCleaning.transaction] - Use transactions to rollback between tests.\n * @property {boolean} [databaseCleaning.truncate] - Truncate tables between tests.\n * @property {boolean} [databaseCleaning.truncateBefore] - Truncate tables before each test, in addition to the default cleanup.\n * @property {boolean} [focus] - Whether this test is focused.\n * @property {() => (void|Promise<void>)} [function] - Test callback function.\n * @property {number} [retry] - Number of retries when a test fails.\n * @property {string[] | string} [tags] - Tags for filtering.\n * @property {number} [timeoutSeconds] - Timeout in seconds for the test.\n * @property {string} [type] - Test type identifier.\n * @property {(args: {databaseIdentifier: string, tenant: object}) => Promise<void>} [registerTransactionalTenant] - Registers one resolved tenant database transaction for this attempt.\n */\n/**\n * BrowserDummyConnectionRegistration type.\n * @typedef {object} BrowserDummyConnectionRegistration\n * @property {import(\"../database/drivers/base.js\").default} db - Attempt-owned connection.\n * @property {string} databaseIdentifier - Configured database identifier.\n * @property {Promise<void>} [quarantinePromise] - Shared connection-discard promise.\n * @property {boolean} quarantined - Whether the connection is unsafe to reuse.\n * @property {Promise<void>} [rollbackPromise] - Shared rollback promise.\n * @property {Promise<void>} [startPromise] - Transaction startup promise when transaction cleaning is enabled.\n */\n/**\n * TestData type.\n * @typedef {object} TestData\n * @property {TestArgs} args - Arguments passed to the test.\n * @property {string} [filePath] - Source file path.\n * @property {number} [line] - Source line number.\n * @property {string} [ownerFilePath] - Deterministic importing test file.\n * @property {(arg: TestArgs) => (void|Promise<void>)} function - Test callback to execute.\n * @property {PackageTestDeclaration} [declaration] - Package declaration.\n */\n/**\n * FailedTestDetail type.\n * @typedef {object} FailedTestDetail\n * @property {string} fullDescription - Full test description.\n * @property {string} [filePath] - Source file path.\n * @property {number} [line] - Source line number.\n * @property {ReturnType<typeof JSON.parse>} error - Failure error.\n * @property {string} [consoleOutput] - Captured console output while test ran.\n * @property {string} [consoleLogPath] - Saved console log path.\n */\n/**\n * Defines this typedef.\n * @typedef {(args: {configuration: import(\"../configuration.js\").default, testArgs: TestArgs, testData: TestData}) => (void|Promise<void>)} AfterBeforeEachCallbackType\n */\n/**\n * AfterBeforeEachCallbackObjectType type.\n * @typedef {object} AfterBeforeEachCallbackObjectType\n * @property {AfterBeforeEachCallbackType} callback - Hook callback to execute.\n * @property {number} [declarationIndex] - Hook index within its declaration scope.\n * @property {string} [declarationScopeId] - Opaque profile scope identifier.\n * @property {string} [ownerFilePath] - Deterministic importing test file.\n */\n/**\n * Defines this typedef.\n * @typedef {(args: {configuration: import(\"../configuration.js\").default}) => (void|Promise<void>)} BeforeAfterAllCallbackType\n */\n/**\n * BeforeAfterAllCallbackObjectType type.\n * @typedef {object} BeforeAfterAllCallbackObjectType\n * @property {BeforeAfterAllCallbackType} callback - Hook callback to execute.\n * @property {number} [declarationIndex] - Hook index within its declaration scope.\n * @property {string} [declarationScopeId] - Opaque profile scope identifier.\n * @property {string} [ownerFilePath] - Deterministic importing test file.\n */\n/**\n * TestsArgument type.\n * @typedef {object} TestsArgument\n * @property {TestArgs} args - Arguments inherited by tests in this scope.\n * @property {boolean} [anyTestsFocussed] - Whether any tests in the tree are focused.\n * @property {AfterBeforeEachCallbackObjectType[]} afterEaches - After-each hooks for this scope.\n * @property {BeforeAfterAllCallbackObjectType[]} afterAlls - After-all hooks for this scope.\n * @property {BeforeAfterAllCallbackObjectType[]} beforeAlls - Before-all hooks for this scope.\n * @property {AfterBeforeEachCallbackObjectType[]} beforeEaches - Before-each hooks for this scope.\n * @property {string} [filePath] - Source file path.\n * @property {number} [line] - Source line number.\n * @property {string} [ownerFilePath] - Deterministic importing test file.\n * @property {Record<string, TestData>} tests - A unique identifier for the node.\n * @property {Record<string, TestsArgument>} subs - Optional child nodes. Each item is another `Node`, allowing recursion.\n */\n/**\n * Marks the error thrown by the attempt timeout so the runner can distinguish\n * detached lifecycle cleanup from an ordinary test failure.\n * @typedef {Error & {velociousTestTimeout?: true}} TestTimeoutError\n */\n/**\n * SharedTransactionBrokerRegistration type.\n * @typedef {object} SharedTransactionBrokerRegistration\n * @property {SharedTransactionBroker} broker - Attempt broker and connection coordinator.\n * @property {boolean} environmentPublished - Whether child-process coordinates were published.\n * @property {string | undefined} previousEnvironment - Environment value to restore after publication.\n */\n/**\n * TransactionalTenantRegistration type.\n * @typedef {object} TransactionalTenantRegistration\n * @property {Promise<{connection: import(\"../database/drivers/base.js\").default | undefined, error: Error | undefined}> | undefined} [checkoutPromise] - Attempt-owned physical checkout outcome.\n * @property {import(\"../database/drivers/base.js\").default | undefined} connection - Attempt-owned physical connection once checkout resolves.\n * @property {Promise<void> | undefined} [cleanupPromise] - Single cleanup operation shared by emergency and eventual lifecycle cleanup.\n * @property {boolean | undefined} [discardOnCleanup] - Whether timeout emergency cleanup must quarantine this connection.\n * @property {import(\"../database/pool/base.js\").default} pool - Owning logical pool.\n * @property {boolean} revoked - Whether this attempt may still publish the physical registration.\n * @property {string} reuseKey - Resolved physical configuration identity.\n * @property {import(\"../database/pool/base.js\").TestSharedConnectionRegistration | undefined} sharedRegistration - Physical-key shared registration once published.\n */\n\n/**\n * Runs to file slug.\n * @param {string} value - Value to sanitize.\n * @returns {string} - Slug-safe value.\n */\nfunction toFileSlug(value) {\n  return value\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-+|-+$/g, \"\")\n    .slice(0, 80) || \"failed-test\"\n}\n\nexport default class TestRunner {\n  /** @type {PackageTestContext} */\n  _context\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {FailedTestDetail[]} */\n  _failedTestDetails\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {PackageTestContext} [args.context] - Declaration context.\n   * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n   * @param {string[] | string} [args.includeTags] - Tags to include.\n   * @param {Array<string>} args.testFiles - Test files.\n   * @param {Record<string, number[]>} [args.lineFilters] - Line filters by file.\n   * @param {RegExp[]} [args.examplePatterns] - Example patterns.\n   * @param {import(\"./test-profiler.js\").default} [args.profiler] - Opt-in profiler.\n   */\n  constructor({configuration, context = defaultTestContext, excludeTags, includeTags, testFiles, lineFilters, examplePatterns, profiler, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!configuration) throw new Error(\"configuration is required\")\n\n    this._configuration = configuration\n    this._context = context\n    this._sharedTransactionCoordinatorOwnerStorage = new AsyncLocalStorage()\n    this._testDatabaseAccessScopeStorage = new AsyncLocalStorage()\n    this._excludeTags = this.normalizeTags(excludeTags)\n    this._includeTags = this.normalizeTags(includeTags)\n    this._testFiles = testFiles\n    this._lineFilters = lineFilters || {}\n    this._examplePatterns = examplePatterns || []\n    this._profiler = profiler\n    this._abortRemainingTests = false\n\n    this._failedTests = 0\n    this._successfulTests = 0\n    this._testsCount = 0\n    this._failedTestDetails = []\n    /** @type {{fullDescription: string, filePath: string, line: number} | null} */\n    this._lastTestContext = null\n    /** @type {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} */\n    this._testDurations = []\n    /** @type {WeakMap<PackageTestDeclaration, {testArgs: TestArgs, testData: TestData}>} */\n    this._testCompatibility = new WeakMap()\n    /** @type {WeakSet<PackageTestDeclaration>} */\n    this._injectedTests = new WeakSet()\n    /** @type {WeakSet<PackageTestDeclaration>} */\n    this._completedTests = new WeakSet()\n    /** @type {WeakMap<PackageTestDeclaration, {descriptions: string[], testDescription: string, fullDescription: string, ownerFilePath: string | undefined, suites: PackageSuiteDeclaration[]}>} */\n    this._testMetadata = new WeakMap()\n    /** @type {WeakMap<PackageHookDeclaration, {declarationIndex: number, declarationScopeId: string | undefined, ownerFilePath: string | undefined}>} */\n    this._hookMetadata = new WeakMap()\n    /** @type {WeakMap<PackageTestDeclaration, Map<number, {abortRemainingTests: boolean, error: ReturnType<typeof JSON.parse>, failed: boolean}>>} */\n    this._attemptOutcomes = new WeakMap()\n    /** @type {Array<{suite: PackageSuiteDeclaration, phase: \"beforeAll\" | \"afterAll\", error: ReturnType<typeof JSON.parse>}>} */\n    this._suiteHookFailures = []\n    /** @type {Map<string, PackageTestDeclaration[]>} */\n    this._testsByFullName = new Map()\n    /** @type {WeakMap<PackageRegistration, string>} */\n    this._declarationOwners = new WeakMap()\n    /** @type {PackageTestRunner | undefined} */\n    this._packageRunner = undefined\n    /** @type {import(\"@velocious/testing/runner\").TestRunResult | undefined} */\n    this._packageResult = undefined\n    /** @type {Map<string, TestData> | undefined} */\n    this._legacyFixtureDataByFullName = undefined\n    /** @type {{filePath?: string, line?: number}} */\n    this._legacyFixtureLocation = {}\n    this._attemptExecutor = new VelociousAttemptExecutor({testRunner: this})\n    this._runnerReporter = new VelociousRunnerReporter({testRunner: this})\n    this._suiteHookExecutor = new VelociousSuiteHookExecutor({testRunner: this})\n    this._testArguments = new VelociousTestArguments({testRunner: this})\n  }\n\n  /**\n   * Gets the package declaration context.\n   * @returns {PackageTestContext} - Package declaration context.\n   */\n  getTestContext() { return this._context }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"../configuration.js\").default} - The configuration.\n   */\n  getConfiguration() { return this._configuration }\n\n  /**\n   * Runs get test files.\n   * @returns {string[]} - The test files.\n   */\n  getTestFiles() { return this._testFiles }\n\n  /**\n   * Runs get line filters.\n   * @returns {Record<string, number[]>} - Line filters.\n   */\n  getLineFilters() { return this._lineFilters }\n\n  /**\n   * Runs get example patterns.\n   * @returns {RegExp[]} - Example patterns.\n   */\n  getExamplePatterns() { return this._examplePatterns }\n\n  /**\n   * Runs a profiler span only when profiling was explicitly enabled.\n   * @template T\n   * @param {object} metadata - Span metadata.\n   * @param {string} metadata.phase - Phase name.\n   * @param {number} [metadata.declarationIndex] - Hook declaration index.\n   * @param {string} [metadata.declarationScopeId] - Hook declaration scope.\n   * @param {string} [metadata.filePath] - Source ownership.\n   * @param {() => (T | Promise<T>)} callback - Timed callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async runProfileSpan(metadata, callback) {\n    if (!this._profiler) return await callback()\n\n    return await this._profiler.runSpan(metadata, callback)\n  }\n\n  /**\n   * Runs normalize tags.\n   * @param {string[] | string | undefined} tags - Tags.\n   * @returns {string[]} - Normalized tags.\n   */\n  normalizeTags(tags) {\n    if (!tags) return []\n\n    const values = []\n    const rawTags = Array.isArray(tags) ? tags : [tags]\n\n    for (const rawTag of rawTags) {\n      if (rawTag === undefined || rawTag === null) continue\n\n      const parts = String(rawTag).split(\",\")\n\n      for (const part of parts) {\n        const trimmed = part.trim()\n\n        if (trimmed) values.push(trimmed)\n      }\n    }\n\n    return Array.from(new Set(values))\n  }\n\n  /**\n   * Runs has tag.\n   * @param {TestArgs} testArgs - Test args.\n   * @param {string} tag - Tag to check for.\n   * @returns {boolean} - Whether tag is present.\n   */\n  hasTag(testArgs, tag) {\n    return this.normalizeTags(testArgs?.tags).includes(tag)\n  }\n\n  /**\n   * Runs is browser test mode.\n   * @returns {boolean} - Whether running browser tests.\n   */\n  isBrowserTestMode() {\n    return process.env.VELOCIOUS_BROWSER_TESTS === \"true\"\n  }\n\n  /**\n   * Runs run with dummy if needed.\n   * @param {TestArgs} testArgs - Test args.\n   * @param {() => Promise<void>} callback - Callback to run.\n   * @param {BrowserDummyConnectionRegistration[]} [browserDummyConnectionRegistrations] - Attempt-owned browser connections.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runWithDummyIfNeeded(testArgs, callback, browserDummyConnectionRegistrations = []) {\n    if (!this.hasTag(testArgs, \"dummy\")) {\n      await callback()\n      return\n    }\n\n    if (this.isBrowserTestMode()) {\n      await this.runBrowserDummy(testArgs, callback, browserDummyConnectionRegistrations)\n      return\n    }\n\n    await this.runNodeDummy(callback)\n  }\n\n  /**\n   * Runs run node dummy.\n   * @param {() => Promise<void>} callback - Callback to run.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runNodeDummy(callback) {\n    const dummyPath = process.env.VELOCIOUS_DUMMY_PATH || this.defaultDummyPath()\n    const dummyImport = await import(pathToFileURL(dummyPath).href)\n    const Dummy = dummyImport.default\n\n    if (!Dummy?.run) {\n      throw new Error(`Dummy helper not found at ${dummyPath}`)\n    }\n\n    // Persistent server resources must not inherit an attempt scope that will be revoked.\n    await this.getConfiguration().getEnvironmentHandler().runWithCapturedTestDatabaseAccessScope(undefined, async () => {\n      await Dummy.run(async () => {})\n    })\n    this.getConfiguration().assertDatabaseAccessAllowed()\n    await callback()\n  }\n\n  /**\n   * Runs default dummy path.\n   * @returns {string} - Default dummy helper path.\n   */\n  defaultDummyPath() {\n    const cwd = path.resolve(process.cwd())\n    const normalized = cwd.split(path.sep).join(\"/\")\n\n    if (normalized.endsWith(\"/spec/dummy\")) {\n      return path.join(cwd, \"index.js\")\n    }\n\n    return path.join(cwd, \"spec/dummy/index.js\")\n  }\n\n  /**\n   * Runs run browser dummy.\n   * @param {TestArgs} testArgs - Test args.\n   * @param {() => Promise<void>} callback - Callback to run.\n   * @param {BrowserDummyConnectionRegistration[]} connectionRegistrations - Attempt-owned browser connections.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runBrowserDummy(testArgs, callback, connectionRegistrations) {\n    const useTransaction = testArgs.databaseCleaning?.transaction === true\n    const truncate = testArgs.databaseCleaning?.truncate\n    const shouldTruncate = truncate === undefined ? !useTransaction : truncate\n\n    if (!useTransaction && !shouldTruncate) {\n      await callback()\n      return\n    }\n\n    await this.getConfiguration().ensureConnections({name: \"Test runner browser dummy\"}, async (dbs) => {\n      const newRegistrations = Object.entries(dbs).map(([databaseIdentifier, db]) => {\n        /** @type {BrowserDummyConnectionRegistration} */\n        const registration = {\n          databaseIdentifier,\n          db,\n          quarantined: false\n        }\n\n        connectionRegistrations.push(registration)\n\n        return registration\n      })\n\n      if (shouldTruncate) {\n        this.getConfiguration().assertDatabaseAccessAllowed()\n        await this.truncateDatabases(dbs)\n      }\n      /** @type {unknown[]} */\n      const lifecycleErrors = []\n\n      try {\n        if (useTransaction) {\n          const startPromises = newRegistrations.map((registration) => {\n            const startPromise = registration.db.startTransaction()\n\n            registration.startPromise = startPromise\n            return startPromise\n          })\n          const startResults = await Promise.allSettled(startPromises)\n          const startErrors = startResults\n            .filter((result) => result.status === \"rejected\")\n            .map((result) => result.reason)\n\n          if (startErrors.length == 1) throw startErrors[0]\n          if (startErrors.length > 1) {\n            throw new AggregateError(startErrors, \"Browser dummy transaction startup failed\", {cause: startErrors[0]})\n          }\n        }\n\n        this.getConfiguration().assertDatabaseAccessAllowed()\n        await callback()\n      } catch (error) {\n        lifecycleErrors.push(error)\n      }\n\n      try {\n        await this.rollbackBrowserDummyTransactions(connectionRegistrations)\n      } catch (error) {\n        if (error instanceof AggregateError) {\n          lifecycleErrors.push(...error.errors)\n        } else {\n          lifecycleErrors.push(error)\n        }\n      }\n\n      try {\n        if (shouldTruncate) {\n          this.getConfiguration().assertDatabaseAccessAllowed()\n          await this.truncateDatabases(dbs)\n        }\n      } catch (error) {\n        lifecycleErrors.push(error)\n      }\n\n      if (lifecycleErrors.length == 1) throw lifecycleErrors[0]\n      if (lifecycleErrors.length > 1) {\n        throw new AggregateError(lifecycleErrors, \"Browser dummy lifecycle and cleanup failed\", {cause: lifecycleErrors[0]})\n      }\n    })\n  }\n\n  /**\n   * Rolls back every attempt-owned browser transaction exactly once.\n   * @param {BrowserDummyConnectionRegistration[]} registrations - Browser connections.\n   * @returns {Promise<void>} - Resolves after all rollbacks settle.\n   */\n  async rollbackBrowserDummyTransactions(registrations) {\n    const rollbackResults = await Promise.allSettled([...registrations].reverse().map((registration) => {\n      const startPromise = registration.startPromise\n\n      if (!startPromise) return\n\n      registration.rollbackPromise ??= (async () => {\n        if (registration.quarantined) return\n\n        try {\n          await startPromise\n        } catch {\n          try {\n            await this.quarantineBrowserDummyConnection(registration)\n          } catch (quarantineError) {\n            throw new Error(`Failed to quarantine browser dummy database after transaction startup failed: ${registration.databaseIdentifier}`, {cause: quarantineError})\n          }\n          return\n        }\n        if (registration.quarantined) return\n\n        try {\n          await registration.db.rollbackTransaction()\n        } catch (rollbackError) {\n          try {\n            await this.quarantineBrowserDummyConnection(registration)\n          } catch (quarantineError) {\n            throw new AggregateError(\n              [rollbackError, quarantineError],\n              `Failed to roll back and quarantine browser dummy database: ${registration.databaseIdentifier}`,\n              {cause: quarantineError}\n            )\n          }\n          throw rollbackError\n        }\n      })()\n\n      return registration.rollbackPromise\n    }))\n    const errors = rollbackResults\n      .filter((result) => result.status === \"rejected\")\n      .map((result) => result.reason)\n\n    if (errors.length == 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Browser dummy transaction cleanup failed\", {cause: errors[0]})\n  }\n\n  /**\n   * Permanently removes one browser connection that cannot be shared safely.\n   * @param {BrowserDummyConnectionRegistration} registration - Browser connection registration.\n   * @returns {Promise<void>} - Resolves after the connection is discarded.\n   */\n  async quarantineBrowserDummyConnection(registration) {\n    registration.quarantined = true\n    registration.quarantinePromise ??= this.discardBrowserDummyConnection(registration.databaseIdentifier, registration.db)\n    await registration.quarantinePromise\n  }\n\n  /**\n   * Discards one browser dummy connection through its owning pool.\n   * @param {string} databaseIdentifier - Configured database identifier.\n   * @param {import(\"../database/drivers/base.js\").default} db - Unsafe connection.\n   * @returns {Promise<void>} - Resolves after discard.\n   */\n  async discardBrowserDummyConnection(databaseIdentifier, db) {\n    await this.getConfiguration().getDatabasePool(databaseIdentifier).discard(db)\n  }\n\n  /**\n   * Quarantines all browser connections concurrently.\n   * @param {BrowserDummyConnectionRegistration[]} registrations - Browser connection registrations.\n   * @returns {Promise<void>} - Resolves after every connection is discarded.\n   */\n  async quarantineBrowserDummyConnections(registrations) {\n    const quarantineResults = await Promise.allSettled(registrations.map(async (registration) => {\n      await this.quarantineBrowserDummyConnection(registration)\n    }))\n    const errors = quarantineResults\n      .filter((result) => result.status === \"rejected\")\n      .map((result) => result.reason)\n\n    if (errors.length == 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Browser dummy connection quarantine failed\", {cause: errors[0]})\n  }\n\n  /**\n   * Runs truncate databases.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} dbs - Database connections.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async truncateDatabases(dbs) {\n    for (const identifier of Object.keys(dbs)) {\n      await dbs[identifier].truncateAllTables()\n    }\n  }\n\n  /**\n   * Runs get exclude tag set.\n   * @returns {Set<string>} - Exclude tag set.\n   */\n  getExcludeTagSet() {\n    /**\n     * Config tags.\n     * @type {string[]} */\n    const configTags = Array.isArray(testConfig.excludeTags) ? testConfig.excludeTags : []\n\n    return new Set([...this._excludeTags, ...configTags])\n  }\n\n  /**\n   * Runs build full description.\n   * @param {string[]} descriptions - Description stack.\n   * @param {string} testDescription - Test description.\n   * @returns {string} - Full description.\n   */\n  buildFullDescription(descriptions, testDescription) {\n    const parts = descriptions.concat([testDescription])\n\n    return parts.join(\" \").trim()\n  }\n\n  /**\n   * Runs application.\n   * @returns {Promise<Application>} - Resolves with the application.\n   */\n  async application() {\n    if (!this._application) {\n      this._application = new Application({\n        configuration: this.getConfiguration(),\n        // Run request handlers in the main thread (not worker threads) so they\n        // resolve DB work to the per-test shared connection set by\n        // {@link activateTestSharedConnections}. This lets request-type specs use\n        // transaction-based cleaning (their writes land inside the test's\n        // transaction and roll back) instead of truncating every table.\n        httpServer: {inProcess: true, port: 31006},\n        type: \"test-runner\"\n      })\n\n      await this._application.initialize()\n      await this._application.startHttpServer()\n    }\n\n    return this._application\n  }\n\n  /**\n   * Registers each non-tenant per-test connection as a dynamic candidate for in-process\n   * request sharing. The pool evaluates transaction state when each request is dispatched,\n   * so a transaction started or ended during a hook callback takes effect immediately.\n   * Inactive and tenant-only connections remain independently pooled. Pair with\n   * {@link clearTestSharedConnections} in a finally.\n   * @returns {{pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}[]} - Lifecycle-owned registrations.\n   */\n  activateTestSharedConnections() {\n    const configuration = this.getConfiguration()\n    const currentConnections = configuration.getCurrentConnections()\n    /** @type {{pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}[]} */\n    const registrations = []\n\n    for (const identifier of Object.keys(currentConnections)) {\n      const pool = configuration.getDatabasePool(identifier)\n\n      // Tenant-scoped pools resolve a different connection per request tenant\n      // (via runWithTenant), so forcing a single shared connection would break\n      // per-request tenant resolution. Only share non-tenant pools; the tenant\n      // pool keeps resolving its own connection per request.\n      if (pool.getConfiguration().tenantOnly) {\n        continue\n      }\n\n      const connection = currentConnections[identifier]\n\n      const registration = pool.setTestSharedConnectionProvider(() => {\n        return connection.insideTransaction() ? connection : undefined\n      })\n\n      if (registration) registrations.push({pool, registration})\n    }\n\n    return registrations\n  }\n\n  /**\n   * Clears the in-process test shared connection on every configured pool. Idempotent and\n   * safe to call when none was set.\n   * @param {{pool: import(\"../database/pool/base.js\").default, registration: import(\"../database/pool/base.js\").TestSharedConnectionRegistration}[]} [registrations] - Lifecycle-owned registrations to clear conditionally.\n   * @returns {void}\n   */\n  clearTestSharedConnections(registrations) {\n    if (registrations) {\n      for (const {pool, registration} of registrations) {\n        pool.clearTestSharedConnection(registration)\n      }\n      return\n    }\n\n    const configuration = this.getConfiguration()\n\n    for (const identifier of configuration.getDatabaseIdentifiers()) {\n      configuration.getDatabasePool(identifier).clearTestSharedConnection()\n    }\n  }\n\n  /**\n   * Checks out and registers one physical tenant transaction for the current attempt.\n   * @param {{databaseIdentifier: string, tenant: object}} args - Logical identifier and tenant descriptor.\n   * @param {TransactionalTenantRegistration[]} registrations - Current attempt registrations.\n   * @returns {Promise<void>}\n   */\n  async registerTransactionalTenant({databaseIdentifier, tenant, ...restArgs}, registrations) {\n    restArgsError(restArgs)\n    if (!databaseIdentifier) throw new Error(\"registerTransactionalTenant requires a databaseIdentifier\")\n    if (!tenant) throw new Error(\"registerTransactionalTenant requires a tenant\")\n\n    const configuration = this.getConfiguration()\n    const pool = configuration.getDatabasePool(databaseIdentifier)\n    const databaseConfiguration = configuration.resolveDatabaseConfiguration(databaseIdentifier, tenant)\n    if (!databaseConfiguration.tenantOnly) {\n      throw new Error(`registerTransactionalTenant requires a tenantOnly database: ${databaseIdentifier}`)\n    }\n    const reuseKey = pool.getConfigurationReuseKey(databaseConfiguration)\n    if (registrations.some((registration) => registration.pool === pool && registration.reuseKey === reuseKey)) return\n\n    /** @type {TransactionalTenantRegistration} */\n    const registration = {\n      connection: undefined,\n      pool,\n      reuseKey,\n      revoked: false,\n      sharedRegistration: undefined\n    }\n\n    registrations.push(registration)\n    registration.checkoutPromise = pool\n      .checkoutForConfiguration(databaseConfiguration, {name: \"Transactional tenant test registration\"})\n      .then(\n        (connection) => ({connection, error: undefined}),\n        (error) => ({\n          connection: undefined,\n          error: error instanceof Error ? error : new Error(\"Transactional tenant connection checkout failed\", {cause: error})\n        })\n      )\n\n    try {\n      const checkoutOutcome = await registration.checkoutPromise\n\n      if (checkoutOutcome.error) throw checkoutOutcome.error\n      if (!checkoutOutcome.connection) throw new Error(\"Transactional tenant connection checkout returned no connection\")\n      registration.connection = checkoutOutcome.connection\n      if (registration.revoked) throw new Error(\"Transactional tenant test registration attempt is no longer active\")\n\n      await registration.connection.startTransaction()\n      if (registration.revoked) throw new Error(\"Transactional tenant test registration attempt is no longer active\")\n\n      const sharedRegistration = pool.setTestSharedConnectionForConfiguration(registration.connection, reuseKey)\n      if (!sharedRegistration) throw new Error(`Database pool does not support transactional tenant test connections: ${databaseIdentifier}`)\n      registration.sharedRegistration = sharedRegistration\n      if (registration.revoked) {\n        pool.clearTestSharedConnection(sharedRegistration)\n        throw new Error(\"Transactional tenant test registration attempt is no longer active\")\n      }\n    } catch (error) {\n      registration.revoked = true\n      try {\n        await this.cleanupTransactionalTenants([registration], {discard: registration.discardOnCleanup === true})\n      } catch (cleanupError) {\n        throw new AggregateError([error, cleanupError], \"Failed to register and clean up a transactional tenant test connection\", {cause: cleanupError})\n      }\n      throw error\n    }\n  }\n\n  /**\n   * Revokes attempt registrations before rolling back and releasing their connections.\n   * @param {TransactionalTenantRegistration[]} registrations - Attempt registrations.\n   * @param {{discard?: boolean}} [options] - Whether connections must be discarded instead of returned to the pool.\n   * @returns {Promise<void>}\n   */\n  async cleanupTransactionalTenants(registrations, {discard = false} = {}) {\n    for (const registration of registrations) {\n      registration.revoked = true\n      if (discard) registration.discardOnCleanup = true\n      if (registration.sharedRegistration) registration.pool.clearTestSharedConnection(registration.sharedRegistration)\n    }\n    const cleanupResults = await Promise.allSettled([...registrations].reverse().map((registration) => {\n      registration.cleanupPromise ??= this.cleanupTransactionalTenantRegistration(registration)\n\n      return registration.cleanupPromise\n    }))\n    const errors = cleanupResults\n      .filter((result) => result.status === \"rejected\")\n      .map((result) => result.reason)\n\n    if (errors.length === 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Failed to clean up transactional tenant test connections\")\n  }\n\n  /**\n   * Cleans one attempt registration exactly once, including a checkout that was still pending at revocation.\n   * @param {TransactionalTenantRegistration} registration - Attempt-owned registration.\n   * @returns {Promise<void>} - Resolves after rollback and release or quarantine.\n   */\n  async cleanupTransactionalTenantRegistration(registration) {\n    let connection = registration.connection\n\n    if (!connection && registration.checkoutPromise) {\n      const checkoutOutcome = await registration.checkoutPromise\n\n      if (checkoutOutcome.error) return\n      connection = checkoutOutcome.connection\n      registration.connection = connection\n    }\n    if (!connection) return\n\n    const errors = []\n\n    try {\n      if (connection.insideTransaction()) await connection.rollbackTransaction()\n    } catch (error) {\n      errors.push(error)\n    } finally {\n      try {\n        if (registration.discardOnCleanup) {\n          await registration.pool.discard(connection)\n        } else {\n          await registration.pool.checkin(connection)\n        }\n      } catch (error) {\n        errors.push(error)\n      }\n    }\n    if (errors.length === 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Failed to clean up a transactional tenant test connection\")\n  }\n\n  /**\n   * Selects the current non-tenant connections eligible for shared transaction work.\n   * @param {{transactionsOnly: boolean}} args - Selection options.\n   * @returns {Record<string, import(\"../database/drivers/base.js\").default>} - Eligible connections by identifier.\n   */\n  sharedTransactionConnections({transactionsOnly}) {\n    const configuration = this.getConfiguration()\n    const currentConnections = configuration.getCurrentConnections()\n    /** @type {Record<string, import(\"../database/drivers/base.js\").default>} */\n    const connections = {}\n\n    for (const [identifier, connection] of Object.entries(currentConnections)) {\n      const pool = configuration.getDatabasePool(identifier)\n\n      if (pool.getConfiguration().tenantOnly) continue\n      if (transactionsOnly && !connection.insideTransaction()) continue\n      connections[identifier] = connection\n    }\n\n    return connections\n  }\n\n  /**\n   * Installs physical-connection coordination before a transaction-opening hook\n   * can expose the shared connection to a long-lived in-process service.\n   * Child-process coordinates remain unpublished until the transaction exists.\n   * @returns {Promise<SharedTransactionBrokerRegistration | undefined>} - Prepared coordinator.\n   */\n  async prepareSharedTransactionBroker() {\n    const connections = this.sharedTransactionConnections({transactionsOnly: false})\n\n    if (Object.keys(connections).length === 0) return undefined\n\n    return {\n      broker: await SharedTransactionBroker.start({connections}),\n      environmentPublished: false,\n      previousEnvironment: undefined\n    }\n  }\n\n  /**\n   * Checks whether a prepared broker coordinates exactly the selected physical connections.\n   * @param {SharedTransactionBrokerRegistration | undefined} registration - Prepared coordinator.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} connections - Selected connections.\n   * @returns {boolean} - Whether the identifier set and physical connections match exactly.\n   */\n  sharedTransactionBrokerMatchesConnections(registration, connections) {\n    const identifiers = Object.keys(connections)\n\n    if (!registration || identifiers.length === 0) return false\n    if (Object.keys(registration.broker.connections).length !== identifiers.length) return false\n\n    for (const [identifier, connection] of Object.entries(connections)) {\n      if (registration.broker.connections[identifier] !== connection) return false\n    }\n\n    return true\n  }\n\n  /**\n   * Starts a capability-scoped broker for the active non-tenant physical\n   * transaction connections. No broker/env is installed for truncation-only or\n   * other transaction-disabled attempts.\n   * @param {SharedTransactionBrokerRegistration} [preparedRegistration] - Coordinator prepared before hooks.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} [selectedConnections] - Post-hook active connections.\n   * @returns {Promise<SharedTransactionBrokerRegistration | undefined>} - Attempt registration.\n   */\n  async startSharedTransactionBroker(preparedRegistration, selectedConnections) {\n    const connections = selectedConnections || this.sharedTransactionConnections({transactionsOnly: true})\n\n    const databaseIdentifiers = Object.keys(connections)\n    if (databaseIdentifiers.length === 0) {\n      await this.stopSharedTransactionBroker(preparedRegistration)\n      return undefined\n    }\n\n    let broker\n\n    if (preparedRegistration && this.sharedTransactionBrokerMatchesConnections(preparedRegistration, connections)) {\n      broker = preparedRegistration.broker\n    } else {\n      await this.stopSharedTransactionBroker(preparedRegistration)\n      broker = await SharedTransactionBroker.start({connections})\n    }\n\n    const previousEnvironment = process.env[SHARED_TRANSACTION_BROKER_ENV]\n    process.env[SHARED_TRANSACTION_BROKER_ENV] = Buffer.from(JSON.stringify({\n      address: broker.address(),\n      capability: broker.capability(),\n      databaseIdentifiers,\n      expected: true\n    })).toString(\"base64url\")\n\n    return {broker, environmentPublished: true, previousEnvironment}\n  }\n\n  /**\n   * Revokes an attempt broker before database rollback hooks run and restores\n   * the caller's environment so later pooled/spawned children cannot inherit it.\n   * @param {SharedTransactionBrokerRegistration | undefined} registration - Attempt registration.\n   */\n  async stopSharedTransactionBroker(registration) {\n    if (!registration) return\n\n    if (registration.environmentPublished) {\n      if (registration.previousEnvironment === undefined) {\n        delete process.env[SHARED_TRANSACTION_BROKER_ENV]\n      } else {\n        process.env[SHARED_TRANSACTION_BROKER_ENV] = registration.previousEnvironment\n      }\n    }\n    await registration.broker.close()\n  }\n\n  /**\n   * Runs request client.\n   * @returns {Promise<RequestClient>} - Resolves with the request client.\n   */\n  async requestClient() {\n    if (!this._requestClient) {\n      this._requestClient = new RequestClient()\n    }\n\n    return this._requestClient\n  }\n\n  /**\n   * Runs import test files.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async importTestFiles() {\n    const environmentHandler = this.getConfiguration().getEnvironmentHandler()\n\n    if (!this._profiler) {\n      await environmentHandler.importTestFiles(this.getTestFiles())\n      return\n    }\n\n    for (const testFile of this.getTestFiles()) {\n      const existingRegistrations = this.testRegistrationObjects()\n\n      await this._profiler.measurePhase(\"imports\", async () => {\n        await environmentHandler.importTestFiles([testFile])\n      }, {filePath: testFile})\n      this.assignTestRegistrationOwnership(existingRegistrations, testFile)\n    }\n  }\n\n  /**\n   * Collects package declaration objects by identity.\n   * @param {Set<PackageRegistration>} [registrations] - Accumulated identities.\n   * @returns {Set<PackageRegistration>} - Registration identities.\n   */\n  testRegistrationObjects(registrations = new Set()) {\n    const visit = (/** @type {PackageSuiteDeclaration} */ suite) => {\n      registrations.add(suite)\n      for (const hook of [...suite.hooks.beforeAll, ...suite.hooks.beforeEach, ...suite.hooks.afterEach, ...suite.hooks.afterAll]) {\n        registrations.add(hook)\n      }\n      for (const testDeclaration of suite.tests) registrations.add(testDeclaration)\n      for (const childSuite of suite.suites) visit(childSuite)\n    }\n\n    for (const suite of this.getTestContext().registry.suites) visit(suite)\n\n    return registrations\n  }\n\n  /**\n   * Assigns deterministic ownership to package declarations added by one entry file.\n   * @param {Set<PackageRegistration>} previousRegistrations - Identities present before import.\n   * @param {string} ownerFilePath - Importing entry file.\n   * @returns {void}\n   */\n  assignTestRegistrationOwnership(previousRegistrations, ownerFilePath) {\n    for (const registration of this.testRegistrationObjects()) {\n      if (!previousRegistrations.has(registration)) this._declarationOwners.set(registration, ownerFilePath)\n    }\n  }\n\n  /**\n   * Runs is failed.\n   * @returns {boolean} - Whether failed.\n   */\n  isFailed() { return this._failedTests !== undefined && (this._failedTests > 0 || this._packageResult?.status === \"failed\") }\n\n  /**\n   * Runs get failed tests.\n   * @returns {number} - The failed tests.\n   */\n  getFailedTests() {\n    if (this._failedTests === undefined) throw new Error(\"Tests hasn't been run yet\")\n\n    return this._failedTests\n  }\n\n  /**\n   * Runs get failed test details.\n   * @returns {FailedTestDetail[]} - Failed test details.\n   */\n  getFailedTestDetails() {\n    return this._failedTestDetails\n  }\n\n  /**\n   * Runs persist failed test console outputs to assets.\n   * @param {object} [args] - Options object.\n   * @param {string} [args.assetsPath] - Assets directory path.\n   * @returns {Promise<string[]>} - Written log file paths.\n   */\n  async persistFailedTestConsoleOutputsToAssets({assetsPath = path.join(process.cwd(), \"tmp/screenshots\")} = {}) {\n    const failedTestDetails = this.getFailedTestDetails()\n    const writtenLogPaths = []\n    let createdDirectory = false\n\n    for (let index = 0; index < failedTestDetails.length; index++) {\n      const failedTestDetail = failedTestDetails[index]\n      const consoleOutput = failedTestDetail.consoleOutput\n\n      if (!consoleOutput) continue\n\n      if (!createdDirectory) {\n        await fs.mkdir(assetsPath, {recursive: true})\n        createdDirectory = true\n      }\n\n      const now = new Date()\n      const timestamp = [\n        String(now.getFullYear()),\n        String(now.getMonth() + 1).padStart(2, \"0\"),\n        String(now.getDate()).padStart(2, \"0\"),\n        String(now.getHours()).padStart(2, \"0\"),\n        String(now.getMinutes()).padStart(2, \"0\"),\n        String(now.getSeconds()).padStart(2, \"0\"),\n        String(now.getMilliseconds()).padStart(3, \"0\")\n      ].join(\"\")\n      const slug = toFileSlug(failedTestDetail.fullDescription)\n      const fileName = `${timestamp}-${String(index + 1).padStart(2, \"0\")}-${slug}.console.log`\n      const filePath = path.join(assetsPath, fileName)\n\n      await fs.writeFile(filePath, consoleOutput, \"utf8\")\n      failedTestDetail.consoleLogPath = filePath\n      writtenLogPaths.push(filePath)\n    }\n\n    return writtenLogPaths\n  }\n\n  /**\n   * Runs get successful tests.\n   * @returns {number} - The successful tests.\n   */\n  getSuccessfulTests() {\n    if (this._successfulTests === undefined) throw new Error(\"Tests hasn't been run yet\")\n\n    return this._successfulTests\n  }\n\n  /**\n   * Runs get tests count.\n   * @returns {number} - The tests count.\n   */\n  getTestsCount() {\n    if (this._testsCount === undefined) throw new Error(\"Tests hasn't been run yet\")\n\n    return this._testsCount\n  }\n\n  /**\n   * Runs get executed tests count.\n   * @returns {number} - The executed tests count.\n   */\n  getExecutedTestsCount() {\n    return this._packageResult?.tests.length ?? this._testDurations.length\n  }\n\n  /**\n   * Returns the tests recorded during the run, slowest first.\n   * @param {number} [limit] - Maximum number of tests to return (0 returns all).\n   * @returns {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} - Slowest tests, slowest first.\n   */\n  getSlowestTests(limit = 10) {\n    const sorted = [...this._testDurations].sort((testA, testB) => testB.durationMs - testA.durationMs)\n\n    return limit > 0 ? sorted.slice(0, limit) : sorted\n  }\n\n  /**\n   * Runs prepare.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async prepare() {\n    this.anyTestsFocussed = false\n    this._failedTests = 0\n    this._successfulTests = 0\n    this._testsCount = 0\n    this._abortRemainingTests = false\n    this._failedTestDetails = []\n    this._testDurations = []\n    this._testCompatibility = new WeakMap()\n    this._injectedTests = new WeakSet()\n    this._completedTests = new WeakSet()\n    this._testMetadata = new WeakMap()\n    this._hookMetadata = new WeakMap()\n    this._attemptOutcomes = new WeakMap()\n    this._suiteHookFailures = []\n    this._testsByFullName = new Map()\n    this._packageResult = undefined\n    const context = this.getTestContext()\n    /** @type {string | undefined} */\n    let ownerFilePath\n\n    context.reset({config: true})\n    context.setDeclarationLocator(() => this.captureTestDeclarationLocation(ownerFilePath))\n    const testingConfigPath = this.getConfiguration().getTesting()\n\n    await context.describe(\"\", {databaseCleaning: {transaction: true}}, async () => {\n      if (testingConfigPath) {\n        await this.runProfileSpan({phase: \"testing config/global setup\"}, async () => {\n          await this.getConfiguration().getEnvironmentHandler().importTestingConfigPath()\n        })\n      }\n\n      if (!this._profiler) {\n        await this.importTestFiles()\n      } else {\n        for (const testFile of this.getTestFiles()) {\n          ownerFilePath = testFile\n          const existingRegistrations = this.testRegistrationObjects()\n\n          await this._profiler.measurePhase(\"imports\", async () => {\n            await this.getConfiguration().getEnvironmentHandler().importTestFiles([testFile])\n          }, {filePath: testFile})\n          this.assignTestRegistrationOwnership(existingRegistrations, testFile)\n        }\n      }\n    })\n    ownerFilePath = undefined\n    this.analyzeDeclarations()\n  }\n\n  /**\n   * Captures a test source location without attributing package/facade frames.\n   * @param {string | undefined} ownerFilePath - Importing entry file fallback.\n   * @returns {{filePath?: string, line?: number}} - Declaration location.\n   */\n  captureTestDeclarationLocation(ownerFilePath) {\n    const stack = new Error().stack?.split(\"\\n\") || []\n\n    for (const stackLine of stack) {\n      const match = stackLine.match(/(?:\\(|\\s)(file:\\/\\/.*?|\\/[^\"]*?):(\\d+):(\\d+)\\)?$/u)\n      if (!match) continue\n\n      let filePath = match[1]\n      if (filePath.startsWith(\"file://\")) {\n        try {\n          filePath = fileURLToPath(filePath)\n        } catch {\n          continue\n        }\n      }\n      const resolvedFilePath = path.resolve(filePath)\n      const portablePath = resolvedFilePath.replaceAll(path.sep, \"/\")\n\n      if (portablePath.endsWith(\"/src/testing/test-runner.js\")) continue\n      if (portablePath.endsWith(\"/src/testing/test.js\")) continue\n      if (portablePath.includes(\"/node_modules/@velocious/testing/\")) continue\n\n      return {filePath: resolvedFilePath, line: Number(match[2])}\n    }\n\n    return ownerFilePath ? {filePath: ownerFilePath} : {}\n  }\n\n  /**\n   * Runs are any tests focussed.\n   * @returns {boolean} - Whether any tests focussed.\n   */\n  areAnyTestsFocussed() {\n    if (this.anyTestsFocussed === undefined) {\n      throw new Error(\"Hasn't been detected yet\")\n    }\n\n    return this.anyTestsFocussed\n  }\n\n  /**\n   * Runs run.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  /**\n   * Records an asynchronous crash (an unhandled promise rejection detached from\n   * any await, e.g. a `void connection.afterCommit(async () => broadcast(...))`\n   * frontend-model publish — or a synchronous throw inside a detached callback\n   * such as a driver socket or timer callback) as a real, visible, attributed\n   * test failure.\n   *\n   * Without this, such a rejection/exception has no handler, so on modern Node\n   * the process is TERMINATED — the run ends with no reported failures and CI\n   * just sees a crashed/retried shard with an empty result (the recurring\n   * \"silent test-runner death\": invisible and impossible to diagnose). Turning\n   * it into a failure makes the run go red with something debuggable instead of\n   * vanishing.\n   * @param {\"uncaughtException\" | \"unhandledRejection\"} kind - Async-crash kind.\n   * @param {unknown} reason - Rejection reason or thrown error.\n   * @returns {void}\n   */\n  recordAsyncCrash(kind, reason) {\n    const error = reason instanceof Error ? reason : new Error(`${kind}: ${String(reason)}`)\n    const near = this._lastTestContext\n    const attribution = near ? `, near test: ${near.fullDescription} (${near.filePath}:${near.line})` : \"\"\n\n    this._failedTests = (this._failedTests || 0) + 1\n    this._failedTestDetails.push({\n      fullDescription: `<${kind} during test run${attribution}>`,\n      filePath: near ? near.filePath : \"<test runner>\",\n      line: near ? near.line : 0,\n      error,\n      consoleOutput: undefined\n    })\n\n    console.error(picocolors.red(`\\n[test-runner] ${kind} during the test run — this would otherwise terminate the process silently and surface only as a crashed/retried shard with zero reported failures.${attribution}`))\n    console.error(error)\n  }\n\n  /**\n   * Records a cleanup failure after timeout handling has begun.\n   * @param {unknown} reason - Detached cleanup rejection.\n   * @param {string} cleanupName - Cleanup operation name.\n   * @param {Set<Error>} [recordedErrors] - Attempt-owned cleanup errors already reported.\n   * @returns {void}\n   */\n  recordTimeoutCleanupFailure(reason, cleanupName, recordedErrors) {\n    const error = reason instanceof Error ? reason : new Error(`${cleanupName} cleanup failed: ${String(reason)}`)\n\n    if (recordedErrors) {\n      // Multiple bounded observers can receive the same detached cleanup rejection.\n      if (recordedErrors.has(error)) return\n      recordedErrors.add(error)\n    }\n\n    const near = this._lastTestContext\n    const attribution = near ? `, near test: ${near.fullDescription} (${near.filePath}:${near.line})` : \"\"\n\n    this._failedTests = (this._failedTests || 0) + 1\n    this._failedTestDetails.push({\n      fullDescription: `<${cleanupName} emergency cleanup failure${attribution}>`,\n      filePath: near ? near.filePath : \"<test runner>\",\n      line: near ? near.line : 0,\n      error,\n      consoleOutput: undefined\n    })\n\n    console.error(picocolors.red(`\\n[test-runner] ${cleanupName} cleanup failed after timeout handling began.${attribution}`))\n    console.error(error)\n  }\n\n  async run() {\n    /**\n     * Handles a process-level unhandled rejection during the run.\n     * @param {unknown} reason - Rejection reason.\n     * @returns {void}\n     */\n    const onUnhandledRejection = (reason) => {\n      // If a test attached its OWN unhandledRejection listener, it is\n      // intentionally observing/triggering the rejection (e.g. beacon\n      // error-reporting-spec.js) — Node dispatches to EVERY listener, so also\n      // failing the suite here would break those tests. Defer to the test's\n      // handler; only treat a rejection as a silent-death crash when ours is the\n      // sole listener (no persistent framework listener exists to mask this).\n      if (process.listenerCount(\"unhandledRejection\") > 1) return\n\n      this.recordAsyncCrash(\"unhandledRejection\", reason)\n    }\n\n    /**\n     * Handles a process-level uncaught exception during the run — a\n     * synchronous throw inside a detached callback (driver socket, timer,\n     * event emitter) that no test await observes. Same silent-death mode as\n     * unhandled rejections: without a handler the process dies mid-run and CI\n     * sees a crashed shard with zero reported failures.\n     * @param {unknown} error - Thrown error.\n     * @returns {void}\n     */\n    const onUncaughtException = (error) => {\n      // Mirror the unhandledRejection deferral: a test observing/triggering\n      // uncaught exceptions with its own listener owns them.\n      if (process.listenerCount(\"uncaughtException\") > 1) return\n\n      this.recordAsyncCrash(\"uncaughtException\", error)\n    }\n\n    process.on(\"unhandledRejection\", onUnhandledRejection)\n    process.on(\"uncaughtException\", onUncaughtException)\n\n    try {\n      await this.runPackageTests()\n\n      // A rejection scheduled by the final test (a detached rejected promise,\n      // or an afterCommit callback rejecting as the suite drains) is reported\n      // by Node on a LATER turn. Drain a few turns while the handler is still\n      // attached so those late rejections are recorded instead of escaping to\n      // the default crash path after cleanup.\n      for (let drainTurn = 0; drainTurn < 3; drainTurn++) {\n        await new Promise((resolve) => setImmediate(resolve))\n      }\n    } finally {\n      process.off(\"unhandledRejection\", onUnhandledRejection)\n      process.off(\"uncaughtException\", onUncaughtException)\n    }\n  }\n\n  /**\n   * Runs run after alls for active scopes.\n   * @returns {Promise<void>} - Resolves when cleanup hooks finish.\n   */\n  async runAfterAllsForActiveScopes() {\n    const failureStart = this._suiteHookFailures.length\n\n    await this._packageRunner?.cleanupActiveSuites()\n    this.throwAfterAllFailures(this._suiteHookFailures.slice(failureStart))\n  }\n\n  /** Builds declaration metadata used only by framework adapters and projections. */\n  analyzeDeclarations() {\n    const visit = (/** @type {PackageSuiteDeclaration} */ suite, /** @type {PackageSuiteDeclaration[]} */ ancestors, /** @type {string | undefined} */ parentProfileScopeId) => {\n      const suites = [...ancestors, suite]\n      const descriptions = suites.map((entry) => entry.name).filter((name) => name !== \"\")\n      const ownerFilePath = this._declarationOwners.get(suite) ?? suite.location.filePath\n      const profileScopeId = this._profiler?.scopeId(suite, {\n        descriptions,\n        filePath: ownerFilePath,\n        line: suite.location.line,\n        parentId: parentProfileScopeId\n      })\n\n      for (const hooks of Object.values(suite.hooks)) {\n        hooks.forEach((hook, declarationIndex) => {\n          this._hookMetadata.set(hook, {\n            declarationIndex,\n            declarationScopeId: profileScopeId,\n            ownerFilePath: this._declarationOwners.get(hook) ?? hook.location.filePath ?? ownerFilePath\n          })\n        })\n      }\n\n      for (const testDeclaration of suite.tests) {\n        const fullDescription = this.buildFullDescription(descriptions, testDeclaration.name)\n        const declarations = this._testsByFullName.get(fullDescription) || []\n\n        declarations.push(testDeclaration)\n        this._testsByFullName.set(fullDescription, declarations)\n        this._testMetadata.set(testDeclaration, {\n          descriptions,\n          testDescription: testDeclaration.name,\n          fullDescription,\n          ownerFilePath: this._declarationOwners.get(testDeclaration) ?? testDeclaration.location.filePath ?? ownerFilePath,\n          suites\n        })\n        const legacyTestData = this._legacyFixtureDataByFullName?.get(fullDescription)\n        if (legacyTestData) {\n          this._testCompatibility.set(testDeclaration, {\n            testArgs: this._testArguments.copy(testDeclaration),\n            testData: legacyTestData\n          })\n        }\n        this._testsCount++\n        if (testDeclaration.state === \"run\" && (testDeclaration.focus || suites.some((entry) => entry.focus))) {\n          this.anyTestsFocussed = true\n        }\n      }\n\n      for (const childSuite of suite.suites) visit(childSuite, suites, profileScopeId)\n    }\n\n    for (const suite of this.getTestContext().registry.suites) visit(suite, [], undefined)\n  }\n\n  /**\n   * Gets package hook compatibility metadata.\n   * @param {PackageHookDeclaration} hook - Package hook declaration.\n   * @returns {{declarationIndex: number, declarationScopeId: string | undefined, ownerFilePath: string | undefined}} - Hook metadata.\n   */\n  hookMetadata(hook) {\n    return this._hookMetadata.get(hook) || {declarationIndex: 0, declarationScopeId: undefined, ownerFilePath: hook.location.filePath}\n  }\n\n  /**\n   * Gets package test compatibility metadata.\n   * @param {PackageTestDeclaration} test - Package test declaration.\n   * @returns {{descriptions: string[], testDescription: string, fullDescription: string, ownerFilePath: string | undefined, suites: PackageSuiteDeclaration[]}} - Declaration metadata.\n   */\n  testMetadata(test) {\n    const metadata = this._testMetadata.get(test)\n    if (!metadata) throw new Error(`Missing package test metadata: ${test.name}`)\n    return metadata\n  }\n\n  /**\n   * Gets stable compatibility data for a package declaration.\n   * @param {PackageTestDeclaration} test - Package test declaration.\n   * @returns {{testArgs: TestArgs, testData: TestData}} - Stable compatibility data.\n   */\n  testData(test) {\n    let compatibility = this._testCompatibility.get(test)\n\n    if (!compatibility) {\n      const testArgs = this._testArguments.copy(test)\n      const metadata = this.testMetadata(test)\n      const testData = {\n        args: testArgs,\n        declaration: test,\n        filePath: test.location.filePath,\n        function: test.callback,\n        line: test.location.line,\n        ownerFilePath: metadata.ownerFilePath\n      }\n      compatibility = {testArgs, testData}\n      this._testCompatibility.set(test, compatibility)\n    }\n\n    return compatibility\n  }\n\n  /**\n   * Injects framework collaborators into stable compatibility data once.\n   * @param {PackageTestDeclaration} test - Package test declaration.\n   * @returns {Promise<{testArgs: TestArgs, testData: TestData}>} - Injected compatibility data.\n   */\n  async testCompatibility(test) {\n    const compatibility = this.testData(test)\n\n    if (!this._injectedTests.has(test)) {\n      await this._testArguments.inject(compatibility.testArgs)\n      this._injectedTests.add(test)\n    }\n\n    return compatibility\n  }\n\n  /**\n   * Records a raw framework attempt outcome.\n   * @param {PackageTestDeclaration} test - Package test declaration.\n   * @param {number} attemptNumber - One-based attempt number.\n   * @param {{abortRemainingTests: boolean, error: ReturnType<typeof JSON.parse>, failed: boolean}} outcome - Raw attempt outcome.\n   * @returns {void}\n   */\n  recordAttemptOutcome(test, attemptNumber, outcome) {\n    const outcomes = this._attemptOutcomes.get(test) || new Map()\n    outcomes.set(attemptNumber, outcome)\n    this._attemptOutcomes.set(test, outcomes)\n    if (outcome.abortRemainingTests) this._abortRemainingTests = true\n  }\n\n  /**\n   * Gets a raw framework attempt outcome.\n   * @param {PackageTestDeclaration} test - Package test declaration.\n   * @param {number} attemptNumber - One-based attempt number.\n   * @returns {{abortRemainingTests: boolean, error: ReturnType<typeof JSON.parse>, failed: boolean} | undefined} - Raw attempt outcome.\n   */\n  attemptOutcome(test, attemptNumber) { return this._attemptOutcomes.get(test)?.get(attemptNumber) }\n\n  /**\n   * Records a raw suite-hook failure.\n   * @param {object} failure - Suite-hook failure.\n   * @param {PackageSuiteDeclaration} failure.suite - Owning package suite.\n   * @param {\"beforeAll\" | \"afterAll\"} failure.phase - Hook phase.\n   * @param {ReturnType<typeof JSON.parse>} failure.error - Raw hook failure.\n   * @returns {void}\n   */\n  recordSuiteHookFailure(failure) { this._suiteHookFailures.push(failure) }\n\n  /**\n   * Gets the raw ancestor setup failure for a package test.\n   * @param {PackageTestDeclaration} test - Package test declaration.\n   * @returns {ReturnType<typeof JSON.parse>} - Raw setup failure.\n   */\n  setupFailureFor(test) {\n    const suites = this.testMetadata(test).suites\n    return this._suiteHookFailures.find((failure) => failure.phase === \"beforeAll\" && suites.includes(failure.suite))?.error\n  }\n\n  /**\n   * Finds the next incomplete declaration with a package full name.\n   * @param {string} fullName - Package full name.\n   * @returns {PackageTestDeclaration | undefined} - Next matching declaration.\n   */\n  findTestDeclaration(fullName) {\n    return this._testsByFullName.get(fullName)?.find((test) => !this._completedTests.has(test))\n  }\n\n  /**\n   * Marks a package declaration complete.\n   * @param {PackageTestDeclaration} test - Completed declaration.\n   * @returns {void}\n   */\n  completeTestDeclaration(test) { this._completedTests.add(test) }\n\n  /**\n   * Gets the effective package retry count.\n   * @param {PackageTestDeclaration} test - Package test declaration.\n   * @returns {number} - Effective retry count.\n   */\n  retryCount(test) {\n    const value = test.options.retries ?? test.options.retry ?? this.getTestContext().config.retries\n    return typeof value === \"number\" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0\n  }\n\n  /**\n   * Normalizes retry inputs for the package execution boundary while retaining\n   * the declarations' original public options after the run.\n   * @returns {() => void} - Restores original declaration options.\n   */\n  normalizePackageRetriesForExecution() {\n    /** @type {PackageRetryOptionRestoration[]} */\n    const restorations = []\n    /**\n     * Normalizes declarations in one suite.\n     * @param {PackageSuiteDeclaration} suite - Suite whose tests are normalized.\n     */\n    const visit = (suite) => {\n      for (const test of suite.tests) {\n        // Capture compatibility arguments before temporarily adapting package\n        // execution options so callbacks retain their declared values/identity.\n        this.testData(test)\n        restorations.push({\n          hadRetries: Object.hasOwn(test.options, \"retries\"),\n          options: test.options,\n          retries: test.options.retries\n        })\n        test.options.retries = this.retryCount(test)\n      }\n\n      for (const childSuite of suite.suites) visit(childSuite)\n    }\n\n    for (const suite of this.getTestContext().registry.suites) visit(suite)\n\n    return () => {\n      for (const restoration of restorations) {\n        if (restoration.hadRetries) restoration.options.retries = restoration.retries\n        else delete restoration.options.retries\n      }\n    }\n  }\n\n  /**\n   * Records one completed test duration.\n   * @param {{durationMs: number, filePath: string, fullDescription: string, line: number}} duration - Completed test duration.\n   * @returns {void}\n   */\n  recordTestDuration(duration) { this._testDurations.push(duration) }\n\n  /** Records one successful package result. */\n  recordSuccessfulTest() { this._successfulTests++ }\n\n  /**\n   * Records one failed package test in the legacy result projection.\n   * @param {object} args - Failed test metadata.\n   * @param {string[]} args.descriptions - Parent descriptions.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Raw failure.\n   * @param {string} args.consoleOutput - Captured console output.\n   * @param {TestData} args.testData - Compatibility test data.\n   * @param {string} args.testDescription - Test description.\n   * @returns {void}\n   */\n  recordFailedTest({descriptions, error, consoleOutput, testData, testDescription}) {\n    this._failedTests++\n    this._failedTestDetails.push({\n      fullDescription: this.buildFullDescription(descriptions, testDescription),\n      filePath: testData.filePath,\n      line: testData.line,\n      error,\n      consoleOutput: consoleOutput || undefined\n    })\n  }\n\n  /**\n   * Stores the completed package result.\n   * @param {import(\"@velocious/testing/runner\").TestRunResult} result - Package result.\n   * @returns {void}\n   */\n  recordPackageResult(result) { this._packageResult = result }\n\n  /**\n   * Runs the package kernel with Velocious framework adapters.\n   * @returns {Promise<void>} - Resolves after execution and teardown.\n   */\n  async runPackageTests() {\n    const environmentHandler = this.getConfiguration().getEnvironmentHandler()\n    environmentHandler.installSharedTransactionCoordinatorOwnerStorage(this._sharedTransactionCoordinatorOwnerStorage)\n    environmentHandler.installTestDatabaseAccessScopeStorage(this._testDatabaseAccessScopeStorage)\n    this._packageRunner = new PackageTestRunner({\n      context: this.getTestContext(),\n      includeTags: this._includeTags,\n      excludeTags: [...this.getExcludeTagSet(), ...(this.isBrowserTestMode() ? [] : [\"browser-only\"])],\n      examples: this.getExamplePatterns(),\n      lineFilters: this.getLineFilters(),\n      includeTagMode: \"any\",\n      focusedTestsBypassIncludeTags: true,\n      omitEmptySuiteNames: true,\n      attemptExecutorOwnsTimeout: true,\n      attemptExecutor: (input) => this._attemptExecutor.execute(input),\n      testArgumentResolver: (input) => this._testArguments.resolve(input),\n      suiteHookExecutor: (input) => this._suiteHookExecutor.execute(input),\n      reporter: this._runnerReporter\n    })\n    const failureStart = this._suiteHookFailures.length\n    const restoreRetryOptions = this.normalizePackageRetriesForExecution()\n    let result\n\n    try {\n      try {\n        result = await this._packageRunner.run()\n      } catch (error) {\n        if (!(error instanceof AbortRemainingTestsError)) throw error\n\n        const afterAll = this.afterAllOutcome(this._suiteHookFailures.slice(failureStart))\n        if (afterAll.failed) this.recordTimeoutCleanupFailure(afterAll.error, \"afterAll\")\n        return\n      }\n\n      this.recordPackageResult(result)\n      this.throwAfterAllFailures(this._suiteHookFailures.slice(failureStart))\n    } finally {\n      restoreRetryOptions()\n    }\n  }\n\n  /**\n   * Aggregates raw after-all failures without using error truthiness.\n   * @param {Array<{phase: \"beforeAll\" | \"afterAll\", error: ReturnType<typeof JSON.parse>}>} failures - Hook failures.\n   * @returns {{failed: false} | {failed: true, error: ReturnType<typeof JSON.parse>}} - Explicit afterAll outcome.\n   */\n  afterAllOutcome(failures) {\n    const afterAllErrors = failures.filter((failure) => failure.phase === \"afterAll\").map((failure) => failure.error)\n\n    if (afterAllErrors.length === 0) return {failed: false}\n    if (afterAllErrors.length === 1) return {failed: true, error: afterAllErrors[0]}\n    return {\n      failed: true,\n      error: new AggregateError(afterAllErrors, \"Multiple active afterAll scopes failed\", {cause: afterAllErrors[0]})\n    }\n  }\n\n  /**\n   * Throws one raw or aggregated after-all failure.\n   * @param {Array<{phase: \"beforeAll\" | \"afterAll\", error: ReturnType<typeof JSON.parse>}>} failures - Hook failures.\n   * @returns {void}\n   */\n  throwAfterAllFailures(failures) {\n    const afterAll = this.afterAllOutcome(failures)\n\n    if (afterAll.failed) throw afterAll.error\n  }\n\n  /**\n   * Compatibility helper for focused framework lifecycle specs. It converts an\n   * explicit legacy fixture into isolated package declarations; the package\n   * runner remains the sole execution engine.\n   * @param {object} args - Legacy fixture arguments.\n   * @param {TestsArgument} args.tests - Fixture tree.\n   * @returns {Promise<void>} - Resolves after package execution.\n   */\n  async runTests({tests}) {\n    const context = createTestContext()\n    const originalContext = this._context\n    context.configureTests({\n      consoleOutput: originalContext.config.consoleOutput,\n      defaultTimeoutMs: originalContext.config.defaultTimeoutMs,\n      excludeTags: originalContext.config.excludeTags,\n      failedConsoleOutputMaxLines: originalContext.config.failedConsoleOutputMaxLines,\n      retries: originalContext.config.retries\n    })\n    this._context = context\n    this._testsCount = 0\n    this._testCompatibility = new WeakMap()\n    this._injectedTests = new WeakSet()\n    this._completedTests = new WeakSet()\n    this._testMetadata = new WeakMap()\n    this._hookMetadata = new WeakMap()\n    this._attemptOutcomes = new WeakMap()\n    this._suiteHookFailures = []\n    this._testsByFullName = new Map()\n    this._legacyFixtureDataByFullName = new Map()\n    context.setDeclarationLocator(() => this._legacyFixtureLocation)\n    this.declareLegacyFixture(context, \"\", tests, [])\n    this.analyzeDeclarations()\n\n    try {\n      await this.runPackageTests()\n    } finally {\n      this._context = originalContext\n    }\n  }\n\n  /**\n   * Declares an isolated legacy-shaped test fixture into a package context.\n   * @param {PackageTestContext} context - Isolated package context.\n   * @param {string} name - Suite name.\n   * @param {TestsArgument} scope - Legacy fixture scope.\n   * @param {string[]} descriptions - Ancestor descriptions.\n   * @returns {void}\n   */\n  declareLegacyFixture(context, name, scope, descriptions) {\n    this._legacyFixtureLocation = {filePath: scope.filePath, line: scope.line}\n    context.describe(name, scope.args || {}, () => {\n      for (const hook of scope.beforeAlls || []) context.beforeAll(hook.callback)\n      for (const hook of scope.beforeEaches || []) context.beforeEach(hook.callback)\n      for (const hook of scope.afterEaches || []) context.afterEach(hook.callback)\n      for (const hook of scope.afterAlls || []) context.afterAll(hook.callback)\n      const nextDescriptions = name === \"\" ? descriptions : [...descriptions, name]\n      for (const [testName, testData] of Object.entries(scope.tests || {})) {\n        this._legacyFixtureLocation = {filePath: testData.filePath, line: testData.line}\n        this._legacyFixtureDataByFullName?.set(this.buildFullDescription(nextDescriptions, testName), testData)\n        context.it(testName, testData.args, testData.function)\n      }\n      for (const [suiteName, childScope] of Object.entries(scope.subs || {})) {\n        this.declareLegacyFixture(context, suiteName, childScope, nextDescriptions)\n      }\n    })\n  }\n\n  /**\n   * Runs emit event.\n   * @param {string} eventName - Event name.\n   * @param {object} payload - Event payload.\n   * @returns {Promise<void>} - Resolves when all listeners complete.\n   */\n  async emitEvent(eventName, payload) {\n    await this._runnerReporter.emitEvent(eventName, payload)\n  }\n\n  /**\n   * Runs print rerun command.\n   * @param {object} args - Options object.\n   * @param {string[]} args.descriptions - Description stack.\n   * @param {string} args.testDescription - Test description.\n   * @param {TestData} args.testData - Test data.\n   * @param {string} args.leftPadding - Left padding.\n   * @returns {void} - No return value.\n   */\n  printRerunCommand({descriptions, testDescription, testData, leftPadding}) {\n    const rerun = this.buildRerunCommand({descriptions, testDescription, testData})\n\n    if (rerun) {\n      console.error(`${leftPadding}  Re-run: ${rerun}`)\n    }\n  }\n\n  /**\n   * Runs build rerun command.\n   * @param {object} args - Options object.\n   * @param {string[]} args.descriptions - Description stack.\n   * @param {string} args.testDescription - Test description.\n   * @param {TestData} args.testData - Test data.\n   * @returns {string | undefined} - Rerun command.\n   */\n  buildRerunCommand({descriptions, testDescription, testData}) {\n    const baseCommand = \"npx velocious test\"\n    const filePath = testData.filePath\n    const line = testData.line\n\n    if (filePath && line) {\n      const relativePath = path.relative(process.cwd(), filePath)\n      return `${baseCommand} ${relativePath}:${line}`\n    }\n\n    const fullDescription = this.buildFullDescription(descriptions, testDescription)\n\n    if (fullDescription) {\n      return `${baseCommand} --example ${JSON.stringify(fullDescription)}`\n    }\n\n    return undefined\n  }\n\n  /**\n   * Runs build console output.\n   * @param {AttemptConsoleOutput[]} attemptConsoleOutputs - Attempt output entries.\n   * @returns {string} - Combined console output.\n   */\n  buildConsoleOutput(attemptConsoleOutputs) {\n    if (attemptConsoleOutputs.length === 0) return \"\"\n    if (attemptConsoleOutputs.length === 1) return attemptConsoleOutputs[0].output\n\n    return attemptConsoleOutputs.map((attemptConsoleOutput) => {\n      return `--- Attempt ${attemptConsoleOutput.attemptNumber} ---\\n${attemptConsoleOutput.output}`\n    }).join(\"\\n\")\n  }\n\n  /**\n   * Runs get failed console output max lines.\n   * @returns {number} - Maximum failed console lines.\n   */\n  getFailedConsoleOutputMaxLines() {\n    const maxLines = testConfig.failedConsoleOutputMaxLines\n\n    if (typeof maxLines !== \"number\" || !Number.isFinite(maxLines)) return 200\n\n    return Math.max(0, Math.floor(maxLines))\n  }\n\n  /**\n   * Runs truncate failed console output lines.\n   * @param {string} consoleOutput - Console output.\n   * @returns {string[]} - Lines for inline output.\n   */\n  truncateFailedConsoleOutputLines(consoleOutput) {\n    const lines = consoleOutput.split(\"\\n\")\n    const maxLines = this.getFailedConsoleOutputMaxLines()\n\n    if (maxLines === 0) return []\n    if (lines.length <= maxLines) return lines\n\n    const omittedLines = lines.length - maxLines\n    const plural = omittedLines === 1 ? \"\" : \"s\"\n\n    return [\n      `... ${omittedLines} console output line${plural} omitted ...`,\n      ...lines.slice(-maxLines)\n    ]\n  }\n\n  /**\n   * Runs print failed console output.\n   * @param {object} args - Options object.\n   * @param {string} args.consoleOutput - Console output.\n   * @param {string} args.leftPadding - Left padding.\n   * @returns {void} - No return value.\n   */\n  printFailedConsoleOutput({consoleOutput, leftPadding}) {\n    if (testConfig.consoleOutput !== \"failure\") return\n    if (!consoleOutput) return\n\n    const lines = this.truncateFailedConsoleOutputLines(consoleOutput)\n\n    if (lines.length === 0) return\n\n    console.error(picocolors.red(`${leftPadding}  Console output:`))\n\n    for (const line of lines) {\n      console.error(picocolors.red(`${leftPadding}    ${line}`))\n    }\n  }\n\n}\n"]}