velocious 1.0.430 → 1.0.431

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

@@ -1,16 +1,18 @@
 // @ts-check
-import { addTrackedStackToError } from "../utils/with-tracked-stack.js";
-import fs from "node:fs/promises";
-import path from "path";
-import { format } from "node:util";
-import Application from "../../src/application.js";
-import BacktraceCleaner from "../utils/backtrace-cleaner-node.js";
-import RequestClient from "./request-client.js";
-import picocolors from "picocolors";
-import restArgsError from "../utils/rest-args-error.js";
-import { testConfig, testEvents, tests } from "./test.js";
-import { pathToFileURL } from "url";
-import { clearDeliveries } from "../mailer.js";
+
+import {addTrackedStackToError} from "../utils/with-tracked-stack.js"
+import fs from "node:fs/promises"
+import path from "path"
+import {format} from "node:util"
+import Application from "../../src/application.js"
+import BacktraceCleaner from "../utils/backtrace-cleaner-node.js"
+import RequestClient from "./request-client.js"
+import picocolors from "picocolors"
+import restArgsError from "../utils/rest-args-error.js"
+import {testConfig, testEvents, tests} from "./test.js"
+import {pathToFileURL} from "url"
+import {clearDeliveries} from "../mailer.js"
+
 /**
  * Runs run with timeout.
  * @param {Promise<?> | ?} promise - Promise or value.
@@ -19,44 +21,51 @@ import { clearDeliveries } from "../mailer.js";
  * @returns {Promise<?>} - Resolves or rejects based on timeout or promise result.
  */
 function runWithTimeout(promise, timeoutMs, testDescription) {
-    const timeoutSeconds = (timeoutMs / 1000).toFixed(3).replace(/\.?0+$/, "");
-    const timeoutError = new Error(`Timed out after ${timeoutSeconds}s: ${testDescription}`);
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => reject(timeoutError), timeoutMs);
-        Promise.resolve(promise).then((result) => {
-            clearTimeout(timeout);
-            resolve(result);
-        }).catch((error) => {
-            clearTimeout(timeout);
-            reject(error);
-        });
-    });
+  const timeoutSeconds = (timeoutMs / 1000).toFixed(3).replace(/\.?0+$/, "")
+  const timeoutError = new Error(`Timed out after ${timeoutSeconds}s: ${testDescription}`)
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(timeoutError), timeoutMs)
+
+    Promise.resolve(promise).then((result) => {
+      clearTimeout(timeout)
+      resolve(result)
+    }).catch((error) => {
+      clearTimeout(timeout)
+      reject(error)
+    })
+  })
 }
+
 /**
  * ConsoleMethodName type.
   @typedef {"log" | "info" | "warn" | "error" | "debug"} ConsoleMethodName */
+
 /**
  * Captured console methods.
   @type {ConsoleMethodName[]} */
-const CAPTURED_CONSOLE_METHODS = ["log", "info", "warn", "error", "debug"];
+const CAPTURED_CONSOLE_METHODS = ["log", "info", "warn", "error", "debug"]
+
 /**
  * AttemptConsoleOutput type.
  * @typedef {object} AttemptConsoleOutput
  * @property {number} attemptNumber - Attempt number.
  * @property {string} output - Captured console output.
  */
+
 /**
  * Runs to file slug.
  * @param {string} value - Value to sanitize.
  * @returns {string} - Slug-safe value.
  */
 function toFileSlug(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 80) || "failed-test";
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80) || "failed-test"
 }
+
 /**
  * TestArgs type.
  * @typedef {object} TestArgs
@@ -72,6 +81,7 @@ function toFileSlug(value) {
  * @property {number} [timeoutSeconds] - Timeout in seconds for the test.
  * @property {string} [type] - Test type identifier.
  */
+
 /**
  * TestData type.
  * @typedef {object} TestData
@@ -80,6 +90,7 @@ function toFileSlug(value) {
  * @property {number} [line] - Source line number.
  * @property {function(TestArgs) : (void|Promise<void>)} function - Test callback to execute.
  */
+
 /**
  * FailedTestDetail type.
  * @typedef {object} FailedTestDetail
@@ -90,30 +101,36 @@ function toFileSlug(value) {
  * @property {string} [consoleOutput] - Captured console output while test ran.
  * @property {string} [consoleLogPath] - Saved console log path.
  */
+
 /**
  * ActiveAfterAllScopeEntry type.
  * @typedef {object} ActiveAfterAllScopeEntry
  * @property {TestsArgument} tests - Scope test tree.
  * @property {boolean} afterAllsRun - Whether cleanup hooks have run.
  */
+
 /**
  * Defines this typedef.
  * @typedef {function({configuration: import("../configuration.js").default, testArgs: TestArgs, testData: TestData}) : (void|Promise<void>)} AfterBeforeEachCallbackType
  */
+
 /**
  * AfterBeforeEachCallbackObjectType type.
  * @typedef {object} AfterBeforeEachCallbackObjectType
  * @property {AfterBeforeEachCallbackType} callback - Hook callback to execute.
  */
+
 /**
  * Defines this typedef.
  * @typedef {function({configuration: import("../configuration.js").default}) : (void|Promise<void>)} BeforeAfterAllCallbackType
  */
+
 /**
  * BeforeAfterAllCallbackObjectType type.
  * @typedef {object} BeforeAfterAllCallbackObjectType
  * @property {BeforeAfterAllCallbackType} callback - Hook callback to execute.
  */
+
 /**
  * TestsArgument type.
  * @typedef {object} TestsArgument
@@ -128,904 +145,1024 @@ function toFileSlug(value) {
  * @property {Record<string, TestData>} tests - A unique identifier for the node.
  * @property {Record<string, TestsArgument>} subs - Optional child nodes. Each item is another `Node`, allowing recursion.
  */
