velocious 1.0.698 → 1.0.700

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

@@ -7,6 +7,7 @@ import { slowestTestResults } from "@velocious/testing/reporters";
 import { TestRunner as PackageTestRunner } from "@velocious/testing/runner";
 import Application from "../../src/application.js";
 import RequestClient from "./request-client.js";
+import Tenant from "../tenants/tenant.js";
 import picocolors from "picocolors";
 import restArgsError from "../utils/rest-args-error.js";
 import { testConfig } from "./test.js";
@@ -16,6 +17,7 @@ import { SHARED_TRANSACTION_BROKER_ENV } from "./shared-transaction-proxy-driver
 import VelociousAttemptExecutor from "./velocious-attempt-executor.js";
 import VelociousRunnerReporter, { AbortRemainingTestsError } from "./velocious-runner-reporter.js";
 import VelociousSuiteHookExecutor from "./velocious-suite-hook-executor.js";
+import TestTenantDatabasePool from "./test-tenant-database-pool.js";
 import VelociousTestArguments from "./velocious-test-arguments.js";
 /** @typedef {typeof defaultTestContext} PackageTestContext */
 /** @typedef {(typeof defaultTestContext.registry.suites)[number]} PackageSuiteDeclaration */
@@ -45,6 +47,18 @@ import VelociousTestArguments from "./velocious-test-arguments.js";
  * @property {number} [timeoutSeconds] - Timeout in seconds for the test.
  * @property {string} [type] - Test type identifier.
  * @property {(args: {databaseIdentifier: string, tenant: object}) => Promise<void>} [registerTransactionalTenant] - Registers one resolved tenant database transaction for this attempt.
+ * @property {(args?: {databaseIdentifier?: string, tenant?: object}) => Promise<TestTenantPoolLease>} [acquireTestTenant] - Leases one member of the configured test tenant database pool for this attempt (opt-in `testTenantPools` configuration).
+ * @property {(args: {databaseIdentifier: string, tenant: object}) => void} [registerTenantForCleanup] - Registers one active tenant database for the framework-owned end-of-attempt cleanup (drop + provider hooks) without hand-rolled afterEach bookkeeping.
+ */
+/**
+ * TestTenantPoolLease type (re-exported from the pool for TestArgs consumers).
+ * @typedef {import("./test-tenant-database-pool.js").TestTenantPoolLease} TestTenantPoolLease
+ */
+/**
+ * TenantCleanupRegistration type.
+ * @typedef {object} TenantCleanupRegistration
+ * @property {string} databaseIdentifier - Tenant database identifier to drop at attempt end.
+ * @property {ReturnType<typeof JSON.parse>} tenant - Tenant descriptor whose database must be dropped.
  */
 /**
  * BrowserDummyConnectionRegistration type.
@@ -192,6 +206,10 @@ export default class TestRunner {
         this._setupFiles = setupFiles || [];
         this._timeoutMs = timeoutMs;
         this._abortRemainingTests = false;
+        /** @type {Map<string, TestTenantDatabasePool>} */
+        this._testTenantPools = new Map();
+        /** @type {Promise<void> | undefined} */
+        this._testTenantPoolTeardownPromise = undefined;
         this._failedTests = 0;
         this._successfulTests = 0;
         this._testsCount = 0;
@@ -581,6 +599,71 @@ export default class TestRunner {
         }
         return this._application;
     }