+
 export default class TestRunner {
-    /**
-     * Narrows the runtime value to the documented type.
-      @type {ActiveAfterAllScopeEntry[]} */
-    _activeAfterAllScopes;
-    /**
-     * Narrows the runtime value to the documented type.
-      @type {FailedTestDetail[]} */
-    _failedTestDetails;
-    /**
-     * Runs constructor.
-     * @param {object} args - Options object.
-     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
-     * @param {string[] | string} [args.excludeTags] - Tags to exclude.
-     * @param {string[] | string} [args.includeTags] - Tags to include.
-     * @param {Array<string>} args.testFiles - Test files.
-     * @param {Record<string, number[]>} [args.lineFilters] - Line filters by file.
-     * @param {RegExp[]} [args.examplePatterns] - Example patterns.
-     */
-    constructor({ configuration, excludeTags, includeTags, testFiles, lineFilters, examplePatterns, ...restArgs }) {
-        restArgsError(restArgs);
-        if (!configuration)
-            throw new Error("configuration is required");
-        this._configuration = configuration;
-        this._excludeTags = this.normalizeTags(excludeTags);
-        this._excludeTagSet = new Set(this._excludeTags);
-        this._includeTags = this.normalizeTags(includeTags);
-        this._includeTagSet = new Set(this._includeTags);
-        this._testFiles = testFiles;
-        this._lineFilters = lineFilters || {};
-        this._examplePatterns = examplePatterns || [];
-        this._failedTests = 0;
-        this._successfulTests = 0;
-        this._testsCount = 0;
-        this._activeAfterAllScopes = [];
-        this._failedTestDetails = [];
+  /**
+   * Narrows the runtime value to the documented type.
+    @type {ActiveAfterAllScopeEntry[]} */
+  _activeAfterAllScopes
+
+  /**
+   * Narrows the runtime value to the documented type.
+    @type {FailedTestDetail[]} */
+  _failedTestDetails
+
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+   * @param {string[] | string} [args.excludeTags] - Tags to exclude.
+   * @param {string[] | string} [args.includeTags] - Tags to include.
+   * @param {Array<string>} args.testFiles - Test files.
+   * @param {Record<string, number[]>} [args.lineFilters] - Line filters by file.
+   * @param {RegExp[]} [args.examplePatterns] - Example patterns.
+   */
+  constructor({configuration, excludeTags, includeTags, testFiles, lineFilters, examplePatterns, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!configuration) throw new Error("configuration is required")
+
+    this._configuration = configuration
+    this._excludeTags = this.normalizeTags(excludeTags)
+    this._excludeTagSet = new Set(this._excludeTags)
+    this._includeTags = this.normalizeTags(includeTags)
+    this._includeTagSet = new Set(this._includeTags)
+    this._testFiles = testFiles
+    this._lineFilters = lineFilters || {}
+    this._examplePatterns = examplePatterns || []
+
+    this._failedTests = 0
+    this._successfulTests = 0
+    this._testsCount = 0
+    this._activeAfterAllScopes = []
+    this._failedTestDetails = []
+  }
+
+  /**
+   * Runs get configuration.
+   * @returns {import("../configuration.js").default} - The configuration.
+   */
+  getConfiguration() { return this._configuration }
+
+  /**
+   * Runs get test files.
+   * @returns {string[]} - The test files.
+   */
+  getTestFiles() { return this._testFiles }
+
+  /**
+   * Runs get line filters.
+   * @returns {Record<string, number[]>} - Line filters.
+   */
+  getLineFilters() { return this._lineFilters }
+
+  /**
+   * Runs get example patterns.
+   * @returns {RegExp[]} - Example patterns.
+   */
+  getExamplePatterns() { return this._examplePatterns }
+
+  /**
+   * Runs normalize tags.
+   * @param {string[] | string | undefined} tags - Tags.
+   * @returns {string[]} - Normalized tags.
+   */
+  normalizeTags(tags) {
+    if (!tags) return []
+
+    const values = []
+    const rawTags = Array.isArray(tags) ? tags : [tags]
+
+    for (const rawTag of rawTags) {
+      if (rawTag === undefined || rawTag === null) continue
+
+      const parts = String(rawTag).split(",")
+
+      for (const part of parts) {
+        const trimmed = part.trim()
+
+        if (trimmed) values.push(trimmed)
+      }
     }
-    /**
-     * Runs get configuration.
-     * @returns {import("../configuration.js").default} - The configuration.
-     */
-    getConfiguration() { return this._configuration; }
-    /**
-     * Runs get test files.
-     * @returns {string[]} - The test files.
-     */
-    getTestFiles() { return this._testFiles; }
-    /**
-     * Runs get line filters.
-     * @returns {Record<string, number[]>} - Line filters.
-     */
-    getLineFilters() { return this._lineFilters; }
-    /**
-     * Runs get example patterns.
-     * @returns {RegExp[]} - Example patterns.
-     */
-    getExamplePatterns() { return this._examplePatterns; }
-    /**
-     * Runs normalize tags.
-     * @param {string[] | string | undefined} tags - Tags.
-     * @returns {string[]} - Normalized tags.
-     */
-    normalizeTags(tags) {
-        if (!tags)
-            return [];
-        const values = [];
-        const rawTags = Array.isArray(tags) ? tags : [tags];
-        for (const rawTag of rawTags) {
-            if (rawTag === undefined || rawTag === null)
-                continue;
-            const parts = String(rawTag).split(",");
-            for (const part of parts) {
-                const trimmed = part.trim();
-                if (trimmed)
-                    values.push(trimmed);
-            }
-        }
-        return Array.from(new Set(values));
+
+    return Array.from(new Set(values))
+  }
+
+  /**
+   * Runs has tag.
+   * @param {TestArgs} testArgs - Test args.
+   * @param {string} tag - Tag to check for.
+   * @returns {boolean} - Whether tag is present.
+   */
+  hasTag(testArgs, tag) {
+    return this.normalizeTags(testArgs?.tags).includes(tag)
+  }
+
+  /**
+   * Runs is browser test mode.
+   * @returns {boolean} - Whether running browser tests.
+   */
+  isBrowserTestMode() {
+    return process.env.VELOCIOUS_BROWSER_TESTS === "true"
+  }
+
+  /**
+   * Runs run with dummy if needed.
+   * @param {TestArgs} testArgs - Test args.
+   * @param {() => Promise<void>} callback - Callback to run.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async runWithDummyIfNeeded(testArgs, callback) {
+    if (!this.hasTag(testArgs, "dummy")) {
+      await callback()
+      return
     }
-    /**
-     * Runs has tag.
-     * @param {TestArgs} testArgs - Test args.
-     * @param {string} tag - Tag to check for.
-     * @returns {boolean} - Whether tag is present.
-     */
-    hasTag(testArgs, tag) {
-        return this.normalizeTags(testArgs?.tags).includes(tag);
+
+    if (this.isBrowserTestMode()) {
+      await this.runBrowserDummy(callback)
+      return
     }
-    /**
-     * Runs is browser test mode.
-     * @returns {boolean} - Whether running browser tests.
-     */
-    isBrowserTestMode() {
-        return process.env.VELOCIOUS_BROWSER_TESTS === "true";
+
+    await this.runNodeDummy(callback)
+  }
+
+  /**
+   * Runs run node dummy.
+   * @param {() => Promise<void>} callback - Callback to run.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async runNodeDummy(callback) {
+    const dummyPath = process.env.VELOCIOUS_DUMMY_PATH || this.defaultDummyPath()
+    const dummyImport = await import(pathToFileURL(dummyPath).href)
+    const Dummy = dummyImport.default
+
+    if (!Dummy?.run) {
+      throw new Error(`Dummy helper not found at ${dummyPath}`)
     }
-    /**
-     * Runs run with dummy if needed.
-     * @param {TestArgs} testArgs - Test args.
-     * @param {() => Promise<void>} callback - Callback to run.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async runWithDummyIfNeeded(testArgs, callback) {
-        if (!this.hasTag(testArgs, "dummy")) {
-            await callback();
-            return;
-        }
-        if (this.isBrowserTestMode()) {
-            await this.runBrowserDummy(callback);
-            return;
-        }
-        await this.runNodeDummy(callback);
+
+    await Dummy.run(callback)
+  }
+
+  /**
+   * Runs default dummy path.
+   * @returns {string} - Default dummy helper path.
+   */
+  defaultDummyPath() {
+    const cwd = path.resolve(process.cwd())
+    const normalized = cwd.split(path.sep).join("/")
+
+    if (normalized.endsWith("/spec/dummy")) {
+      return path.join(cwd, "index.js")
     }
-    /**
-     * Runs run node dummy.
-     * @param {() => Promise<void>} callback - Callback to run.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async runNodeDummy(callback) {
-        const dummyPath = process.env.VELOCIOUS_DUMMY_PATH || this.defaultDummyPath();
-        const dummyImport = await import(pathToFileURL(dummyPath).href);
-        const Dummy = dummyImport.default;
-        if (!Dummy?.run) {
-            throw new Error(`Dummy helper not found at ${dummyPath}`);
-        }
-        await Dummy.run(callback);
+
+    return path.join(cwd, "spec/dummy/index.js")
+  }
+
+  /**
+   * Runs run browser dummy.
+   * @param {() => Promise<void>} callback - Callback to run.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async runBrowserDummy(callback) {
+    await this.getConfiguration().ensureConnections({name: "Test runner browser dummy"}, async (dbs) => {
+      await this.truncateDatabases(dbs)
+
+      try {
+        await callback()
+      } finally {
+        await this.truncateDatabases(dbs)
+      }
+    })
+  }
+
+  /**
+   * Runs truncate databases.
+   * @param {Record<string, import("../database/drivers/base.js").default>} dbs - Database connections.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async truncateDatabases(dbs) {
+    for (const identifier of Object.keys(dbs)) {
+      await dbs[identifier].truncateAllTables()
     }
+  }
+
+  /**
+   * Runs get exclude tag set.
+   * @returns {Set<string>} - Exclude tag set.
+   */
+  getExcludeTagSet() {
     /**
-     * Runs default dummy path.
-     * @returns {string} - Default dummy helper path.
-     */
-    defaultDummyPath() {
-        const cwd = path.resolve(process.cwd());
-        const normalized = cwd.split(path.sep).join("/");
-        if (normalized.endsWith("/spec/dummy")) {
-            return path.join(cwd, "index.js");
-        }
-        return path.join(cwd, "spec/dummy/index.js");
+     * Config tags.
+      @type {string[]} */
+    const configTags = Array.isArray(testConfig.excludeTags) ? testConfig.excludeTags : []
+
+    return new Set([...this._excludeTags, ...configTags])
+  }
+
+  /**
+   * Runs has matching tag.
+   * @param {string[] | string | undefined} testTags - Test tags.
+   * @param {Set<string>} tagSet - Tag set.
+   * @returns {boolean} - Whether any tags match.
+   */
+  hasMatchingTag(testTags, tagSet) {
+    if (!tagSet.size) return false
+
+    const normalized = this.normalizeTags(testTags)
+
+    for (const tag of normalized) {
+      if (tagSet.has(tag)) return true
     }
-    /**
-     * Runs run browser dummy.
-     * @param {() => Promise<void>} callback - Callback to run.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async runBrowserDummy(callback) {
-        await this.getConfiguration().ensureConnections({ name: "Test runner browser dummy" }, async (dbs) => {
-            await this.truncateDatabases(dbs);
-            try {
-                await callback();
-            }
-            finally {
-                await this.truncateDatabases(dbs);
-            }
-        });
+
+    return false
+  }
+
+  /**
+   * Runs has runnable tests.
+   * @param {TestsArgument} tests - Tests.
+   * @param {string[]} [descriptions] - Description stack.
+   * @param {boolean} [lineMatchedInScope] - Whether line matched in scope.
+   * @returns {boolean} - Whether any tests in this scope will run.
+   */
+  hasRunnableTests(tests, descriptions = [], lineMatchedInScope = false) {
+    for (const testDescription in tests.tests) {
+      const testData = tests.tests[testDescription]
+      const testArgs = /**
+                        * Narrows the runtime value to the documented type.
+                         @type {TestArgs} */ (Object.assign({}, testData.args))
+      const includeByLine = lineMatchedInScope || this.matchesLineFilter(testData)
+
+      if (this._onlyFocussed && !testArgs.focus) continue
+      if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine)) continue
+
+      return true
     }
-    /**
-     * Runs truncate databases.
-     * @param {Record<string, import("../database/drivers/base.js").default>} dbs - Database connections.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async truncateDatabases(dbs) {
-        for (const identifier of Object.keys(dbs)) {
-            await dbs[identifier].truncateAllTables();
-        }
+
+    for (const subDescription in tests.subs) {
+      const subTest = tests.subs[subDescription]
+      const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(subTest)
+      const nextDescriptions = descriptions.concat([subDescription])
+
+      if (this._onlyFocussed && !subTest.anyTestsFocussed) continue
+      if (this.hasRunnableTests(subTest, nextDescriptions, scopeLineMatch)) return true
     }
-    /**
-     * Runs get exclude tag set.
-     * @returns {Set<string>} - Exclude tag set.
-     */
-    getExcludeTagSet() {
-        /**
-         * Config tags.
-          @type {string[]} */
-        const configTags = Array.isArray(testConfig.excludeTags) ? testConfig.excludeTags : [];
-        return new Set([...this._excludeTags, ...configTags]);
+
+    return false
+  }
+
+  /**
+   * Runs should skip test.
+   * @param {TestArgs} testArgs - Test args.
+   * @param {TestData} testData - Test data.
+   * @param {string} testDescription - Test description.
+   * @param {string[]} descriptions - Description stack.
+   * @param {boolean} lineMatchedInScope - Whether line matched in scope.
+   * @returns {boolean} - Whether the test should be skipped.
+   */
+  shouldSkipTest(testArgs, testData, testDescription, descriptions, lineMatchedInScope) {
+    if (this.hasMatchingTag(testArgs.tags, this.getExcludeTagSet())) return true
+
+    if (this._includeTagSet.size > 0 && !testArgs.focus) {
+      if (!this.hasMatchingTag(testArgs.tags, this._includeTagSet)) return true
     }
-    /**
-     * Runs has matching tag.
-     * @param {string[] | string | undefined} testTags - Test tags.
-     * @param {Set<string>} tagSet - Tag set.
-     * @returns {boolean} - Whether any tags match.
-     */
-    hasMatchingTag(testTags, tagSet) {
-        if (!tagSet.size)
-            return false;
-        const normalized = this.normalizeTags(testTags);
-        for (const tag of normalized) {
-            if (tagSet.has(tag))
-                return true;
-        }
-        return false;
+
+    if (this.getExamplePatterns().length > 0) {
+      const fullDescription = this.buildFullDescription(descriptions, testDescription)
+      const matches = this.getExamplePatterns().some((pattern) => {
+        pattern.lastIndex = 0
+        return pattern.test(fullDescription)
+      })
+
+      if (!matches) return true
     }
-    /**
-     * Runs has runnable tests.
-     * @param {TestsArgument} tests - Tests.
-     * @param {string[]} [descriptions] - Description stack.
-     * @param {boolean} [lineMatchedInScope] - Whether line matched in scope.
-     * @returns {boolean} - Whether any tests in this scope will run.
-     */
-    hasRunnableTests(tests, descriptions = [], lineMatchedInScope = false) {
-        for (const testDescription in tests.tests) {
-            const testData = tests.tests[testDescription];
-            const testArgs = /**
-                              * Narrows the runtime value to the documented type.
-                               @type {TestArgs} */ (Object.assign({}, testData.args));
-            const includeByLine = lineMatchedInScope || this.matchesLineFilter(testData);
-            if (this._onlyFocussed && !testArgs.focus)
-                continue;
-            if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine))
-                continue;
-            return true;
-        }
-        for (const subDescription in tests.subs) {
-            const subTest = tests.subs[subDescription];
-            const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(subTest);
-            const nextDescriptions = descriptions.concat([subDescription]);
-            if (this._onlyFocussed && !subTest.anyTestsFocussed)
-                continue;
-            if (this.hasRunnableTests(subTest, nextDescriptions, scopeLineMatch))
-                return true;
-        }
-        return false;
+
+    const lineFilters = this.getLineFilters()
+
+    if (Object.keys(lineFilters).length > 0) {
+      if (!lineMatchedInScope && !this.matchesLineFilter(testData)) return true
     }
-    /**
-     * Runs should skip test.
-     * @param {TestArgs} testArgs - Test args.
-     * @param {TestData} testData - Test data.
-     * @param {string} testDescription - Test description.
-     * @param {string[]} descriptions - Description stack.
-     * @param {boolean} lineMatchedInScope - Whether line matched in scope.
-     * @returns {boolean} - Whether the test should be skipped.
-     */
-    shouldSkipTest(testArgs, testData, testDescription, descriptions, lineMatchedInScope) {
-        if (this.hasMatchingTag(testArgs.tags, this.getExcludeTagSet()))
-            return true;
-        if (this._includeTagSet.size > 0 && !testArgs.focus) {
-            if (!this.hasMatchingTag(testArgs.tags, this._includeTagSet))
-                return true;
-        }
-        if (this.getExamplePatterns().length > 0) {
-            const fullDescription = this.buildFullDescription(descriptions, testDescription);
-            const matches = this.getExamplePatterns().some((pattern) => {
-                pattern.lastIndex = 0;
-                return pattern.test(fullDescription);
-            });
-            if (!matches)
-                return true;
-        }
-        const lineFilters = this.getLineFilters();
-        if (Object.keys(lineFilters).length > 0) {
-            if (!lineMatchedInScope && !this.matchesLineFilter(testData))
-                return true;
-        }
-        return false;
+
+    return false
+  }
+
+  /**
+   * Runs matches line filter.
+   * @param {TestData | TestsArgument} entry - Test entry.
+   * @returns {boolean} - Whether line filter matches entry.
+   */
+  matchesLineFilter(entry) {
+    if (!entry || !entry.filePath || !entry.line) return false
+
+    const filePath = path.resolve(entry.filePath)
+    const lines = this.getLineFilters()[filePath]
+
+    if (!lines || lines.length === 0) return false
+
+    return lines.includes(entry.line)
+  }
+
+  /**
+   * Runs build full description.
+   * @param {string[]} descriptions - Description stack.
+   * @param {string} testDescription - Test description.
+   * @returns {string} - Full description.
+   */
+  buildFullDescription(descriptions, testDescription) {
+    const parts = descriptions.concat([testDescription])
+
+    return parts.join(" ").trim()
+  }
+
+  /**
+   * Runs application.
+   * @returns {Promise<Application>} - Resolves with the application.
+   */
+  async application() {
+    if (!this._application) {
+      this._application = new Application({
+        configuration: this.getConfiguration(),
+        httpServer: {port: 31006},
+        type: "test-runner"
+      })
+
+      await this._application.initialize()
+      await this._application.startHttpServer()
     }
-    /**
-     * Runs matches line filter.
-     * @param {TestData | TestsArgument} entry - Test entry.
-     * @returns {boolean} - Whether line filter matches entry.
-     */
-    matchesLineFilter(entry) {
-        if (!entry || !entry.filePath || !entry.line)
-            return false;
-        const filePath = path.resolve(entry.filePath);
-        const lines = this.getLineFilters()[filePath];
-        if (!lines || lines.length === 0)
-            return false;
-        return lines.includes(entry.line);
+
+    return this._application
+  }
+
+  /**
+   * Runs request client.
+   * @returns {Promise<RequestClient>} - Resolves with the request client.
+   */
+  async requestClient() {
+    if (!this._requestClient) {
+      this._requestClient = new RequestClient()
     }
-    /**
-     * Runs build full description.
-     * @param {string[]} descriptions - Description stack.
-     * @param {string} testDescription - Test description.
-     * @returns {string} - Full description.
-     */
-    buildFullDescription(descriptions, testDescription) {
-        const parts = descriptions.concat([testDescription]);
-        return parts.join(" ").trim();
+
+    return this._requestClient
+  }
+
+  /**
+   * Runs import test files.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async importTestFiles() {
+    await this.getConfiguration().getEnvironmentHandler().importTestFiles(this.getTestFiles())
+  }
+
+  /**
+   * Runs is failed.
+   * @returns {boolean} - Whether failed.
+   */
+  isFailed() { return this._failedTests !== undefined && this._failedTests > 0 }
+
+  /**
+   * Runs get failed tests.
+   * @returns {number} - The failed tests.
+   */
+  getFailedTests() {
+    if (this._failedTests === undefined) throw new Error("Tests hasn't been run yet")
+
+    return this._failedTests
+  }
+
+  /**
+   * Runs get failed test details.
+   * @returns {FailedTestDetail[]} - Failed test details.
+   */
+  getFailedTestDetails() {
+    return this._failedTestDetails
+  }
+
+  /**
+   * Runs persist failed test console outputs to assets.
+   * @param {object} [args] - Options object.
+   * @param {string} [args.assetsPath] - Assets directory path.
+   * @returns {Promise<string[]>} - Written log file paths.
+   */
+  async persistFailedTestConsoleOutputsToAssets({assetsPath = path.join(process.cwd(), "tmp/screenshots")} = {}) {
+    const failedTestDetails = this.getFailedTestDetails()
+    const writtenLogPaths = []
+    let createdDirectory = false
+
+    for (let index = 0; index < failedTestDetails.length; index++) {
+      const failedTestDetail = failedTestDetails[index]
+      const consoleOutput = failedTestDetail.consoleOutput
+
+      if (!consoleOutput) continue
+
+      if (!createdDirectory) {
+        await fs.mkdir(assetsPath, {recursive: true})
+        createdDirectory = true
+      }
+
+      const now = new Date()
+      const timestamp = [
+        String(now.getFullYear()),
+        String(now.getMonth() + 1).padStart(2, "0"),
+        String(now.getDate()).padStart(2, "0"),
+        String(now.getHours()).padStart(2, "0"),
+        String(now.getMinutes()).padStart(2, "0"),
+        String(now.getSeconds()).padStart(2, "0"),
+        String(now.getMilliseconds()).padStart(3, "0")
+      ].join("")
+      const slug = toFileSlug(failedTestDetail.fullDescription)
+      const fileName = `${timestamp}-${String(index + 1).padStart(2, "0")}-${slug}.console.log`
+      const filePath = path.join(assetsPath, fileName)
+
+      await fs.writeFile(filePath, consoleOutput, "utf8")
+      failedTestDetail.consoleLogPath = filePath
+      writtenLogPaths.push(filePath)
     }
-    /**
-     * Runs application.
-     * @returns {Promise<Application>} - Resolves with the application.
-     */
-    async application() {
-        if (!this._application) {
-            this._application = new Application({
-                configuration: this.getConfiguration(),
-                httpServer: { port: 31006 },
-                type: "test-runner"
-            });
-            await this._application.initialize();
-            await this._application.startHttpServer();
-        }
-        return this._application;
+
+    return writtenLogPaths
+  }
+
+  /**
+   * Runs get successful tests.
+   * @returns {number} - The successful tests.
+   */
+  getSuccessfulTests() {
+    if (this._successfulTests === undefined) throw new Error("Tests hasn't been run yet")
+
+    return this._successfulTests
+  }
+
+  /**
+   * Runs get tests count.
+   * @returns {number} - The tests count.
+   */
+  getTestsCount() {
+    if (this._testsCount === undefined) throw new Error("Tests hasn't been run yet")
+
+    return this._testsCount
+  }
+
+  /**
+   * Runs get executed tests count.
+   * @returns {number} - The executed tests count.
+   */
+  getExecutedTestsCount() {
+    if (this._successfulTests === undefined || this._failedTests === undefined) {
+      throw new Error("Tests hasn't been run yet")
     }
-    /**
-     * Runs request client.
-     * @returns {Promise<RequestClient>} - Resolves with the request client.
-     */
-    async requestClient() {
-        if (!this._requestClient) {
-            this._requestClient = new RequestClient();
-        }
-        return this._requestClient;
+
+    return this._successfulTests + this._failedTests
+  }
+
+  /**
+   * Runs prepare.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async prepare() {
+    this.anyTestsFocussed = false
+    this._failedTests = 0
+    this._successfulTests = 0
+    this._testsCount = 0
+    this._failedTestDetails = []
+    await this.importTestFiles()
+    await this.analyzeTests(tests)
+    this._onlyFocussed = this.anyTestsFocussed
+
+    const testingConfigPath = this.getConfiguration().getTesting()
+
+    if (testingConfigPath) {
+      await this.getConfiguration().getEnvironmentHandler().importTestingConfigPath()
     }
-    /**
-     * Runs import test files.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async importTestFiles() {
-        await this.getConfiguration().getEnvironmentHandler().importTestFiles(this.getTestFiles());
+  }
+
+  /**
+   * Runs are any tests focussed.
+   * @returns {boolean} - Whether any tests focussed.
+   */
+  areAnyTestsFocussed() {
+    if (this.anyTestsFocussed === undefined) {
+      throw new Error("Hasn't been detected yet")
     }
-    /**
-     * Runs is failed.
-     * @returns {boolean} - Whether failed.
-     */
-    isFailed() { return this._failedTests !== undefined && this._failedTests > 0; }
-    /**
-     * Runs get failed tests.
-     * @returns {number} - The failed tests.
-     */
-    getFailedTests() {
-        if (this._failedTests === undefined)
-            throw new Error("Tests hasn't been run yet");
-        return this._failedTests;
+
+    return this.anyTestsFocussed
+  }
+
+  /**
+   * Runs run.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async run() {
+    await this.getConfiguration().ensureConnections({name: "Test runner suite"}, async () => {
+      await this.runTests({
+        afterEaches: [],
+        beforeEaches: [],
+        tests,
+        descriptions: [],
+        indentLevel: 0
+      })
+    })
+  }
+
+  /**
+   * Runs run after alls for active scopes.
+   * @returns {Promise<void>} - Resolves when cleanup hooks finish.
+   */
+  async runAfterAllsForActiveScopes() {
+    const scopes = [...this._activeAfterAllScopes].reverse()
+
+    for (const scope of scopes) {
+      await this.runAfterAllsForScope(scope)
     }
-    /**
-     * Runs get failed test details.
-     * @returns {FailedTestDetail[]} - Failed test details.
-     */
-    getFailedTestDetails() {
-        return this._failedTestDetails;
+
+    this._activeAfterAllScopes = []
+  }
+
+  /**
+   * Runs analyze tests.
+   * @param {TestsArgument} tests - Tests.
+   * @returns {{anyTestsFocussed: boolean}} - Whether any tests in the tree are focused.
+   */
+  analyzeTests(tests) {
+    let anyTestsFocussedFound = false
+
+    for (const testDescription in tests.tests) {
+      const testData = tests.tests[testDescription]
+      const testArgs = Object.assign({}, testData.args)
+
+      this._testsCount++
+
+      if (testArgs.focus) {
+        anyTestsFocussedFound = true
+        this.anyTestsFocussed = true
+      }
     }
-    /**
-     * Runs persist failed test console outputs to assets.
-     * @param {object} [args] - Options object.
-     * @param {string} [args.assetsPath] - Assets directory path.
-     * @returns {Promise<string[]>} - Written log file paths.
-     */
-    async persistFailedTestConsoleOutputsToAssets({ assetsPath = path.join(process.cwd(), "tmp/screenshots") } = {}) {
-        const failedTestDetails = this.getFailedTestDetails();
-        const writtenLogPaths = [];
-        let createdDirectory = false;
-        for (let index = 0; index < failedTestDetails.length; index++) {
-            const failedTestDetail = failedTestDetails[index];
-            const consoleOutput = failedTestDetail.consoleOutput;
-            if (!consoleOutput)
-                continue;
-            if (!createdDirectory) {
-                await fs.mkdir(assetsPath, { recursive: true });
-                createdDirectory = true;
-            }
-            const now = new Date();
-            const timestamp = [
-                String(now.getFullYear()),
-                String(now.getMonth() + 1).padStart(2, "0"),
-                String(now.getDate()).padStart(2, "0"),
-                String(now.getHours()).padStart(2, "0"),
-                String(now.getMinutes()).padStart(2, "0"),
-                String(now.getSeconds()).padStart(2, "0"),
-                String(now.getMilliseconds()).padStart(3, "0")
-            ].join("");
-            const slug = toFileSlug(failedTestDetail.fullDescription);
-            const fileName = `${timestamp}-${String(index + 1).padStart(2, "0")}-${slug}.console.log`;
-            const filePath = path.join(assetsPath, fileName);
-            await fs.writeFile(filePath, consoleOutput, "utf8");
-            failedTestDetail.consoleLogPath = filePath;
-            writtenLogPaths.push(filePath);
-        }
-        return writtenLogPaths;
+
+    for (const subDescription in tests.subs) {
+      const subTest = tests.subs[subDescription]
+      const {anyTestsFocussed} = this.analyzeTests(subTest)
+
+      if (anyTestsFocussed) {
+        anyTestsFocussedFound = true
+      }
+
+      subTest.anyTestsFocussed = anyTestsFocussed
     }
-    /**
-     * Runs get successful tests.
-     * @returns {number} - The successful tests.
-     */
-    getSuccessfulTests() {
-        if (this._successfulTests === undefined)
-            throw new Error("Tests hasn't been run yet");
-        return this._successfulTests;
-    }
-    /**
-     * Runs get tests count.
-     * @returns {number} - The tests count.
-     */
-    getTestsCount() {
-        if (this._testsCount === undefined)
-            throw new Error("Tests hasn't been run yet");
-        return this._testsCount;
-    }
-    /**
-     * Runs get executed tests count.
-     * @returns {number} - The executed tests count.
-     */
-    getExecutedTestsCount() {
-        if (this._successfulTests === undefined || this._failedTests === undefined) {
-            throw new Error("Tests hasn't been run yet");
-        }
-        return this._successfulTests + this._failedTests;
-    }
-    /**
-     * Runs prepare.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async prepare() {
-        this.anyTestsFocussed = false;
-        this._failedTests = 0;
-        this._successfulTests = 0;
-        this._testsCount = 0;
-        this._failedTestDetails = [];
-        await this.importTestFiles();
-        await this.analyzeTests(tests);
-        this._onlyFocussed = this.anyTestsFocussed;
-        const testingConfigPath = this.getConfiguration().getTesting();
-        if (testingConfigPath) {
-            await this.getConfiguration().getEnvironmentHandler().importTestingConfigPath();
-        }
-    }
-    /**
-     * Runs are any tests focussed.
-     * @returns {boolean} - Whether any tests focussed.
-     */
-    areAnyTestsFocussed() {
-        if (this.anyTestsFocussed === undefined) {
-            throw new Error("Hasn't been detected yet");
+
+    return {anyTestsFocussed: anyTestsFocussedFound}
+  }
+
+  /**
+   * Runs run tests.
+   * @param {object} args - Options object.
+   * @param {Array<AfterBeforeEachCallbackObjectType>} args.afterEaches - After eaches.
+   * @param {Array<AfterBeforeEachCallbackObjectType>} args.beforeEaches - Before eaches.
+   * @param {TestsArgument} args.tests - Tests.
+   * @param {string[]} args.descriptions - Descriptions.
+   * @param {number} args.indentLevel - Indent level.
+   * @param {boolean} [args.lineMatchedInScope] - Whether line matched in scope.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async runTests({afterEaches, beforeEaches, tests, descriptions, indentLevel, lineMatchedInScope = false}) {
+    const leftPadding = " ".repeat(indentLevel * 2)
+    const newAfterEaches = [...afterEaches, ...tests.afterEaches]
+    const newBeforeEaches = [...beforeEaches, ...tests.beforeEaches]
+    const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(tests)
+    const shouldRunAnyTests = this.hasRunnableTests(tests, descriptions, scopeLineMatch)
+
+    if (!shouldRunAnyTests) return
+
+    /** Scope entry. @type {ActiveAfterAllScopeEntry} */
+    const scopeEntry = {tests, afterAllsRun: false}
+    this._activeAfterAllScopes.push(scopeEntry)
+
+    try {
+      for (const beforeAllData of tests.beforeAlls || []) {
+        await beforeAllData.callback({configuration: this.getConfiguration()})
+      }
+
+      for (const testDescription in tests.tests) {
+        const testData = tests.tests[testDescription]
+        const testArgs = /**
+                          * Narrows the runtime value to the documented type.
+                           @type {TestArgs} */ (Object.assign({}, testData.args))
+        const includeByLine = scopeLineMatch || this.matchesLineFilter(testData)
+
+        if (this._onlyFocussed && !testArgs.focus) continue
+        if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine)) continue
+
+        if (testArgs.type == "model" || testArgs.type == "request") {
+          testArgs.application = await this.application()
         }
-        return this.anyTestsFocussed;
-    }
-    /**
-     * Runs run.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async run() {
-        await this.getConfiguration().ensureConnections({ name: "Test runner suite" }, async () => {
-            await this.runTests({
-                afterEaches: [],
-                beforeEaches: [],
-                tests,
-                descriptions: [],
-                indentLevel: 0
-            });
-        });
-    }
-    /**
-     * Runs run after alls for active scopes.
-     * @returns {Promise<void>} - Resolves when cleanup hooks finish.
-     */
-    async runAfterAllsForActiveScopes() {
-        const scopes = [...this._activeAfterAllScopes].reverse();
-        for (const scope of scopes) {
-            await this.runAfterAllsForScope(scope);
+
+        if (testArgs.type == "request") {
+          testArgs.client = await this.requestClient()
         }
-        this._activeAfterAllScopes = [];
-    }
-    /**
-     * Runs analyze tests.
-     * @param {TestsArgument} tests - Tests.
-     * @returns {{anyTestsFocussed: boolean}} - Whether any tests in the tree are focused.
-     */
-    analyzeTests(tests) {
-        let anyTestsFocussedFound = false;
-        for (const testDescription in tests.tests) {
-            const testData = tests.tests[testDescription];
-            const testArgs = Object.assign({}, testData.args);
-            this._testsCount++;
-            if (testArgs.focus) {
-                anyTestsFocussedFound = true;
-                this.anyTestsFocussed = true;
+
+        const retryCount = typeof testArgs.retry === "number" && Number.isFinite(testArgs.retry)
+          ? Math.max(0, Math.floor(testArgs.retry))
+          : 0
+        const configTimeoutSeconds = typeof testConfig.defaultTimeoutSeconds === "number" ? testConfig.defaultTimeoutSeconds : undefined
+        const timeoutSeconds = typeof testArgs.timeoutSeconds === "number" ? testArgs.timeoutSeconds : configTimeoutSeconds
+        const useTimeout = typeof timeoutSeconds === "number" && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0
+        const timeoutMs = useTimeout ? timeoutSeconds * 1000 : undefined
+        let retriesUsed = 0
+        let attemptNumber = 1
+        /**
+         * Attempt console outputs.
+          @type {AttemptConsoleOutput[]} */
+        const attemptConsoleOutputs = []
+
+        console.log(`${leftPadding}it ${testDescription}`)
+
+        while (true) {
+          let shouldRetry = false
+          /**
+           * Defines caughtError.
+            @type {?} */
+          let caughtError
+          /**
+           * Defines failedError.
+            @type {?} */
+          let failedError
+          /**
+           * Defines lastError.
+            @type {?} */
+          let lastError
+          let willRetry = false
+          const stopConsoleCapture = this.startConsoleCapture({
+            passthrough: testConfig.consoleOutput === "live"
+          })
+
+          try {
+            // Run the whole per-test lifecycle (dummy/server startup, connection
+            // acquisition, beforeEach hooks, the test body and afterEach hooks) as
+            // one promise so the timeout below can cover all of it.
+            const testLifecycle = this.runWithDummyIfNeeded(testArgs, async () => {
+              // Pin one connection per test so beforeEach, the test body and afterEach
+              // all run on the SAME connection. This is required for transaction-based
+              // database cleaning (beforeEach starts a transaction, afterEach rolls it
+              // back). ensureConnections reuses the suite-level pinned connection while
+              // it is healthy and transparently re-establishes a per-test pin if an
+              // earlier spec closed the suite connection (which would otherwise leave a
+              // stale async-context pin and force every later test onto a fresh checkout,
+              // breaking isolation).
+              await this.getConfiguration().ensureConnections({name: `Test: ${testDescription}`}, async () => {
+                try {
+                  clearDeliveries()
+                  for (const beforeEachData of newBeforeEaches) {
+                    await beforeEachData.callback({configuration: this.getConfiguration(), testArgs, testData})
+                  }
+
+                  await testData.function(testArgs)
+                  this._successfulTests++
+                } finally {
+                  for (const afterEachData of newAfterEaches) {
+                    await afterEachData.callback({configuration: this.getConfiguration(), testArgs, testData})
+                  }
+                }
+              })
+            })
+
+            // Time out the ENTIRE lifecycle, not just the test body. A hang in any
+            // phase — a connection checkout that never resolves, a beforeEach/afterEach
+            // waiting on a lock, or dummy server startup — would otherwise stall the
+            // whole run indefinitely (until CI kills the build) instead of failing the
+            // single offending test.
+            if (useTimeout && timeoutMs !== undefined) {
+              await runWithTimeout(testLifecycle, timeoutMs, testDescription)
+            } else {
+              await testLifecycle
             }
-        }
-        for (const subDescription in tests.subs) {
-            const subTest = tests.subs[subDescription];
-            const { anyTestsFocussed } = this.analyzeTests(subTest);
-            if (anyTestsFocussed) {
-                anyTestsFocussedFound = true;
+          } catch (error) {
+            caughtError = error
+            lastError = error
+            willRetry = retriesUsed < retryCount
+
+            if (willRetry) {
+              retriesUsed++
             }
-            subTest.anyTestsFocussed = anyTestsFocussed;
-        }
-        return { anyTestsFocussed: anyTestsFocussedFound };
-    }
-    /**
-     * Runs run tests.
-     * @param {object} args - Options object.
-     * @param {Array<AfterBeforeEachCallbackObjectType>} args.afterEaches - After eaches.
-     * @param {Array<AfterBeforeEachCallbackObjectType>} args.beforeEaches - Before eaches.
-     * @param {TestsArgument} args.tests - Tests.
-     * @param {string[]} args.descriptions - Descriptions.
-     * @param {number} args.indentLevel - Indent level.
-     * @param {boolean} [args.lineMatchedInScope] - Whether line matched in scope.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async runTests({ afterEaches, beforeEaches, tests, descriptions, indentLevel, lineMatchedInScope = false }) {
-        const leftPadding = " ".repeat(indentLevel * 2);
-        const newAfterEaches = [...afterEaches, ...tests.afterEaches];
-        const newBeforeEaches = [...beforeEaches, ...tests.beforeEaches];
-        const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(tests);
-        const shouldRunAnyTests = this.hasRunnableTests(tests, descriptions, scopeLineMatch);
-        if (!shouldRunAnyTests)
-            return;
-        /** Scope entry. @type {ActiveAfterAllScopeEntry} */
-        const scopeEntry = { tests, afterAllsRun: false };
-        this._activeAfterAllScopes.push(scopeEntry);
-        try {
-            for (const beforeAllData of tests.beforeAlls || []) {
-                await beforeAllData.callback({ configuration: this.getConfiguration() });
+
+            if (willRetry) {
+              shouldRetry = true
+            } else {
+              failedError = error
             }
-            for (const testDescription in tests.tests) {
-                const testData = tests.tests[testDescription];
-                const testArgs = /**
-                                  * Narrows the runtime value to the documented type.
-                                   @type {TestArgs} */ (Object.assign({}, testData.args));
-                const includeByLine = scopeLineMatch || this.matchesLineFilter(testData);
-                if (this._onlyFocussed && !testArgs.focus)
-                    continue;
-                if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine))
-                    continue;
-                if (testArgs.type == "model" || testArgs.type == "request") {
-                    testArgs.application = await this.application();
-                }
-                if (testArgs.type == "request") {
-                    testArgs.client = await this.requestClient();
-                }
-                const retryCount = typeof testArgs.retry === "number" && Number.isFinite(testArgs.retry)
-                    ? Math.max(0, Math.floor(testArgs.retry))
-                    : 0;
-                const configTimeoutSeconds = typeof testConfig.defaultTimeoutSeconds === "number" ? testConfig.defaultTimeoutSeconds : undefined;
-                const timeoutSeconds = typeof testArgs.timeoutSeconds === "number" ? testArgs.timeoutSeconds : configTimeoutSeconds;
-                const useTimeout = typeof timeoutSeconds === "number" && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0;
-                const timeoutMs = useTimeout ? timeoutSeconds * 1000 : undefined;
-                let retriesUsed = 0;
-                let attemptNumber = 1;
-                /**
-                 * Attempt console outputs.
-                  @type {AttemptConsoleOutput[]} */
-                const attemptConsoleOutputs = [];
-                console.log(`${leftPadding}it ${testDescription}`);
-                while (true) {
-                    let shouldRetry = false;
-                    /**
-                     * Defines caughtError.
-                      @type {?} */
-                    let caughtError;
-                    /**
-                     * Defines failedError.
-                      @type {?} */
-                    let failedError;
-                    /**
-                     * Defines lastError.
-                      @type {?} */
-                    let lastError;
-                    let willRetry = false;
-                    const stopConsoleCapture = this.startConsoleCapture({
-                        passthrough: testConfig.consoleOutput === "live"
-                    });
-                    try {
-                        // Run the whole per-test lifecycle (dummy/server startup, connection
-                        // acquisition, beforeEach hooks, the test body and afterEach hooks) as
-                        // one promise so the timeout below can cover all of it.
-                        const testLifecycle = this.runWithDummyIfNeeded(testArgs, async () => {
-                            // Pin one connection per test so beforeEach, the test body and afterEach
-                            // all run on the SAME connection. This is required for transaction-based
-                            // database cleaning (beforeEach starts a transaction, afterEach rolls it
-                            // back). ensureConnections reuses the suite-level pinned connection while
-                            // it is healthy and transparently re-establishes a per-test pin if an
-                            // earlier spec closed the suite connection (which would otherwise leave a
-                            // stale async-context pin and force every later test onto a fresh checkout,
-                            // breaking isolation).
-                            await this.getConfiguration().ensureConnections({ name: `Test: ${testDescription}` }, async () => {
-                                try {
-                                    clearDeliveries();
-                                    for (const beforeEachData of newBeforeEaches) {
-                                        await beforeEachData.callback({ configuration: this.getConfiguration(), testArgs, testData });
-                                    }
-                                    await testData.function(testArgs);
-                                    this._successfulTests++;
-                                }
-                                finally {
-                                    for (const afterEachData of newAfterEaches) {
-                                        await afterEachData.callback({ configuration: this.getConfiguration(), testArgs, testData });
-                                    }
-                                }
-                            });
-                        });
-                        // Time out the ENTIRE lifecycle, not just the test body. A hang in any
-                        // phase — a connection checkout that never resolves, a beforeEach/afterEach
-                        // waiting on a lock, or dummy server startup — would otherwise stall the
-                        // whole run indefinitely (until CI kills the build) instead of failing the
-                        // single offending test.
-                        if (useTimeout && timeoutMs !== undefined) {
-                            await runWithTimeout(testLifecycle, timeoutMs, testDescription);
-                        }
-                        else {
-                            await testLifecycle;
-                        }
-                    }
-                    catch (error) {
-                        caughtError = error;
-                        lastError = error;
-                        willRetry = retriesUsed < retryCount;
-                        if (willRetry) {
-                            retriesUsed++;
-                        }
-                        if (willRetry) {
-                            shouldRetry = true;
-                        }
-                        else {
-                            failedError = error;
-                        }
-                    }
-                    finally {
-                        const consoleOutput = stopConsoleCapture();
-                        if (consoleOutput) {
-                            attemptConsoleOutputs.push({ attemptNumber, output: consoleOutput });
-                        }
-                    }
-                    if (caughtError !== undefined) {
-                        await this.emitEvent("testAttemptFailed", {
-                            configuration: this.getConfiguration(),
-                            descriptions,
-                            error: caughtError,
-                            attemptNumber,
-                            nextAttempt: willRetry ? attemptNumber + 1 : undefined,
-                            retriesUsed,
-                            retryCount,
-                            testArgs,
-                            testData,
-                            testDescription,
-                            testRunner: this,
-                            willRetry
-                        });
-                    }
-                    if (shouldRetry) {
-                        console.warn(picocolors.red(`${leftPadding}  Retrying (${retriesUsed}/${retryCount}) after error: ${lastError instanceof Error ? lastError.message : String(lastError)}`));
-                        await this.emitEvent("testRetrying", {
-                            configuration: this.getConfiguration(),
-                            descriptions,
-                            error: lastError,
-                            nextAttempt: attemptNumber + 1,
-                            retriesUsed,
-                            retryCount,
-                            testArgs,
-                            testData,
-                            testDescription,
-                            testRunner: this
-                        });
-                    }
-                    if (attemptNumber > 1) {
-                        await this.emitEvent("testRetried", {
-                            configuration: this.getConfiguration(),
-                            descriptions,
-                            error: lastError,
-                            attemptNumber,
-                            retriesUsed,
-                            retryCount,
-                            testArgs,
-                            testData,
-                            testDescription,
-                            testRunner: this
-                        });
-                    }
-                    attemptNumber++;
-                    if (shouldRetry)
-                        continue;
-                    if (failedError) {
-                        const consoleOutput = this.buildConsoleOutput(attemptConsoleOutputs);
-                        if (failedError instanceof Error) {
-                            console.error(picocolors.red(`${leftPadding}  Test failed: ${failedError.message}`));
-                            addTrackedStackToError(failedError);
-                            const backtraceCleaner = new BacktraceCleaner(failedError);
-                            const cleanedStack = backtraceCleaner.getCleanedStack();
-                            const stackLines = cleanedStack?.split("\n");
-                            if (stackLines) {
-                                for (const stackLine of stackLines) {
-                                    console.error(picocolors.red(`${leftPadding}  ${stackLine}`));
-                                }
-                            }
-                        }
-                        else {
-                            console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof failedError}: ${String(failedError)}`));
-                        }
-                        this.printFailedConsoleOutput({ consoleOutput, leftPadding });
-                        this._failedTests++;
-                        this._failedTestDetails.push({
-                            fullDescription: this.buildFullDescription(descriptions, testDescription),
-                            filePath: testData.filePath,
-                            line: testData.line,
-                            error: failedError,
-                            consoleOutput: consoleOutput || undefined
-                        });
-                        await this.emitEvent("testFailed", {
-                            configuration: this.getConfiguration(),
-                            descriptions,
-                            error: failedError,
-                            testArgs,
-                            testData,
-                            testDescription,
-                            testRunner: this
-                        });
-                        this.printRerunCommand({ descriptions, testDescription, testData, leftPadding });
-                    }
-                    break;
-                }
+          } finally {
+            const consoleOutput = stopConsoleCapture()
+
+            if (consoleOutput) {
+              attemptConsoleOutputs.push({attemptNumber, output: consoleOutput})
             }
-            for (const subDescription in tests.subs) {
-                const subTest = tests.subs[subDescription];
-                const newDecriptions = descriptions.concat([subDescription]);
-                const childScopeLineMatch = scopeLineMatch || this.matchesLineFilter(subTest);
-                if (!this._onlyFocussed || subTest.anyTestsFocussed) {
-                    console.log(`${leftPadding}${subDescription}`);
-                    await this.runTests({
-                        afterEaches: newAfterEaches,
-                        beforeEaches: newBeforeEaches,
-                        tests: subTest,
-                        descriptions: newDecriptions,
-                        indentLevel: indentLevel + 1,
-                        lineMatchedInScope: childScopeLineMatch
-                    });
+          }
+
+          if (caughtError !== undefined) {
+            await this.emitEvent("testAttemptFailed", {
+              configuration: this.getConfiguration(),
+              descriptions,
+              error: caughtError,
+              attemptNumber,
+              nextAttempt: willRetry ? attemptNumber + 1 : undefined,
+              retriesUsed,
+              retryCount,
+              testArgs,
+              testData,
+              testDescription,
+              testRunner: this,
+              willRetry
+            })
+          }
+
+          if (shouldRetry) {
+            console.warn(picocolors.red(`${leftPadding}  Retrying (${retriesUsed}/${retryCount}) after error: ${lastError instanceof Error ? lastError.message : String(lastError)}`))
+            await this.emitEvent("testRetrying", {
+              configuration: this.getConfiguration(),
+              descriptions,
+              error: lastError,
+              nextAttempt: attemptNumber + 1,
+              retriesUsed,
+              retryCount,
+              testArgs,
+              testData,
+              testDescription,
+              testRunner: this
+            })
+          }
+
+          if (attemptNumber > 1) {
+            await this.emitEvent("testRetried", {
+              configuration: this.getConfiguration(),
+              descriptions,
+              error: lastError,
+              attemptNumber,
+              retriesUsed,
+              retryCount,
+              testArgs,
+              testData,
+              testDescription,
+              testRunner: this
+            })
+          }
+
+          attemptNumber++
+
+          if (shouldRetry) continue
+
+          if (failedError) {
+            const consoleOutput = this.buildConsoleOutput(attemptConsoleOutputs)
+
+            if (failedError instanceof Error) {
+              console.error(picocolors.red(`${leftPadding}  Test failed: ${failedError.message}`))
+              addTrackedStackToError(failedError)
+
+              const backtraceCleaner = new BacktraceCleaner(failedError)
+              const cleanedStack = backtraceCleaner.getCleanedStack()
+              const stackLines = cleanedStack?.split("\n")
+
+              if (stackLines) {
+                for (const stackLine of stackLines) {
+                  console.error(picocolors.red(`${leftPadding}  ${stackLine}`))
                 }
+              }
+            } else {
+              console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof failedError}: ${String(failedError)}`))
             }
+
+            this.printFailedConsoleOutput({consoleOutput, leftPadding})
+            this._failedTests++
+            this._failedTestDetails.push({
+              fullDescription: this.buildFullDescription(descriptions, testDescription),
+              filePath: testData.filePath,
+              line: testData.line,
+              error: failedError,
+              consoleOutput: consoleOutput || undefined
+            })
+
+            await this.emitEvent("testFailed", {
+              configuration: this.getConfiguration(),
+              descriptions,
+              error: failedError,
+              testArgs,
+              testData,
+              testDescription,
+              testRunner: this
+            })
+
+            this.printRerunCommand({descriptions, testDescription, testData, leftPadding})
+          }
+
+          break
         }
-        finally {
-            await this.runAfterAllsForScope(scopeEntry);
-            const scopeIndex = this._activeAfterAllScopes.indexOf(scopeEntry);
-            if (scopeIndex >= 0) {
-                this._activeAfterAllScopes.splice(scopeIndex, 1);
-            }
+      }
+
+      for (const subDescription in tests.subs) {
+        const subTest = tests.subs[subDescription]
+        const newDecriptions = descriptions.concat([subDescription])
+        const childScopeLineMatch = scopeLineMatch || this.matchesLineFilter(subTest)
+
+        if (!this._onlyFocussed || subTest.anyTestsFocussed) {
+          console.log(`${leftPadding}${subDescription}`)
+          await this.runTests({
+            afterEaches: newAfterEaches,
+            beforeEaches: newBeforeEaches,
+            tests: subTest,
+            descriptions: newDecriptions,
+            indentLevel: indentLevel + 1,
+            lineMatchedInScope: childScopeLineMatch
+          })
         }
+      }
+    } finally {
+      await this.runAfterAllsForScope(scopeEntry)
+      const scopeIndex = this._activeAfterAllScopes.indexOf(scopeEntry)
+
+      if (scopeIndex >= 0) {
+        this._activeAfterAllScopes.splice(scopeIndex, 1)
+      }
     }
-    /**
-     * Runs run after alls for scope.
-     * @param {ActiveAfterAllScopeEntry} scopeEntry - Scope entry.
-     * @returns {Promise<void>} - Resolves when scope cleanup finishes.
-     */
-    async runAfterAllsForScope(scopeEntry) {
-        if (scopeEntry.afterAllsRun)
-            return;
-        scopeEntry.afterAllsRun = true;
-        for (const afterAllData of scopeEntry.tests.afterAlls || []) {
-            await afterAllData.callback({ configuration: this.getConfiguration() });
-        }
+  }
+
+  /**
+   * Runs run after alls for scope.
+   * @param {ActiveAfterAllScopeEntry} scopeEntry - Scope entry.
+   * @returns {Promise<void>} - Resolves when scope cleanup finishes.
+   */
+  async runAfterAllsForScope(scopeEntry) {
+    if (scopeEntry.afterAllsRun) return
+
+    scopeEntry.afterAllsRun = true
+
+    for (const afterAllData of scopeEntry.tests.afterAlls || []) {
+      await afterAllData.callback({configuration: this.getConfiguration()})
     }
-    /**
-     * Runs emit event.
-     * @param {string} eventName - Event name.
-     * @param {object} payload - Event payload.
-     * @returns {Promise<void>} - Resolves when all listeners complete.
-     */
-    async emitEvent(eventName, payload) {
-        const listeners = testEvents.listeners(eventName);
-        for (const listener of listeners) {
-            await listener(payload);
-        }
+  }
+
+  /**
+   * Runs emit event.
+   * @param {string} eventName - Event name.
+   * @param {object} payload - Event payload.
+   * @returns {Promise<void>} - Resolves when all listeners complete.
+   */
+  async emitEvent(eventName, payload) {
+    const listeners = testEvents.listeners(eventName)
+
+    for (const listener of listeners) {
+      await listener(payload)
     }
-    /**
-     * Runs print rerun command.
-     * @param {object} args - Options object.
-     * @param {string[]} args.descriptions - Description stack.
-     * @param {string} args.testDescription - Test description.
-     * @param {TestData} args.testData - Test data.
-     * @param {string} args.leftPadding - Left padding.
-     * @returns {void} - No return value.
-     */
-    printRerunCommand({ descriptions, testDescription, testData, leftPadding }) {
-        const rerun = this.buildRerunCommand({ descriptions, testDescription, testData });
-        if (rerun) {
-            console.error(`${leftPadding}  Re-run: ${rerun}`);
-        }
+  }
+
+  /**
+   * Runs print rerun command.
+   * @param {object} args - Options object.
+   * @param {string[]} args.descriptions - Description stack.
+   * @param {string} args.testDescription - Test description.
+   * @param {TestData} args.testData - Test data.
+   * @param {string} args.leftPadding - Left padding.
+   * @returns {void} - No return value.
+   */
+  printRerunCommand({descriptions, testDescription, testData, leftPadding}) {
+    const rerun = this.buildRerunCommand({descriptions, testDescription, testData})
+
+    if (rerun) {
+      console.error(`${leftPadding}  Re-run: ${rerun}`)
     }
-    /**
-     * Runs build rerun command.
-     * @param {object} args - Options object.
-     * @param {string[]} args.descriptions - Description stack.
-     * @param {string} args.testDescription - Test description.
-     * @param {TestData} args.testData - Test data.
-     * @returns {string | undefined} - Rerun command.
-     */
-    buildRerunCommand({ descriptions, testDescription, testData }) {
-        const baseCommand = "npx velocious test";
-        const filePath = testData.filePath;
-        const line = testData.line;
-        if (filePath && line) {
-            const relativePath = path.relative(process.cwd(), filePath);
-            return `${baseCommand} ${relativePath}:${line}`;
-        }
-        const fullDescription = this.buildFullDescription(descriptions, testDescription);
-        if (fullDescription) {
-            return `${baseCommand} --example ${JSON.stringify(fullDescription)}`;
-        }
-        return undefined;
+  }
+
+  /**
+   * Runs build rerun command.
+   * @param {object} args - Options object.
+   * @param {string[]} args.descriptions - Description stack.
+   * @param {string} args.testDescription - Test description.
+   * @param {TestData} args.testData - Test data.
+   * @returns {string | undefined} - Rerun command.
+   */
+  buildRerunCommand({descriptions, testDescription, testData}) {
+    const baseCommand = "npx velocious test"
+    const filePath = testData.filePath
+    const line = testData.line
+
+    if (filePath && line) {
+      const relativePath = path.relative(process.cwd(), filePath)
+      return `${baseCommand} ${relativePath}:${line}`
     }
-    /**
-     * Runs build console output.
-     * @param {AttemptConsoleOutput[]} attemptConsoleOutputs - Attempt output entries.
-     * @returns {string} - Combined console output.
-     */
-    buildConsoleOutput(attemptConsoleOutputs) {
-        if (attemptConsoleOutputs.length === 0)
-            return "";
-        if (attemptConsoleOutputs.length === 1)
-            return attemptConsoleOutputs[0].output;
-        return attemptConsoleOutputs.map((attemptConsoleOutput) => {
-            return `--- Attempt ${attemptConsoleOutput.attemptNumber} ---\n${attemptConsoleOutput.output}`;
-        }).join("\n");
+
+    const fullDescription = this.buildFullDescription(descriptions, testDescription)
+
+    if (fullDescription) {
+      return `${baseCommand} --example ${JSON.stringify(fullDescription)}`
     }
-    /**
-     * Runs get failed console output max lines.
-     * @returns {number} - Maximum failed console lines.
-     */
-    getFailedConsoleOutputMaxLines() {
-        const maxLines = testConfig.failedConsoleOutputMaxLines;
-        if (typeof maxLines !== "number" || !Number.isFinite(maxLines))
-            return 200;
-        return Math.max(0, Math.floor(maxLines));
+
+    return undefined
+  }
+
+  /**
+   * Runs build console output.
+   * @param {AttemptConsoleOutput[]} attemptConsoleOutputs - Attempt output entries.
+   * @returns {string} - Combined console output.
+   */
+  buildConsoleOutput(attemptConsoleOutputs) {
+    if (attemptConsoleOutputs.length === 0) return ""
+    if (attemptConsoleOutputs.length === 1) return attemptConsoleOutputs[0].output
+
+    return attemptConsoleOutputs.map((attemptConsoleOutput) => {
+      return `--- Attempt ${attemptConsoleOutput.attemptNumber} ---\n${attemptConsoleOutput.output}`
+    }).join("\n")
+  }
+
+  /**
+   * Runs get failed console output max lines.
+   * @returns {number} - Maximum failed console lines.
+   */
+  getFailedConsoleOutputMaxLines() {
+    const maxLines = testConfig.failedConsoleOutputMaxLines
+
+    if (typeof maxLines !== "number" || !Number.isFinite(maxLines)) return 200
+
+    return Math.max(0, Math.floor(maxLines))
+  }
+
+  /**
+   * Runs truncate failed console output lines.
+   * @param {string} consoleOutput - Console output.
+   * @returns {string[]} - Lines for inline output.
+   */
+  truncateFailedConsoleOutputLines(consoleOutput) {
+    const lines = consoleOutput.split("\n")
+    const maxLines = this.getFailedConsoleOutputMaxLines()
+
+    if (maxLines === 0) return []
+    if (lines.length <= maxLines) return lines
+
+    const omittedLines = lines.length - maxLines
+    const plural = omittedLines === 1 ? "" : "s"
+
+    return [
+      `... ${omittedLines} console output line${plural} omitted ...`,
+      ...lines.slice(-maxLines)
+    ]
+  }
+
+  /**
+   * Runs print failed console output.
+   * @param {object} args - Options object.
+   * @param {string} args.consoleOutput - Console output.
+   * @param {string} args.leftPadding - Left padding.
+   * @returns {void} - No return value.
+   */
+  printFailedConsoleOutput({consoleOutput, leftPadding}) {
+    if (testConfig.consoleOutput !== "failure") return
+    if (!consoleOutput) return
+
+    const lines = this.truncateFailedConsoleOutputLines(consoleOutput)
+
+    if (lines.length === 0) return
+
+    console.error(picocolors.red(`${leftPadding}  Console output:`))
+
+    for (const line of lines) {
+      console.error(picocolors.red(`${leftPadding}    ${line}`))
     }
+  }
+
+  /**
+   * Runs start console capture.
+   * @param {object} [args] - Options object.
+   * @param {boolean} [args.passthrough] - Whether to pass through to the original console.
+   * @returns {() => string} - Stops the capture and returns captured text.
+   */
+  startConsoleCapture({passthrough = false} = {}) {
     /**
-     * Runs truncate failed console output lines.
-     * @param {string} consoleOutput - Console output.
-     * @returns {string[]} - Lines for inline output.
-     */
-    truncateFailedConsoleOutputLines(consoleOutput) {
-        const lines = consoleOutput.split("\n");
-        const maxLines = this.getFailedConsoleOutputMaxLines();
-        if (maxLines === 0)
-            return [];
-        if (lines.length <= maxLines)
-            return lines;
-        const omittedLines = lines.length - maxLines;
-        const plural = omittedLines === 1 ? "" : "s";
-        return [
-            `... ${omittedLines} console output line${plural} omitted ...`,
-            ...lines.slice(-maxLines)
-        ];
-    }
+     * Lines.
+      @type {string[]} */
+    const lines = []
+    /**
+     * Console object.
+      @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */
+    const consoleObject = /**
+                           * Narrows the runtime value to the documented type.
+                            @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */ (console)
     /**
-     * Runs print failed console output.
-     * @param {object} args - Options object.
-     * @param {string} args.consoleOutput - Console output.
-     * @param {string} args.leftPadding - Left padding.
-     * @returns {void} - No return value.
-     */
-    printFailedConsoleOutput({ consoleOutput, leftPadding }) {
-        if (testConfig.consoleOutput !== "failure")
-            return;
-        if (!consoleOutput)
-            return;
-        const lines = this.truncateFailedConsoleOutputLines(consoleOutput);
-        if (lines.length === 0)
-            return;
-        console.error(picocolors.red(`${leftPadding}  Console output:`));
-        for (const line of lines) {
-            console.error(picocolors.red(`${leftPadding}    ${line}`));
+     * Original console methods.
+      @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */
+    const originalConsoleMethods = {
+      debug: consoleObject.debug.bind(console),
+      error: consoleObject.error.bind(console),
+      info: consoleObject.info.bind(console),
+      log: consoleObject.log.bind(console),
+      warn: consoleObject.warn.bind(console)
+    }
+    let stopped = false
+    let outputText = ""
+
+    for (const methodName of CAPTURED_CONSOLE_METHODS) {
+      consoleObject[methodName] = (...args) => {
+        lines.push(`[${new Date().toISOString()}] [${methodName}] ${format(...args)}`)
+
+        if (passthrough) {
+          originalConsoleMethods[methodName](...args)
         }
+      }
     }
-    /**
-     * Runs start console capture.
-     * @param {object} [args] - Options object.
-     * @param {boolean} [args.passthrough] - Whether to pass through to the original console.
-     * @returns {() => string} - Stops the capture and returns captured text.
-     */
-    startConsoleCapture({ passthrough = false } = {}) {
-        /**
-         * Lines.
-          @type {string[]} */
-        const lines = [];
-        /**
-         * Console object.
-          @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */
-        const consoleObject = /**
-                               * Narrows the runtime value to the documented type.
-                                @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */ (console);
-        /**
-         * Original console methods.
-          @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */
-        const originalConsoleMethods = {
-            debug: consoleObject.debug.bind(console),
-            error: consoleObject.error.bind(console),
-            info: consoleObject.info.bind(console),
-            log: consoleObject.log.bind(console),
-            warn: consoleObject.warn.bind(console)
-        };
-        let stopped = false;
-        let outputText = "";
+
+    return () => {
+      if (!stopped) {
+        stopped = true
+
         for (const methodName of CAPTURED_CONSOLE_METHODS) {
-            consoleObject[methodName] = (...args) => {
-                lines.push(`[${new Date().toISOString()}] [${methodName}] ${format(...args)}`);
-                if (passthrough) {
-                    originalConsoleMethods[methodName](...args);
-                }
-            };
+          consoleObject[methodName] = originalConsoleMethods[methodName]
         }
-        return () => {
-            if (!stopped) {
-                stopped = true;
-                for (const methodName of CAPTURED_CONSOLE_METHODS) {
-                    consoleObject[methodName] = originalConsoleMethods[methodName];
-                }
-                outputText = lines.join("\n");
-            }
-            return outputText;
-        };
+
+        outputText = lines.join("\n")
+      }
+
+      return outputText
     }
+  }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-runner.js","sourceRoot":"","sources":["../../../src/testing/test-runner.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {addTrackedStackToError} from \"../utils/with-tracked-stack.js\"\nimport fs from \"node:fs/promises\"\nimport path from \"path\"\nimport {format} from \"node:util\"\nimport Application from \"../../src/application.js\"\nimport BacktraceCleaner from \"../utils/backtrace-cleaner-node.js\"\nimport RequestClient from \"./request-client.js\"\nimport picocolors from \"picocolors\"\nimport restArgsError from \"../utils/rest-args-error.js\"\nimport {testConfig, testEvents, tests} from \"./test.js\"\nimport {pathToFileURL} from \"url\"\nimport {clearDeliveries} from \"../mailer.js\"\n\n/**\n * Runs run with timeout.\n * @param {Promise<?> | ?} promise - Promise or value.\n * @param {number} timeoutMs - Timeout in milliseconds.\n * @param {string} testDescription - Test description.\n * @returns {Promise<?>} - Resolves or rejects based on timeout or promise result.\n */\nfunction runWithTimeout(promise, timeoutMs, testDescription) {\n  const timeoutSeconds = (timeoutMs / 1000).toFixed(3).replace(/\\.?0+$/, \"\")\n  const timeoutError = new Error(`Timed out after ${timeoutSeconds}s: ${testDescription}`)\n\n  return new Promise((resolve, reject) => {\n    const timeout = setTimeout(() => reject(timeoutError), timeoutMs)\n\n    Promise.resolve(promise).then((result) => {\n      clearTimeout(timeout)\n      resolve(result)\n    }).catch((error) => {\n      clearTimeout(timeout)\n      reject(error)\n    })\n  })\n}\n\n/**\n * ConsoleMethodName type.\n  @typedef {\"log\" | \"info\" | \"warn\" | \"error\" | \"debug\"} ConsoleMethodName */\n\n/**\n * Captured console methods.\n  @type {ConsoleMethodName[]} */\nconst CAPTURED_CONSOLE_METHODS = [\"log\", \"info\", \"warn\", \"error\", \"debug\"]\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/**\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\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} [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 */\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 {function(TestArgs) : (void|Promise<void>)} function - Test callback to execute.\n */\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 {?} error - Failure error.\n * @property {string} [consoleOutput] - Captured console output while test ran.\n * @property {string} [consoleLogPath] - Saved console log path.\n */\n\n/**\n * ActiveAfterAllScopeEntry type.\n * @typedef {object} ActiveAfterAllScopeEntry\n * @property {TestsArgument} tests - Scope test tree.\n * @property {boolean} afterAllsRun - Whether cleanup hooks have run.\n */\n\n/**\n * Defines this typedef.\n * @typedef {function({configuration: import(\"../configuration.js\").default, testArgs: TestArgs, testData: TestData}) : (void|Promise<void>)} AfterBeforeEachCallbackType\n */\n\n/**\n * AfterBeforeEachCallbackObjectType type.\n * @typedef {object} AfterBeforeEachCallbackObjectType\n * @property {AfterBeforeEachCallbackType} callback - Hook callback to execute.\n */\n\n/**\n * Defines this typedef.\n * @typedef {function({configuration: import(\"../configuration.js\").default}) : (void|Promise<void>)} BeforeAfterAllCallbackType\n */\n\n/**\n * BeforeAfterAllCallbackObjectType type.\n * @typedef {object} BeforeAfterAllCallbackObjectType\n * @property {BeforeAfterAllCallbackType} callback - Hook callback to execute.\n */\n\n/**\n * TestsArgument type.\n * @typedef {object} TestsArgument\n * @property {Record<string, TestData>} args - Arguments keyed by test description.\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 {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\nexport default class TestRunner {\n  /**\n   * Narrows the runtime value to the documented type.\n    @type {ActiveAfterAllScopeEntry[]} */\n  _activeAfterAllScopes\n\n  /**\n   * Narrows the runtime value to the documented type.\n    @type {FailedTestDetail[]} */\n  _failedTestDetails\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n   * @param {string[] | string} [args.includeTags] - Tags to include.\n   * @param {Array<string>} args.testFiles - Test files.\n   * @param {Record<string, number[]>} [args.lineFilters] - Line filters by file.\n   * @param {RegExp[]} [args.examplePatterns] - Example patterns.\n   */\n  constructor({configuration, excludeTags, includeTags, testFiles, lineFilters, examplePatterns, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!configuration) throw new Error(\"configuration is required\")\n\n    this._configuration = configuration\n    this._excludeTags = this.normalizeTags(excludeTags)\n    this._excludeTagSet = new Set(this._excludeTags)\n    this._includeTags = this.normalizeTags(includeTags)\n    this._includeTagSet = new Set(this._includeTags)\n    this._testFiles = testFiles\n    this._lineFilters = lineFilters || {}\n    this._examplePatterns = examplePatterns || []\n\n    this._failedTests = 0\n    this._successfulTests = 0\n    this._testsCount = 0\n    this._activeAfterAllScopes = []\n    this._failedTestDetails = []\n  }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"../configuration.js\").default} - The configuration.\n   */\n  getConfiguration() { return this._configuration }\n\n  /**\n   * Runs get test files.\n   * @returns {string[]} - The test files.\n   */\n  getTestFiles() { return this._testFiles }\n\n  /**\n   * Runs get line filters.\n   * @returns {Record<string, number[]>} - Line filters.\n   */\n  getLineFilters() { return this._lineFilters }\n\n  /**\n   * Runs get example patterns.\n   * @returns {RegExp[]} - Example patterns.\n   */\n  getExamplePatterns() { return this._examplePatterns }\n\n  /**\n   * Runs 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   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runWithDummyIfNeeded(testArgs, callback) {\n    if (!this.hasTag(testArgs, \"dummy\")) {\n      await callback()\n      return\n    }\n\n    if (this.isBrowserTestMode()) {\n      await this.runBrowserDummy(callback)\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    await Dummy.run(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 {() => Promise<void>} callback - Callback to run.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runBrowserDummy(callback) {\n    await this.getConfiguration().ensureConnections({name: \"Test runner browser dummy\"}, async (dbs) => {\n      await this.truncateDatabases(dbs)\n\n      try {\n        await callback()\n      } finally {\n        await this.truncateDatabases(dbs)\n      }\n    })\n  }\n\n  /**\n   * Runs truncate databases.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} dbs - Database connections.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async truncateDatabases(dbs) {\n    for (const identifier of Object.keys(dbs)) {\n      await dbs[identifier].truncateAllTables()\n    }\n  }\n\n  /**\n   * Runs get exclude tag set.\n   * @returns {Set<string>} - Exclude tag set.\n   */\n  getExcludeTagSet() {\n    /**\n     * Config tags.\n      @type {string[]} */\n    const configTags = Array.isArray(testConfig.excludeTags) ? testConfig.excludeTags : []\n\n    return new Set([...this._excludeTags, ...configTags])\n  }\n\n  /**\n   * Runs has matching tag.\n   * @param {string[] | string | undefined} testTags - Test tags.\n   * @param {Set<string>} tagSet - Tag set.\n   * @returns {boolean} - Whether any tags match.\n   */\n  hasMatchingTag(testTags, tagSet) {\n    if (!tagSet.size) return false\n\n    const normalized = this.normalizeTags(testTags)\n\n    for (const tag of normalized) {\n      if (tagSet.has(tag)) return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs has runnable tests.\n   * @param {TestsArgument} tests - Tests.\n   * @param {string[]} [descriptions] - Description stack.\n   * @param {boolean} [lineMatchedInScope] - Whether line matched in scope.\n   * @returns {boolean} - Whether any tests in this scope will run.\n   */\n  hasRunnableTests(tests, descriptions = [], lineMatchedInScope = false) {\n    for (const testDescription in tests.tests) {\n      const testData = tests.tests[testDescription]\n      const testArgs = /**\n                        * Narrows the runtime value to the documented type.\n                         @type {TestArgs} */ (Object.assign({}, testData.args))\n      const includeByLine = lineMatchedInScope || this.matchesLineFilter(testData)\n\n      if (this._onlyFocussed && !testArgs.focus) continue\n      if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine)) continue\n\n      return true\n    }\n\n    for (const subDescription in tests.subs) {\n      const subTest = tests.subs[subDescription]\n      const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(subTest)\n      const nextDescriptions = descriptions.concat([subDescription])\n\n      if (this._onlyFocussed && !subTest.anyTestsFocussed) continue\n      if (this.hasRunnableTests(subTest, nextDescriptions, scopeLineMatch)) return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs should skip test.\n   * @param {TestArgs} testArgs - Test args.\n   * @param {TestData} testData - Test data.\n   * @param {string} testDescription - Test description.\n   * @param {string[]} descriptions - Description stack.\n   * @param {boolean} lineMatchedInScope - Whether line matched in scope.\n   * @returns {boolean} - Whether the test should be skipped.\n   */\n  shouldSkipTest(testArgs, testData, testDescription, descriptions, lineMatchedInScope) {\n    if (this.hasMatchingTag(testArgs.tags, this.getExcludeTagSet())) return true\n\n    if (this._includeTagSet.size > 0 && !testArgs.focus) {\n      if (!this.hasMatchingTag(testArgs.tags, this._includeTagSet)) return true\n    }\n\n    if (this.getExamplePatterns().length > 0) {\n      const fullDescription = this.buildFullDescription(descriptions, testDescription)\n      const matches = this.getExamplePatterns().some((pattern) => {\n        pattern.lastIndex = 0\n        return pattern.test(fullDescription)\n      })\n\n      if (!matches) return true\n    }\n\n    const lineFilters = this.getLineFilters()\n\n    if (Object.keys(lineFilters).length > 0) {\n      if (!lineMatchedInScope && !this.matchesLineFilter(testData)) return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs matches line filter.\n   * @param {TestData | TestsArgument} entry - Test entry.\n   * @returns {boolean} - Whether line filter matches entry.\n   */\n  matchesLineFilter(entry) {\n    if (!entry || !entry.filePath || !entry.line) return false\n\n    const filePath = path.resolve(entry.filePath)\n    const lines = this.getLineFilters()[filePath]\n\n    if (!lines || lines.length === 0) return false\n\n    return lines.includes(entry.line)\n  }\n\n  /**\n   * Runs build full description.\n   * @param {string[]} descriptions - Description stack.\n   * @param {string} testDescription - Test description.\n   * @returns {string} - Full description.\n   */\n  buildFullDescription(descriptions, testDescription) {\n    const parts = descriptions.concat([testDescription])\n\n    return parts.join(\" \").trim()\n  }\n\n  /**\n   * Runs application.\n   * @returns {Promise<Application>} - Resolves with the application.\n   */\n  async application() {\n    if (!this._application) {\n      this._application = new Application({\n        configuration: this.getConfiguration(),\n        httpServer: {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   * 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    await this.getConfiguration().getEnvironmentHandler().importTestFiles(this.getTestFiles())\n  }\n\n  /**\n   * Runs is failed.\n   * @returns {boolean} - Whether failed.\n   */\n  isFailed() { return this._failedTests !== undefined && this._failedTests > 0 }\n\n  /**\n   * Runs get failed tests.\n   * @returns {number} - The failed tests.\n   */\n  getFailedTests() {\n    if (this._failedTests === undefined) throw new Error(\"Tests hasn't been run yet\")\n\n    return this._failedTests\n  }\n\n  /**\n   * Runs get failed test details.\n   * @returns {FailedTestDetail[]} - Failed test details.\n   */\n  getFailedTestDetails() {\n    return this._failedTestDetails\n  }\n\n  /**\n   * Runs persist failed test console outputs to assets.\n   * @param {object} [args] - Options object.\n   * @param {string} [args.assetsPath] - Assets directory path.\n   * @returns {Promise<string[]>} - Written log file paths.\n   */\n  async persistFailedTestConsoleOutputsToAssets({assetsPath = path.join(process.cwd(), \"tmp/screenshots\")} = {}) {\n    const failedTestDetails = this.getFailedTestDetails()\n    const writtenLogPaths = []\n    let createdDirectory = false\n\n    for (let index = 0; index < failedTestDetails.length; index++) {\n      const failedTestDetail = failedTestDetails[index]\n      const consoleOutput = failedTestDetail.consoleOutput\n\n      if (!consoleOutput) continue\n\n      if (!createdDirectory) {\n        await fs.mkdir(assetsPath, {recursive: true})\n        createdDirectory = true\n      }\n\n      const now = new Date()\n      const timestamp = [\n        String(now.getFullYear()),\n        String(now.getMonth() + 1).padStart(2, \"0\"),\n        String(now.getDate()).padStart(2, \"0\"),\n        String(now.getHours()).padStart(2, \"0\"),\n        String(now.getMinutes()).padStart(2, \"0\"),\n        String(now.getSeconds()).padStart(2, \"0\"),\n        String(now.getMilliseconds()).padStart(3, \"0\")\n      ].join(\"\")\n      const slug = toFileSlug(failedTestDetail.fullDescription)\n      const fileName = `${timestamp}-${String(index + 1).padStart(2, \"0\")}-${slug}.console.log`\n      const filePath = path.join(assetsPath, fileName)\n\n      await fs.writeFile(filePath, consoleOutput, \"utf8\")\n      failedTestDetail.consoleLogPath = filePath\n      writtenLogPaths.push(filePath)\n    }\n\n    return writtenLogPaths\n  }\n\n  /**\n   * Runs get successful tests.\n   * @returns {number} - The successful tests.\n   */\n  getSuccessfulTests() {\n    if (this._successfulTests === undefined) throw new Error(\"Tests hasn't been run yet\")\n\n    return this._successfulTests\n  }\n\n  /**\n   * Runs get tests count.\n   * @returns {number} - The tests count.\n   */\n  getTestsCount() {\n    if (this._testsCount === undefined) throw new Error(\"Tests hasn't been run yet\")\n\n    return this._testsCount\n  }\n\n  /**\n   * Runs get executed tests count.\n   * @returns {number} - The executed tests count.\n   */\n  getExecutedTestsCount() {\n    if (this._successfulTests === undefined || this._failedTests === undefined) {\n      throw new Error(\"Tests hasn't been run yet\")\n    }\n\n    return this._successfulTests + this._failedTests\n  }\n\n  /**\n   * Runs prepare.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async prepare() {\n    this.anyTestsFocussed = false\n    this._failedTests = 0\n    this._successfulTests = 0\n    this._testsCount = 0\n    this._failedTestDetails = []\n    await this.importTestFiles()\n    await this.analyzeTests(tests)\n    this._onlyFocussed = this.anyTestsFocussed\n\n    const testingConfigPath = this.getConfiguration().getTesting()\n\n    if (testingConfigPath) {\n      await this.getConfiguration().getEnvironmentHandler().importTestingConfigPath()\n    }\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  async run() {\n    await this.getConfiguration().ensureConnections({name: \"Test runner suite\"}, async () => {\n      await this.runTests({\n        afterEaches: [],\n        beforeEaches: [],\n        tests,\n        descriptions: [],\n        indentLevel: 0\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 scopes = [...this._activeAfterAllScopes].reverse()\n\n    for (const scope of scopes) {\n      await this.runAfterAllsForScope(scope)\n    }\n\n    this._activeAfterAllScopes = []\n  }\n\n  /**\n   * Runs analyze tests.\n   * @param {TestsArgument} tests - Tests.\n   * @returns {{anyTestsFocussed: boolean}} - Whether any tests in the tree are focused.\n   */\n  analyzeTests(tests) {\n    let anyTestsFocussedFound = false\n\n    for (const testDescription in tests.tests) {\n      const testData = tests.tests[testDescription]\n      const testArgs = Object.assign({}, testData.args)\n\n      this._testsCount++\n\n      if (testArgs.focus) {\n        anyTestsFocussedFound = true\n        this.anyTestsFocussed = true\n      }\n    }\n\n    for (const subDescription in tests.subs) {\n      const subTest = tests.subs[subDescription]\n      const {anyTestsFocussed} = this.analyzeTests(subTest)\n\n      if (anyTestsFocussed) {\n        anyTestsFocussedFound = true\n      }\n\n      subTest.anyTestsFocussed = anyTestsFocussed\n    }\n\n    return {anyTestsFocussed: anyTestsFocussedFound}\n  }\n\n  /**\n   * Runs run tests.\n   * @param {object} args - Options object.\n   * @param {Array<AfterBeforeEachCallbackObjectType>} args.afterEaches - After eaches.\n   * @param {Array<AfterBeforeEachCallbackObjectType>} args.beforeEaches - Before eaches.\n   * @param {TestsArgument} args.tests - Tests.\n   * @param {string[]} args.descriptions - Descriptions.\n   * @param {number} args.indentLevel - Indent level.\n   * @param {boolean} [args.lineMatchedInScope] - Whether line matched in scope.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async runTests({afterEaches, beforeEaches, tests, descriptions, indentLevel, lineMatchedInScope = false}) {\n    const leftPadding = \" \".repeat(indentLevel * 2)\n    const newAfterEaches = [...afterEaches, ...tests.afterEaches]\n    const newBeforeEaches = [...beforeEaches, ...tests.beforeEaches]\n    const scopeLineMatch = lineMatchedInScope || this.matchesLineFilter(tests)\n    const shouldRunAnyTests = this.hasRunnableTests(tests, descriptions, scopeLineMatch)\n\n    if (!shouldRunAnyTests) return\n\n    /** Scope entry. @type {ActiveAfterAllScopeEntry} */\n    const scopeEntry = {tests, afterAllsRun: false}\n    this._activeAfterAllScopes.push(scopeEntry)\n\n    try {\n      for (const beforeAllData of tests.beforeAlls || []) {\n        await beforeAllData.callback({configuration: this.getConfiguration()})\n      }\n\n      for (const testDescription in tests.tests) {\n        const testData = tests.tests[testDescription]\n        const testArgs = /**\n                          * Narrows the runtime value to the documented type.\n                           @type {TestArgs} */ (Object.assign({}, testData.args))\n        const includeByLine = scopeLineMatch || this.matchesLineFilter(testData)\n\n        if (this._onlyFocussed && !testArgs.focus) continue\n        if (this.shouldSkipTest(testArgs, testData, testDescription, descriptions, includeByLine)) continue\n\n        if (testArgs.type == \"model\" || testArgs.type == \"request\") {\n          testArgs.application = await this.application()\n        }\n\n        if (testArgs.type == \"request\") {\n          testArgs.client = await this.requestClient()\n        }\n\n        const retryCount = typeof testArgs.retry === \"number\" && Number.isFinite(testArgs.retry)\n          ? Math.max(0, Math.floor(testArgs.retry))\n          : 0\n        const configTimeoutSeconds = typeof testConfig.defaultTimeoutSeconds === \"number\" ? testConfig.defaultTimeoutSeconds : undefined\n        const timeoutSeconds = typeof testArgs.timeoutSeconds === \"number\" ? testArgs.timeoutSeconds : configTimeoutSeconds\n        const useTimeout = typeof timeoutSeconds === \"number\" && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0\n        const timeoutMs = useTimeout ? timeoutSeconds * 1000 : undefined\n        let retriesUsed = 0\n        let attemptNumber = 1\n        /**\n         * Attempt console outputs.\n          @type {AttemptConsoleOutput[]} */\n        const attemptConsoleOutputs = []\n\n        console.log(`${leftPadding}it ${testDescription}`)\n\n        while (true) {\n          let shouldRetry = false\n          /**\n           * Defines caughtError.\n            @type {?} */\n          let caughtError\n          /**\n           * Defines failedError.\n            @type {?} */\n          let failedError\n          /**\n           * Defines lastError.\n            @type {?} */\n          let lastError\n          let willRetry = false\n          const stopConsoleCapture = this.startConsoleCapture({\n            passthrough: testConfig.consoleOutput === \"live\"\n          })\n\n          try {\n            // Run the whole per-test lifecycle (dummy/server startup, connection\n            // acquisition, beforeEach hooks, the test body and afterEach hooks) as\n            // one promise so the timeout below can cover all of it.\n            const testLifecycle = this.runWithDummyIfNeeded(testArgs, async () => {\n              // Pin one connection per test so beforeEach, the test body and afterEach\n              // all run on the SAME connection. This is required for transaction-based\n              // database cleaning (beforeEach starts a transaction, afterEach rolls it\n              // back). ensureConnections reuses the suite-level pinned connection while\n              // it is healthy and transparently re-establishes a per-test pin if an\n              // earlier spec closed the suite connection (which would otherwise leave a\n              // stale async-context pin and force every later test onto a fresh checkout,\n              // breaking isolation).\n              await this.getConfiguration().ensureConnections({name: `Test: ${testDescription}`}, async () => {\n                try {\n                  clearDeliveries()\n                  for (const beforeEachData of newBeforeEaches) {\n                    await beforeEachData.callback({configuration: this.getConfiguration(), testArgs, testData})\n                  }\n\n                  await testData.function(testArgs)\n                  this._successfulTests++\n                } finally {\n                  for (const afterEachData of newAfterEaches) {\n                    await afterEachData.callback({configuration: this.getConfiguration(), testArgs, testData})\n                  }\n                }\n              })\n            })\n\n            // Time out the ENTIRE lifecycle, not just the test body. A hang in any\n            // phase — a connection checkout that never resolves, a beforeEach/afterEach\n            // waiting on a lock, or dummy server startup — would otherwise stall the\n            // whole run indefinitely (until CI kills the build) instead of failing the\n            // single offending test.\n            if (useTimeout && timeoutMs !== undefined) {\n              await runWithTimeout(testLifecycle, timeoutMs, testDescription)\n            } else {\n              await testLifecycle\n            }\n          } catch (error) {\n            caughtError = error\n            lastError = error\n            willRetry = retriesUsed < retryCount\n\n            if (willRetry) {\n              retriesUsed++\n            }\n\n            if (willRetry) {\n              shouldRetry = true\n            } else {\n              failedError = error\n            }\n          } finally {\n            const consoleOutput = stopConsoleCapture()\n\n            if (consoleOutput) {\n              attemptConsoleOutputs.push({attemptNumber, output: consoleOutput})\n            }\n          }\n\n          if (caughtError !== undefined) {\n            await this.emitEvent(\"testAttemptFailed\", {\n              configuration: this.getConfiguration(),\n              descriptions,\n              error: caughtError,\n              attemptNumber,\n              nextAttempt: willRetry ? attemptNumber + 1 : undefined,\n              retriesUsed,\n              retryCount,\n              testArgs,\n              testData,\n              testDescription,\n              testRunner: this,\n              willRetry\n            })\n          }\n\n          if (shouldRetry) {\n            console.warn(picocolors.red(`${leftPadding}  Retrying (${retriesUsed}/${retryCount}) after error: ${lastError instanceof Error ? lastError.message : String(lastError)}`))\n            await this.emitEvent(\"testRetrying\", {\n              configuration: this.getConfiguration(),\n              descriptions,\n              error: lastError,\n              nextAttempt: attemptNumber + 1,\n              retriesUsed,\n              retryCount,\n              testArgs,\n              testData,\n              testDescription,\n              testRunner: this\n            })\n          }\n\n          if (attemptNumber > 1) {\n            await this.emitEvent(\"testRetried\", {\n              configuration: this.getConfiguration(),\n              descriptions,\n              error: lastError,\n              attemptNumber,\n              retriesUsed,\n              retryCount,\n              testArgs,\n              testData,\n              testDescription,\n              testRunner: this\n            })\n          }\n\n          attemptNumber++\n\n          if (shouldRetry) continue\n\n          if (failedError) {\n            const consoleOutput = this.buildConsoleOutput(attemptConsoleOutputs)\n\n            if (failedError instanceof Error) {\n              console.error(picocolors.red(`${leftPadding}  Test failed: ${failedError.message}`))\n              addTrackedStackToError(failedError)\n\n              const backtraceCleaner = new BacktraceCleaner(failedError)\n              const cleanedStack = backtraceCleaner.getCleanedStack()\n              const stackLines = cleanedStack?.split(\"\\n\")\n\n              if (stackLines) {\n                for (const stackLine of stackLines) {\n                  console.error(picocolors.red(`${leftPadding}  ${stackLine}`))\n                }\n              }\n            } else {\n              console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof failedError}: ${String(failedError)}`))\n            }\n\n            this.printFailedConsoleOutput({consoleOutput, leftPadding})\n            this._failedTests++\n            this._failedTestDetails.push({\n              fullDescription: this.buildFullDescription(descriptions, testDescription),\n              filePath: testData.filePath,\n              line: testData.line,\n              error: failedError,\n              consoleOutput: consoleOutput || undefined\n            })\n\n            await this.emitEvent(\"testFailed\", {\n              configuration: this.getConfiguration(),\n              descriptions,\n              error: failedError,\n              testArgs,\n              testData,\n              testDescription,\n              testRunner: this\n            })\n\n            this.printRerunCommand({descriptions, testDescription, testData, leftPadding})\n          }\n\n          break\n        }\n      }\n\n      for (const subDescription in tests.subs) {\n        const subTest = tests.subs[subDescription]\n        const newDecriptions = descriptions.concat([subDescription])\n        const childScopeLineMatch = scopeLineMatch || this.matchesLineFilter(subTest)\n\n        if (!this._onlyFocussed || subTest.anyTestsFocussed) {\n          console.log(`${leftPadding}${subDescription}`)\n          await this.runTests({\n            afterEaches: newAfterEaches,\n            beforeEaches: newBeforeEaches,\n            tests: subTest,\n            descriptions: newDecriptions,\n            indentLevel: indentLevel + 1,\n            lineMatchedInScope: childScopeLineMatch\n          })\n        }\n      }\n    } finally {\n      await this.runAfterAllsForScope(scopeEntry)\n      const scopeIndex = this._activeAfterAllScopes.indexOf(scopeEntry)\n\n      if (scopeIndex >= 0) {\n        this._activeAfterAllScopes.splice(scopeIndex, 1)\n      }\n    }\n  }\n\n  /**\n   * Runs run after alls for scope.\n   * @param {ActiveAfterAllScopeEntry} scopeEntry - Scope entry.\n   * @returns {Promise<void>} - Resolves when scope cleanup finishes.\n   */\n  async runAfterAllsForScope(scopeEntry) {\n    if (scopeEntry.afterAllsRun) return\n\n    scopeEntry.afterAllsRun = true\n\n    for (const afterAllData of scopeEntry.tests.afterAlls || []) {\n      await afterAllData.callback({configuration: this.getConfiguration()})\n    }\n  }\n\n  /**\n   * Runs emit event.\n   * @param {string} eventName - Event name.\n   * @param {object} payload - Event payload.\n   * @returns {Promise<void>} - Resolves when all listeners complete.\n   */\n  async emitEvent(eventName, payload) {\n    const listeners = testEvents.listeners(eventName)\n\n    for (const listener of listeners) {\n      await listener(payload)\n    }\n  }\n\n  /**\n   * Runs print rerun command.\n   * @param {object} args - Options object.\n   * @param {string[]} args.descriptions - Description stack.\n   * @param {string} args.testDescription - Test description.\n   * @param {TestData} args.testData - Test data.\n   * @param {string} args.leftPadding - Left padding.\n   * @returns {void} - No return value.\n   */\n  printRerunCommand({descriptions, testDescription, testData, leftPadding}) {\n    const rerun = this.buildRerunCommand({descriptions, testDescription, testData})\n\n    if (rerun) {\n      console.error(`${leftPadding}  Re-run: ${rerun}`)\n    }\n  }\n\n  /**\n   * Runs build rerun command.\n   * @param {object} args - Options object.\n   * @param {string[]} args.descriptions - Description stack.\n   * @param {string} args.testDescription - Test description.\n   * @param {TestData} args.testData - Test data.\n   * @returns {string | undefined} - Rerun command.\n   */\n  buildRerunCommand({descriptions, testDescription, testData}) {\n    const baseCommand = \"npx velocious test\"\n    const filePath = testData.filePath\n    const line = testData.line\n\n    if (filePath && line) {\n      const relativePath = path.relative(process.cwd(), filePath)\n      return `${baseCommand} ${relativePath}:${line}`\n    }\n\n    const fullDescription = this.buildFullDescription(descriptions, testDescription)\n\n    if (fullDescription) {\n      return `${baseCommand} --example ${JSON.stringify(fullDescription)}`\n    }\n\n    return undefined\n  }\n\n  /**\n   * Runs build console output.\n   * @param {AttemptConsoleOutput[]} attemptConsoleOutputs - Attempt output entries.\n   * @returns {string} - Combined console output.\n   */\n  buildConsoleOutput(attemptConsoleOutputs) {\n    if (attemptConsoleOutputs.length === 0) return \"\"\n    if (attemptConsoleOutputs.length === 1) return attemptConsoleOutputs[0].output\n\n    return attemptConsoleOutputs.map((attemptConsoleOutput) => {\n      return `--- Attempt ${attemptConsoleOutput.attemptNumber} ---\\n${attemptConsoleOutput.output}`\n    }).join(\"\\n\")\n  }\n\n  /**\n   * Runs get failed console output max lines.\n   * @returns {number} - Maximum failed console lines.\n   */\n  getFailedConsoleOutputMaxLines() {\n    const maxLines = testConfig.failedConsoleOutputMaxLines\n\n    if (typeof maxLines !== \"number\" || !Number.isFinite(maxLines)) return 200\n\n    return Math.max(0, Math.floor(maxLines))\n  }\n\n  /**\n   * Runs truncate failed console output lines.\n   * @param {string} consoleOutput - Console output.\n   * @returns {string[]} - Lines for inline output.\n   */\n  truncateFailedConsoleOutputLines(consoleOutput) {\n    const lines = consoleOutput.split(\"\\n\")\n    const maxLines = this.getFailedConsoleOutputMaxLines()\n\n    if (maxLines === 0) return []\n    if (lines.length <= maxLines) return lines\n\n    const omittedLines = lines.length - maxLines\n    const plural = omittedLines === 1 ? \"\" : \"s\"\n\n    return [\n      `... ${omittedLines} console output line${plural} omitted ...`,\n      ...lines.slice(-maxLines)\n    ]\n  }\n\n  /**\n   * Runs print failed console output.\n   * @param {object} args - Options object.\n   * @param {string} args.consoleOutput - Console output.\n   * @param {string} args.leftPadding - Left padding.\n   * @returns {void} - No return value.\n   */\n  printFailedConsoleOutput({consoleOutput, leftPadding}) {\n    if (testConfig.consoleOutput !== \"failure\") return\n    if (!consoleOutput) return\n\n    const lines = this.truncateFailedConsoleOutputLines(consoleOutput)\n\n    if (lines.length === 0) return\n\n    console.error(picocolors.red(`${leftPadding}  Console output:`))\n\n    for (const line of lines) {\n      console.error(picocolors.red(`${leftPadding}    ${line}`))\n    }\n  }\n\n  /**\n   * Runs start console capture.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.passthrough] - Whether to pass through to the original console.\n   * @returns {() => string} - Stops the capture and returns captured text.\n   */\n  startConsoleCapture({passthrough = false} = {}) {\n    /**\n     * Lines.\n      @type {string[]} */\n    const lines = []\n    /**\n     * Console object.\n      @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */\n    const consoleObject = /**\n                           * Narrows the runtime value to the documented type.\n                            @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */ (console)\n    /**\n     * Original console methods.\n      @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */\n    const originalConsoleMethods = {\n      debug: consoleObject.debug.bind(console),\n      error: consoleObject.error.bind(console),\n      info: consoleObject.info.bind(console),\n      log: consoleObject.log.bind(console),\n      warn: consoleObject.warn.bind(console)\n    }\n    let stopped = false\n    let outputText = \"\"\n\n    for (const methodName of CAPTURED_CONSOLE_METHODS) {\n      consoleObject[methodName] = (...args) => {\n        lines.push(`[${new Date().toISOString()}] [${methodName}] ${format(...args)}`)\n\n        if (passthrough) {\n          originalConsoleMethods[methodName](...args)\n        }\n      }\n    }\n\n    return () => {\n      if (!stopped) {\n        stopped = true\n\n        for (const methodName of CAPTURED_CONSOLE_METHODS) {\n          consoleObject[methodName] = originalConsoleMethods[methodName]\n        }\n\n        outputText = lines.join(\"\\n\")\n      }\n\n      return outputText\n    }\n  }\n}\n"]}