+    /**
+     * Resolves the pool identifier when exactly one `testTenantPools` entry is
+     * configured, so `acquireTestTenant()` can omit it. Ambiguous or missing
+     * configuration fails loudly instead of guessing.
+     * @returns {string} - The single configured pool identifier.
+     */
+    singleTestTenantPoolIdentifier() {
+        const identifiers = Object.keys(this.getConfiguration().getTestTenantPools() || {});
+        if (identifiers.length === 0) {
+            throw new Error("acquireTestTenant requires a databaseIdentifier when no testTenantPools configuration is present");
+        }
+        if (identifiers.length > 1) {
+            throw new Error(`acquireTestTenant requires a databaseIdentifier when multiple testTenantPools are configured: ${identifiers.join(", ")}`);
+        }
+        return identifiers[0];
+    }
+    /**
+     * Returns the test tenant database pool for one configured `testTenantPools`
+     * identifier, creating it on first use. Throws when the identifier has no pool
+     * configuration — the pool stays strictly opt-in.
+     * @param {string} databaseIdentifier - Tenant database identifier.
+     * @returns {TestTenantDatabasePool} - The runner-owned pool.
+     */
+    getTestTenantPool(databaseIdentifier) {
+        const existingPool = this._testTenantPools.get(databaseIdentifier);
+        if (existingPool)
+            return existingPool;
+        const poolConfiguration = this.getConfiguration().getTestTenantPools()?.[databaseIdentifier];
+        if (!poolConfiguration) {
+            throw new Error(`No testTenantPools configuration for database identifier: ${databaseIdentifier}`);
+        }
+        const pool = new TestTenantDatabasePool({
+            configuration: this.getConfiguration(),
+            databaseIdentifier,
+            poolConfiguration
+        });
+        this._testTenantPools.set(databaseIdentifier, pool);
+        return pool;
+    }
+    /**
+     * Tears down every test tenant database pool created during this run, exactly once.
+     * Safe to call from afterAll-style teardown and from the runner's own cleanup; the
+     * same promise is shared by concurrent callers.
+     * @returns {Promise<void>} - Resolves after all pools dropped their databases.
+     */
+    teardownTestTenantPools() {
+        this._testTenantPoolTeardownPromise ??= (async () => {
+            const pools = [...this._testTenantPools.values()];
+            this._testTenantPools.clear();
+            const errors = [];
+            for (const pool of pools) {
+                try {
+                    await pool.teardown();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            if (errors.length === 1)
+                throw errors[0];
+            if (errors.length > 1)
+                throw new AggregateError(errors, "Failed to tear down test tenant database pools");
+        })();
+        return this._testTenantPoolTeardownPromise;
+    }
     /**
      * Registers each non-tenant per-test connection as a dynamic candidate for in-process
      * request sharing. The pool evaluates transaction state when each request is dispatched,
@@ -766,6 +849,50 @@ export default class TestRunner {
         if (errors.length > 1)
             throw new AggregateError(errors, "Failed to clean up a transactional tenant test connection");
     }
+    /**
+     * Registers one tenant database for framework-owned end-of-attempt cleanup. The
+     * registration drops the tenant's database through the provider's `dropDatabase`
+     * hook (or the framework default) after the attempt's afterEach hooks and
+     * transactional tenant rollbacks finished, so consuming apps do not hand-roll a
+     * Map/afterEach bookkeeping layer for DDL that a test transaction cannot roll back.
+     * @param {{databaseIdentifier: string, tenant: object}} args - Tenant database identifier and tenant descriptor to drop at attempt end.
+     * @param {TenantCleanupRegistration[]} registrations - Current attempt registrations.
+     * @returns {void} - No return value.
+     */
+    registerTenantForCleanup({ databaseIdentifier, tenant, ...restArgs }, registrations) {
+        restArgsError(restArgs);
+        if (!databaseIdentifier)
+            throw new Error("registerTenantForCleanup requires a databaseIdentifier");
+        if (!tenant)
+            throw new Error("registerTenantForCleanup requires a tenant");
+        const databaseConfiguration = this.getConfiguration().resolveDatabaseConfiguration(databaseIdentifier, tenant);
+        if (!databaseConfiguration.tenantOnly) {
+            throw new Error(`registerTenantForCleanup requires a tenantOnly database: ${databaseIdentifier}`);
+        }
+        registrations.push({ databaseIdentifier, tenant });
+    }
+    /**
+     * Drops every tenant database registered for this attempt, in registration order.
+     * Each drop is attempted even when an earlier one failed; failures are surfaced
+     * (single error or AggregateError), never swallowed.
+     * @param {TenantCleanupRegistration[]} registrations - Attempt-owned registrations.
+     * @returns {Promise<void>} - Resolves after all registered tenants were dropped.
+     */
+    async cleanupTenantRegistrations(registrations) {
+        const errors = [];
+        for (const { databaseIdentifier, tenant } of registrations) {
+            try {
+                await Tenant.drop({ identifier: databaseIdentifier, tenant, configuration: this.getConfiguration() });
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, "Failed to drop tenant databases registered for cleanup");
+    }
     /**
      * Selects the current non-tenant connections eligible for shared transaction work.
      * @param {{transactionsOnly: boolean}} args - Selection options.
@@ -1265,6 +1392,12 @@ export default class TestRunner {
         finally {
             process.off("unhandledRejection", onUnhandledRejection);
             process.off("uncaughtException", onUncaughtException);
+            try {
+                await this.teardownTestTenantPools();
+            }
+            catch (error) {
+                this.recordTimeoutCleanupFailure(error, "test tenant pool teardown");
+            }
         }
     }
     /**
@@ -1274,6 +1407,12 @@ export default class TestRunner {
     async runAfterAllsForActiveScopes() {
         const failureStart = this._suiteHookFailures.length;
         await this._packageRunner?.cleanupActiveSuites();
+        try {
+            await this.teardownTestTenantPools();
+        }
+        catch (error) {
+            this.recordTimeoutCleanupFailure(error, "test tenant pool teardown");
+        }
         this.throwAfterAllFailures(this._suiteHookFailures.slice(failureStart));
     }
     /** Builds declaration metadata used only by framework adapters and projections. */
@@ -1769,4 +1908,4 @@ export default class TestRunner {
         }
     }
 }
-//# 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 { slowestTestResults } from \"@velocious/testing/reporters\"\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\nconst testingPackageDirectory = path.dirname(fileURLToPath(import.meta.resolve(\"@velocious/testing/package.json\")))\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   * @param {number} [args.retries] - Default retry count.\n   * @param {string[]} [args.setupFiles] - Setup files imported before test files.\n   * @param {number} [args.timeoutMs] - Default lifecycle timeout.\n   */\n  constructor({configuration, context = defaultTestContext, excludeTags, includeTags, testFiles, lineFilters, examplePatterns, profiler, retries, setupFiles, timeoutMs, ...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._retries = retries\n    this._setupFiles = setupFiles || []\n    this._timeoutMs = timeoutMs\n    this._abortRemainingTests = false\n\n    this._failedTests = 0\n    this._successfulTests = 0\n    this._testsCount = 0\n    this._failedTestDetails = []\n    /** @type {import(\"@velocious/testing/runner\").NonRunTestResult[]} */\n    this._notRunTestDetails = []\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   * Counts selected tests blocked by a terminal resource.\n   * @returns {number} - Selected tests not executed because a shared resource failed.\n   */\n  getNotRunTests() { return this._notRunTestDetails.length }\n\n  /**\n   * Returns runtime non-run attribution.\n   * @returns {import(\"@velocious/testing/runner\").NonRunTestResult[]} - Runtime non-run details with the originating failure.\n   */\n  getNotRunTestDetails() { return this._notRunTestDetails }\n\n  /**\n   * Records a selected test that did not execute.\n   * @param {import(\"@velocious/testing/runner\").NonRunTestResult} result - Terminal-resource non-run record.\n   * @returns {void}\n   */\n  recordNotRunTest(result) { this._notRunTestDetails.push(result) }\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   * Distinguishes an empty selection from a failure before selected cases execute.\n   * @returns {boolean} - Whether selection matched no declarations.\n   */\n  hasNoMatches() {\n    return this._packageResult?.noMatches === true\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    if (this._packageResult) {\n      return slowestTestResults(this._packageResult, {limit}).map((result) => ({\n        fullDescription: result.fullName,\n        filePath: result.filePath ?? \"<unknown>\",\n        line: result.line ?? 0,\n        durationMs: result.durationMs\n      }))\n    }\n\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._notRunTestDetails = []\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 (this._setupFiles.length > 0) {\n        await this.runProfileSpan({phase: \"testing config/global setup\"}, async () => {\n          await this.getConfiguration().getEnvironmentHandler().importTestFiles(this._setupFiles)\n        })\n      }\n\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 (resolvedFilePath.startsWith(`${testingPackageDirectory}${path.sep}`)) 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 outcome for a package test.\n   * @param {PackageTestDeclaration} test - Package test declaration.\n   * @returns {{failed: false} | {failed: true, error: ReturnType<typeof JSON.parse>}} - Raw setup failure outcome.\n   */\n  setupFailureOutcomeFor(test) {\n    const suites = this.testMetadata(test).suites\n    const failure = this._suiteHookFailures.find((entry) => entry.phase === \"beforeAll\" && suites.includes(entry.suite))\n\n    return failure ? {failed: true, error: failure.error} : {failed: false}\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._retries ?? 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      retries: this._retries,\n      timeoutMs: this._timeoutMs\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"]}
+//# 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 { slowestTestResults } from \"@velocious/testing/reporters\"\nimport { TestRunner as PackageTestRunner } from \"@velocious/testing/runner\"\nimport Application from \"../../src/application.js\"\nimport RequestClient from \"./request-client.js\"\nimport Tenant from \"../tenants/tenant.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 TestTenantDatabasePool from \"./test-tenant-database-pool.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 * @property {(args?: {databaseIdentifier?: string, tenant?: object}) => Promise<TestTenantPoolLease>} [acquireTestTenant] - Leases one member of the configured test tenant database pool for this attempt (opt-in `testTenantPools` configuration).\n * @property {(args: {databaseIdentifier: string, tenant: object}) => void} [registerTenantForCleanup] - Registers one active tenant database for the framework-owned end-of-attempt cleanup (drop + provider hooks) without hand-rolled afterEach bookkeeping.\n */\n/**\n * TestTenantPoolLease type (re-exported from the pool for TestArgs consumers).\n * @typedef {import(\"./test-tenant-database-pool.js\").TestTenantPoolLease} TestTenantPoolLease\n */\n/**\n * TenantCleanupRegistration type.\n * @typedef {object} TenantCleanupRegistration\n * @property {string} databaseIdentifier - Tenant database identifier to drop at attempt end.\n * @property {ReturnType<typeof JSON.parse>} tenant - Tenant descriptor whose database must be dropped.\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\nconst testingPackageDirectory = path.dirname(fileURLToPath(import.meta.resolve(\"@velocious/testing/package.json\")))\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   * @param {number} [args.retries] - Default retry count.\n   * @param {string[]} [args.setupFiles] - Setup files imported before test files.\n   * @param {number} [args.timeoutMs] - Default lifecycle timeout.\n   */\n  constructor({configuration, context = defaultTestContext, excludeTags, includeTags, testFiles, lineFilters, examplePatterns, profiler, retries, setupFiles, timeoutMs, ...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._retries = retries\n    this._setupFiles = setupFiles || []\n    this._timeoutMs = timeoutMs\n    this._abortRemainingTests = false\n    /** @type {Map<string, TestTenantDatabasePool>} */\n    this._testTenantPools = new Map()\n    /** @type {Promise<void> | undefined} */\n    this._testTenantPoolTeardownPromise = undefined\n\n    this._failedTests = 0\n    this._successfulTests = 0\n    this._testsCount = 0\n    this._failedTestDetails = []\n    /** @type {import(\"@velocious/testing/runner\").NonRunTestResult[]} */\n    this._notRunTestDetails = []\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   * Resolves the pool identifier when exactly one `testTenantPools` entry is\n   * configured, so `acquireTestTenant()` can omit it. Ambiguous or missing\n   * configuration fails loudly instead of guessing.\n   * @returns {string} - The single configured pool identifier.\n   */\n  singleTestTenantPoolIdentifier() {\n    const identifiers = Object.keys(this.getConfiguration().getTestTenantPools() || {})\n\n    if (identifiers.length === 0) {\n      throw new Error(\"acquireTestTenant requires a databaseIdentifier when no testTenantPools configuration is present\")\n    }\n    if (identifiers.length > 1) {\n      throw new Error(`acquireTestTenant requires a databaseIdentifier when multiple testTenantPools are configured: ${identifiers.join(\", \")}`)\n    }\n\n    return identifiers[0]\n  }\n\n  /**\n   * Returns the test tenant database pool for one configured `testTenantPools`\n   * identifier, creating it on first use. Throws when the identifier has no pool\n   * configuration — the pool stays strictly opt-in.\n   * @param {string} databaseIdentifier - Tenant database identifier.\n   * @returns {TestTenantDatabasePool} - The runner-owned pool.\n   */\n  getTestTenantPool(databaseIdentifier) {\n    const existingPool = this._testTenantPools.get(databaseIdentifier)\n\n    if (existingPool) return existingPool\n\n    const poolConfiguration = this.getConfiguration().getTestTenantPools()?.[databaseIdentifier]\n\n    if (!poolConfiguration) {\n      throw new Error(`No testTenantPools configuration for database identifier: ${databaseIdentifier}`)\n    }\n\n    const pool = new TestTenantDatabasePool({\n      configuration: this.getConfiguration(),\n      databaseIdentifier,\n      poolConfiguration\n    })\n    this._testTenantPools.set(databaseIdentifier, pool)\n\n    return pool\n  }\n\n  /**\n   * Tears down every test tenant database pool created during this run, exactly once.\n   * Safe to call from afterAll-style teardown and from the runner's own cleanup; the\n   * same promise is shared by concurrent callers.\n   * @returns {Promise<void>} - Resolves after all pools dropped their databases.\n   */\n  teardownTestTenantPools() {\n    this._testTenantPoolTeardownPromise ??= (async () => {\n      const pools = [...this._testTenantPools.values()]\n      this._testTenantPools.clear()\n\n      const errors = []\n\n      for (const pool of pools) {\n        try {\n          await pool.teardown()\n        } catch (error) {\n          errors.push(error)\n        }\n      }\n\n      if (errors.length === 1) throw errors[0]\n      if (errors.length > 1) throw new AggregateError(errors, \"Failed to tear down test tenant database pools\")\n    })()\n\n    return this._testTenantPoolTeardownPromise\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   * Registers one tenant database for framework-owned end-of-attempt cleanup. The\n   * registration drops the tenant's database through the provider's `dropDatabase`\n   * hook (or the framework default) after the attempt's afterEach hooks and\n   * transactional tenant rollbacks finished, so consuming apps do not hand-roll a\n   * Map/afterEach bookkeeping layer for DDL that a test transaction cannot roll back.\n   * @param {{databaseIdentifier: string, tenant: object}} args - Tenant database identifier and tenant descriptor to drop at attempt end.\n   * @param {TenantCleanupRegistration[]} registrations - Current attempt registrations.\n   * @returns {void} - No return value.\n   */\n  registerTenantForCleanup({databaseIdentifier, tenant, ...restArgs}, registrations) {\n    restArgsError(restArgs)\n    if (!databaseIdentifier) throw new Error(\"registerTenantForCleanup requires a databaseIdentifier\")\n    if (!tenant) throw new Error(\"registerTenantForCleanup requires a tenant\")\n\n    const databaseConfiguration = this.getConfiguration().resolveDatabaseConfiguration(databaseIdentifier, tenant)\n\n    if (!databaseConfiguration.tenantOnly) {\n      throw new Error(`registerTenantForCleanup requires a tenantOnly database: ${databaseIdentifier}`)\n    }\n\n    registrations.push({databaseIdentifier, tenant})\n  }\n\n  /**\n   * Drops every tenant database registered for this attempt, in registration order.\n   * Each drop is attempted even when an earlier one failed; failures are surfaced\n   * (single error or AggregateError), never swallowed.\n   * @param {TenantCleanupRegistration[]} registrations - Attempt-owned registrations.\n   * @returns {Promise<void>} - Resolves after all registered tenants were dropped.\n   */\n  async cleanupTenantRegistrations(registrations) {\n    const errors = []\n\n    for (const {databaseIdentifier, tenant} of registrations) {\n      try {\n        await Tenant.drop({identifier: databaseIdentifier, tenant, configuration: this.getConfiguration()})\n      } catch (error) {\n        errors.push(error)\n      }\n    }\n\n    if (errors.length === 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Failed to drop tenant databases registered for cleanup\")\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   * Counts selected tests blocked by a terminal resource.\n   * @returns {number} - Selected tests not executed because a shared resource failed.\n   */\n  getNotRunTests() { return this._notRunTestDetails.length }\n\n  /**\n   * Returns runtime non-run attribution.\n   * @returns {import(\"@velocious/testing/runner\").NonRunTestResult[]} - Runtime non-run details with the originating failure.\n   */\n  getNotRunTestDetails() { return this._notRunTestDetails }\n\n  /**\n   * Records a selected test that did not execute.\n   * @param {import(\"@velocious/testing/runner\").NonRunTestResult} result - Terminal-resource non-run record.\n   * @returns {void}\n   */\n  recordNotRunTest(result) { this._notRunTestDetails.push(result) }\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   * Distinguishes an empty selection from a failure before selected cases execute.\n   * @returns {boolean} - Whether selection matched no declarations.\n   */\n  hasNoMatches() {\n    return this._packageResult?.noMatches === true\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    if (this._packageResult) {\n      return slowestTestResults(this._packageResult, {limit}).map((result) => ({\n        fullDescription: result.fullName,\n        filePath: result.filePath ?? \"<unknown>\",\n        line: result.line ?? 0,\n        durationMs: result.durationMs\n      }))\n    }\n\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._notRunTestDetails = []\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 (this._setupFiles.length > 0) {\n        await this.runProfileSpan({phase: \"testing config/global setup\"}, async () => {\n          await this.getConfiguration().getEnvironmentHandler().importTestFiles(this._setupFiles)\n        })\n      }\n\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 (resolvedFilePath.startsWith(`${testingPackageDirectory}${path.sep}`)) 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      try {\n        await this.teardownTestTenantPools()\n      } catch (error) {\n        this.recordTimeoutCleanupFailure(error, \"test tenant pool teardown\")\n      }\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\n    try {\n      await this.teardownTestTenantPools()\n    } catch (error) {\n      this.recordTimeoutCleanupFailure(error, \"test tenant pool teardown\")\n    }\n\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 outcome for a package test.\n   * @param {PackageTestDeclaration} test - Package test declaration.\n   * @returns {{failed: false} | {failed: true, error: ReturnType<typeof JSON.parse>}} - Raw setup failure outcome.\n   */\n  setupFailureOutcomeFor(test) {\n    const suites = this.testMetadata(test).suites\n    const failure = this._suiteHookFailures.find((entry) => entry.phase === \"beforeAll\" && suites.includes(entry.suite))\n\n    return failure ? {failed: true, error: failure.error} : {failed: false}\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._retries ?? 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      retries: this._retries,\n      timeoutMs: this._timeoutMs\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"]}