velocious 1.0.644 → 1.0.646

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

@@ -3,7 +3,9 @@
 import { TestDatabaseAccessRevokedError } from "../environment-handlers/base.js"
 import { clearDeliveries } from "../mailer.js"
 import restArgsError from "../utils/rest-args-error.js"
-import { testConfig } from "./test.js"
+import {clearTimeout as realClearTimeout, setTimeout as realSetTimeout} from "node:timers"
+
+/** @typedef {import("@velocious/testing/runner").AttemptExecutorInput["beforeEach"][number]} PackageHookDeclaration */
 
 /**
  * Marks one whole-lifecycle timeout while its underlying promise keeps running.
@@ -24,13 +26,13 @@ function runWithTimeout(promise, timeoutMs, testDescription) {
   timeoutError.velociousTestTimeout = true
 
   return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => reject(timeoutError), timeoutMs)
+    const timeout = realSetTimeout(() => reject(timeoutError), timeoutMs)
 
     Promise.resolve(promise).then((result) => {
-      clearTimeout(timeout)
+      realClearTimeout(timeout)
       resolve(result)
     }).catch((error) => {
-      clearTimeout(timeout)
+      realClearTimeout(timeout)
       reject(error)
     })
   })
@@ -45,7 +47,7 @@ function runWithTimeout(promise, timeoutMs, testDescription) {
 function awaitSettledOrGrace(lifecycle, graceMs) {
   return new Promise((resolve) => {
     let settled = false
-    const graceTimer = setTimeout(() => {
+    const graceTimer = realSetTimeout(() => {
       if (settled) return
 
       settled = true
@@ -57,14 +59,14 @@ function awaitSettledOrGrace(lifecycle, graceMs) {
         if (settled) return
 
         settled = true
-        clearTimeout(graceTimer)
+        realClearTimeout(graceTimer)
         resolve({settled: true, status: "fulfilled"})
       },
       (reason) => {
         if (settled) return
 
         settled = true
-        clearTimeout(graceTimer)
+        realClearTimeout(graceTimer)
         resolve({settled: true, status: "rejected", reason})
       }
     )
@@ -96,22 +98,31 @@ export default class VelociousAttemptExecutor {
     this.testRunner = testRunner
   }
 
+  /**
+   * Normalizes the legacy timeout contract at the framework adapter boundary.
+   * @param {number | undefined} timeoutMs - Declared package timeout.
+   * @returns {number | undefined} - Positive finite timeout, or no timeout.
+   */
+  normalizeTimeoutMs(timeoutMs) {
+    return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined
+  }
+
   /**
    * Executes exactly one complete Velocious-owned test attempt.
-   * @param {object} args - Attempt arguments.
-   * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.afterEaches - Cleanup hooks.
-   * @param {number} args.attemptNumber - One-based attempt number.
-   * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.beforeEaches - Setup hooks.
-   * @param {string[]} args.descriptions - Parent descriptions.
-   * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
-   * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
-   * @param {string} args.testDescription - Test description.
-   * @param {number} [args.timeoutMs] - Whole-lifecycle timeout.
-   * @returns {Promise<{abortRemainingTests: boolean, consoleOutput: string, error: ReturnType<typeof JSON.parse>, failed: boolean}>} - Attempt outcome.
+   * @param {import("@velocious/testing/runner").AttemptExecutorInput} input - Package attempt.
+   * @returns {Promise<void>} - Resolves after one complete framework attempt.
    */
-  async execute({afterEaches, attemptNumber, beforeEaches, descriptions, testArgs, testData, testDescription, timeoutMs, ...restArgs}) {
+  async execute({afterEach, args, attemptNumber, beforeEach, context, defaultExecute, fullName, suite, test, timeoutMs, ...restArgs}) {
     restArgsError(restArgs)
+    void context
+    void defaultExecute
+    void suite
     const testRunner = this.testRunner
+    const effectiveTimeoutMs = this.normalizeTimeoutMs(timeoutMs)
+    const compatibility = await testRunner.testCompatibility(test)
+    const {testArgs, testData} = compatibility
+    const metadata = testRunner.testMetadata(test)
+    const {descriptions, testDescription} = metadata
     /** @type {ReturnType<typeof JSON.parse>} */
     let caughtError
     let failed = false
@@ -133,14 +144,9 @@ export default class VelociousAttemptExecutor {
     const recordedTimeoutCleanupErrors = new Set()
     let abortRemainingTests = false
     let attemptTimedOut = false
-    /** @type {string} */
-    let consoleOutput
     testArgs.registerTransactionalTenant = async (args) => {
       await testRunner.registerTransactionalTenant(args, transactionalTenantRegistrations)
     }
-    const stopConsoleCapture = testRunner.startConsoleCapture({
-      passthrough: testConfig.consoleOutput === "live"
-    })
     const profiler = testRunner._profiler
     const profileAttempt = profiler?.startAttempt({
       descriptions,
@@ -171,7 +177,7 @@ export default class VelociousAttemptExecutor {
             runCleanupHooks = true
 
             clearDeliveries()
-            await this.runBeforeEaches({beforeEaches, testArgs, testData})
+            await this.runBeforeEaches({beforeEaches: beforeEach, testArgs, testData})
 
             if (useSharedTestConnections) {
               const activeConnections = testRunner.sharedTransactionConnections({transactionsOnly: true})
@@ -190,12 +196,12 @@ export default class VelociousAttemptExecutor {
             }
 
             testRunner._lastTestContext = {
-              fullDescription: testRunner.buildFullDescription(descriptions, testDescription),
+              fullDescription: fullName,
               filePath: testData.filePath ?? "<unknown>",
               line: testData.line ?? 0
             }
             await testRunner.runProfileSpan({phase: "test body", filePath: testData.ownerFilePath ?? testData.filePath}, async () => {
-              await testData.function(testArgs)
+              await test.callback(...args)
             })
           } catch (error) {
             lifecycleErrors.push(error)
@@ -227,7 +233,7 @@ export default class VelociousAttemptExecutor {
             }
 
             try {
-              await this.runAfterEaches({afterEaches, testArgs, testData})
+              await this.runAfterEaches({afterEaches: [...afterEach].reverse(), testArgs, testData})
             } catch (error) {
               lifecycleErrors.push(error)
             }
@@ -265,8 +271,8 @@ export default class VelociousAttemptExecutor {
         ? profiler.runAttempt(profileAttempt, lifecycleCallback)
         : lifecycleCallback()
 
-      if (timeoutMs !== undefined) {
-        await runWithTimeout(testLifecycle, timeoutMs, testDescription)
+      if (effectiveTimeoutMs !== undefined) {
+        await runWithTimeout(testLifecycle, effectiveTimeoutMs, testDescription)
       } else {
         await testLifecycle
       }
@@ -280,7 +286,7 @@ export default class VelociousAttemptExecutor {
         const emergencyCleanupErrors = []
 
         if (profileAttempt && profiler) profiler.finishAttempt(profileAttempt, "timed-out")
-        const lifecycleOutcome = await awaitSettledOrGrace(testLifecycle, timeoutMs ?? 60000)
+        const lifecycleOutcome = await awaitSettledOrGrace(testLifecycle, effectiveTimeoutMs ?? 60000)
 
         if (lifecycleOutcome.settled && lifecycleOutcome.status === "rejected") {
           emergencyCleanupErrors.push(lifecycleOutcome.reason)
@@ -293,7 +299,7 @@ export default class VelociousAttemptExecutor {
             testRunner.recordTimeoutCleanupFailure(cleanupError, "test lifecycle", recordedTimeoutCleanupErrors)
           })
           const quarantine = testRunner.quarantineBrowserDummyConnections(browserDummyConnectionRegistrations)
-          const quarantineOutcome = await awaitSettledOrGrace(quarantine, timeoutMs ?? 60000)
+          const quarantineOutcome = await awaitSettledOrGrace(quarantine, effectiveTimeoutMs ?? 60000)
           const usesBrowserTransactions = testArgs.databaseCleaning?.transaction === true
           const usesBrowserTruncation = testArgs.databaseCleaning?.truncate ?? !usesBrowserTransactions
 
@@ -321,7 +327,7 @@ export default class VelociousAttemptExecutor {
         }
 
         const brokerCleanup = testRunner.stopSharedTransactionBroker(sharedTransactionBrokerRegistration || sharedTransactionBrokerPreparation)
-        const brokerCleanupOutcome = await awaitSettledOrGrace(brokerCleanup, timeoutMs ?? 60000)
+        const brokerCleanupOutcome = await awaitSettledOrGrace(brokerCleanup, effectiveTimeoutMs ?? 60000)
 
         if (brokerCleanupOutcome.settled && brokerCleanupOutcome.status === "rejected") {
           emergencyCleanupErrors.push(brokerCleanupOutcome.reason)
@@ -333,7 +339,7 @@ export default class VelociousAttemptExecutor {
         sharedTransactionBrokerRegistration = undefined
         sharedTransactionBrokerPreparation = undefined
         const emergencyCleanup = testRunner.cleanupTransactionalTenants(transactionalTenantRegistrations, {discard: true})
-        const emergencyCleanupOutcome = await awaitSettledOrGrace(emergencyCleanup, timeoutMs ?? 60000)
+        const emergencyCleanupOutcome = await awaitSettledOrGrace(emergencyCleanup, effectiveTimeoutMs ?? 60000)
 
         if (emergencyCleanupOutcome.settled && emergencyCleanupOutcome.status === "rejected") {
           emergencyCleanupErrors.push(emergencyCleanupOutcome.reason)
@@ -358,7 +364,6 @@ export default class VelociousAttemptExecutor {
       }
     } finally {
       testDatabaseAccessScope.revoked = true
-      consoleOutput = stopConsoleCapture()
 
       if (profileAttempt && profiler) {
         profiler.finishAttempt(profileAttempt, failed
@@ -367,29 +372,32 @@ export default class VelociousAttemptExecutor {
       }
     }
 
-    return {
+    testRunner.recordAttemptOutcome(test, attemptNumber, {
       abortRemainingTests,
-      consoleOutput,
       error: caughtError,
       failed
-    }
+    })
+
+    if (failed) throw caughtError
   }
 
   /**
    * Runs before-each hooks in inherited declaration order.
    * @param {object} args - Hook arguments.
-   * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.beforeEaches - Setup hooks.
+   * @param {PackageHookDeclaration[]} args.beforeEaches - Setup hooks.
    * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
    * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
    * @returns {Promise<void>} - Resolves after all setup hooks complete.
    */
   async runBeforeEaches({beforeEaches, testArgs, testData}) {
     for (const hook of beforeEaches) {
+      const metadata = this.testRunner.hookMetadata(hook)
+
       await this.testRunner.runProfileSpan({
         phase: "beforeEach",
-        declarationIndex: hook.declarationIndex,
-        declarationScopeId: hook.declarationScopeId,
-        filePath: hook.ownerFilePath
+        declarationIndex: metadata.declarationIndex,
+        declarationScopeId: metadata.declarationScopeId,
+        filePath: metadata.ownerFilePath
       }, async () => {
         await hook.callback({configuration: this.testRunner.getConfiguration(), testArgs, testData})
       })
@@ -399,7 +407,7 @@ export default class VelociousAttemptExecutor {
   /**
    * Runs every after-each hook while preserving all failures.
    * @param {object} args - Hook arguments.
-   * @param {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} args.afterEaches - Cleanup hooks.
+   * @param {PackageHookDeclaration[]} args.afterEaches - Cleanup hooks.
    * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
    * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
    * @returns {Promise<void>} - Resolves after every cleanup hook settles.
@@ -409,12 +417,14 @@ export default class VelociousAttemptExecutor {
     const errors = []
 
     for (const hook of afterEaches) {
+      const metadata = this.testRunner.hookMetadata(hook)
+
       try {
         await this.testRunner.runProfileSpan({
           phase: "afterEach",
-          declarationIndex: hook.declarationIndex,
-          declarationScopeId: hook.declarationScopeId,
-          filePath: hook.ownerFilePath
+          declarationIndex: metadata.declarationIndex,
+          declarationScopeId: metadata.declarationScopeId,
+          filePath: metadata.ownerFilePath
         }, async () => {
           await hook.callback({configuration: this.testRunner.getConfiguration(), testArgs, testData})
         })

package/src/testing/velocious-runner-reporter.js

@@ -6,6 +6,11 @@ import picocolors from "picocolors"
 import restArgsError from "../utils/rest-args-error.js"
 import { testEvents } from "./test.js"
 
+/** @typedef {import("@velocious/testing/runner").TestDeclaration} PackageTestDeclaration */
+
+/** Stops package traversal after framework-owned connection quarantine. */
+export class AbortRemainingTestsError extends Error {}
+
 export default class VelociousRunnerReporter {
   /**
    * Creates the legacy event and result projection adapter.
@@ -15,83 +20,189 @@ export default class VelociousRunnerReporter {
   constructor({testRunner, ...restArgs}) {
     restArgsError(restArgs)
     this.testRunner = testRunner
+    /** @type {WeakMap<PackageTestDeclaration, import("./test-runner.js").AttemptConsoleOutput[]>} */
+    this.attemptConsoleOutputs = new WeakMap()
+    /** @type {PackageTestDeclaration | undefined} */
+    this.activeTest = undefined
   }
 
   /**
-   * Projects one completed attempt into legacy events and final result accounting.
-   * Retry eligibility is decided by the caller before this method runs.
-   * @param {object} args - Completed attempt and retry metadata.
-   * @param {import("./test-runner.js").AttemptConsoleOutput[]} args.attemptConsoleOutputs - Captured output across attempts.
-   * @param {number} args.attemptNumber - Current one-based attempt.
-   * @param {string[]} args.descriptions - Parent description stack.
-   * @param {ReturnType<typeof JSON.parse>} args.error - Raw thrown or rejected value.
-   * @param {boolean} args.failed - Whether the attempt failed, independently of error truthiness.
-   * @param {string} args.leftPadding - Console indentation.
-   * @param {number} args.retriesUsed - Retry count consumed after this attempt.
-   * @param {number} args.retryCount - Configured retry limit.
-   * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
-   * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
-   * @param {string} args.testDescription - Test description.
-   * @param {boolean} args.willRetry - Whether the legacy loop will run another attempt.
-   * @returns {Promise<void>} - Resolves after all legacy listeners complete.
+   * Translates one awaited package runner event into the legacy contract.
+   * @param {import("@velocious/testing/runner").RunnerEvent} event - Structured package event.
+   * @returns {Promise<void>} - Resolves after legacy listeners finish.
    */
-  async reportAttempt({attemptConsoleOutputs, attemptNumber, descriptions, error, failed, leftPadding, retriesUsed, retryCount, testArgs, testData, testDescription, willRetry, ...restArgs}) {
-    restArgsError(restArgs)
-    const testRunner = this.testRunner
+  async onEvent(event) {
+    if (event.type === "test:start") {
+      this.activeTest = this.testRunner.findTestDeclaration(event.fullName)
+      if (this.activeTest) {
+        const metadata = this.testRunner.testMetadata(this.activeTest)
+        console.log(`${" ".repeat(metadata.descriptions.length * 2)}it ${metadata.testDescription}`)
+      }
+      return
+    }
+
+    if (event.type === "attempt:finish") {
+      await this.reportAttemptEvent(event)
+      return
+    }
 
-    if (!failed) testRunner._successfulTests++
+    if (event.type === "test:finish") {
+      await this.reportTestEvent(event)
+      return
+    }
+
+    if (event.type === "run:finish") this.testRunner.recordPackageResult(event.result)
+  }
+
+  /**
+   * Projects attempt failure/retry events while retaining the raw thrown value.
+   * @param {import("@velocious/testing/runner").RunnerEvent} event - Attempt event.
+   * @returns {Promise<void>} - Resolves after listeners finish.
+   */
+  async reportAttemptEvent(event) {
+    const test = this.activeTest || this.testRunner.findTestDeclaration(event.fullName)
+
+    if (!test) throw new Error(`Package runner attempt did not match a declaration: ${event.fullName}`)
+
+    // Narrows the structured event payload for this event discriminator.
+    const attempt = /** @type {import("@velocious/testing/runner").TestAttemptResult} */ (event.attempt)
+    const outcome = this.testRunner.attemptOutcome(test, attempt.attemptNumber)
+    const attemptConsoleOutputs = this.attemptConsoleOutputs.get(test) || []
+
+    if (attempt.consoleOutput) {
+      attemptConsoleOutputs.push({attemptNumber: attempt.attemptNumber, output: attempt.consoleOutput.trimEnd()})
+      this.attemptConsoleOutputs.set(test, attemptConsoleOutputs)
+    }
+
+    const retryCount = this.testRunner.retryCount(test)
+    const failed = outcome?.failed ?? Boolean(attempt.error)
+    const error = outcome?.error
+    const retriesUsed = Math.min(attempt.attemptNumber, retryCount)
+    const willRetry = failed && !outcome?.abortRemainingTests && attempt.attemptNumber <= retryCount
+    const {descriptions, testDescription} = this.testRunner.testMetadata(test)
+    const compatibility = this.testRunner.testData(test)
 
     if (failed) {
       await this.emitEvent("testAttemptFailed", {
-        configuration: testRunner.getConfiguration(),
+        configuration: this.testRunner.getConfiguration(),
         descriptions,
         error,
-        attemptNumber,
-        nextAttempt: willRetry ? attemptNumber + 1 : undefined,
+        attemptNumber: attempt.attemptNumber,
+        nextAttempt: willRetry ? attempt.attemptNumber + 1 : undefined,
         retriesUsed,
         retryCount,
-        testArgs,
-        testData,
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
         testDescription,
-        testRunner,
+        testRunner: this.testRunner,
         willRetry
       })
     }
 
     if (willRetry) {
-      console.warn(picocolors.red(`${leftPadding}  Retrying (${retriesUsed}/${retryCount}) after error: ${error instanceof Error ? error.message : String(error)}`))
+      console.warn(picocolors.red(`${" ".repeat(descriptions.length * 2)}  Retrying (${retriesUsed}/${retryCount}) after error: ${error instanceof Error ? error.message : String(error)}`))
       await this.emitEvent("testRetrying", {
-        configuration: testRunner.getConfiguration(),
+        configuration: this.testRunner.getConfiguration(),
         descriptions,
         error,
-        nextAttempt: attemptNumber + 1,
+        nextAttempt: attempt.attemptNumber + 1,
         retriesUsed,
         retryCount,
-        testArgs,
-        testData,
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
         testDescription,
-        testRunner
+        testRunner: this.testRunner
       })
     }
 
-    if (attemptNumber > 1) {
+    if (attempt.attemptNumber > 1) {
       await this.emitEvent("testRetried", {
-        configuration: testRunner.getConfiguration(),
+        configuration: this.testRunner.getConfiguration(),
         descriptions,
         error,
-        attemptNumber,
+        attemptNumber: attempt.attemptNumber,
         retriesUsed,
         retryCount,
-        testArgs,
-        testData,
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
         testDescription,
-        testRunner
+        testRunner: this.testRunner
+      })
+    }
+
+    if (outcome?.abortRemainingTests) {
+      const metadata = this.testRunner.testMetadata(test)
+
+      this.testRunner.recordTestDuration({
+        durationMs: attempt.durationMs,
+        filePath: compatibility.testData.filePath ?? "<unknown>",
+        fullDescription: metadata.fullDescription,
+        line: compatibility.testData.line ?? 0
+      })
+      await this.reportFailedTest({
+        attemptConsoleOutputs,
+        descriptions,
+        error,
+        leftPadding: " ".repeat(descriptions.length * 2),
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
+        testDescription
+      })
+      this.testRunner.completeTestDeclaration(test)
+      this.activeTest = undefined
+      throw new AbortRemainingTestsError("Velocious quarantined an attempt-owned database connection")
+    }
+  }
+
+  /**
+   * Projects final package result accounting and failures.
+   * @param {import("@velocious/testing/runner").RunnerEvent} event - Test result event.
+   * @returns {Promise<void>} - Resolves after listeners finish.
+   */
+  async reportTestEvent(event) {
+    // Narrows the structured event payload for this event discriminator.
+    const packageTestResult = /** @type {import("@velocious/testing/runner").TestResult} */ (event.test)
+    const test = this.activeTest || this.testRunner.findTestDeclaration(packageTestResult.fullName)
+
+    if (!test) throw new Error(`Package runner result did not match a declaration: ${packageTestResult.fullName}`)
+
+    const metadata = this.testRunner.testMetadata(test)
+    const compatibility = this.testRunner.testData(test)
+    const durationMs = packageTestResult.attempts.reduce((total, attempt) => total + attempt.durationMs, 0)
+
+    if (packageTestResult.attempts.length > 0) {
+      this.testRunner.recordTestDuration({
+        durationMs,
+        filePath: compatibility.testData.filePath ?? "<unknown>",
+        fullDescription: metadata.fullDescription,
+        line: compatibility.testData.line ?? 0
       })
     }
 
-    if (failed && !willRetry) {
-      await this.reportFailedTest({attemptConsoleOutputs, descriptions, error, leftPadding, testArgs, testData, testDescription})
+    if (packageTestResult.status === "passed") {
+      this.testRunner.recordSuccessfulTest()
+    } else {
+      const finalAttempt = packageTestResult.attempts.at(-1)
+      const outcome = finalAttempt
+        ? this.testRunner.attemptOutcome(test, finalAttempt.attemptNumber)
+        : undefined
+      const error = outcome?.failed
+        ? outcome.error
+        : this.testRunner.setupFailureFor(test)
+
+      await this.reportFailedTest({
+        attemptConsoleOutputs: this.attemptConsoleOutputs.get(test) || [],
+        descriptions: metadata.descriptions,
+        error,
+        leftPadding: " ".repeat(metadata.descriptions.length * 2),
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
+        testDescription: metadata.testDescription
+      })
     }
+
+    this.testRunner.completeTestDeclaration(test)
+    this.activeTest = undefined
   }
 
   /**
@@ -101,8 +212,8 @@ export default class VelociousRunnerReporter {
    * @param {string[]} args.descriptions - Parent description stack.
    * @param {ReturnType<typeof JSON.parse>} args.error - Raw final failure.
    * @param {string} args.leftPadding - Console indentation.
-   * @param {import("./velocious-test-arguments.js").TestArgs} args.testArgs - Stable test arguments.
-   * @param {import("./velocious-test-arguments.js").TestData} args.testData - Test registration.
+   * @param {import("./test-runner.js").TestArgs} args.testArgs - Stable test arguments.
+   * @param {import("./test-runner.js").TestData} args.testData - Test registration.
    * @param {string} args.testDescription - Test description.
    * @returns {Promise<void>} - Resolves after the final-failure listener completes.
    */
@@ -119,23 +230,14 @@ export default class VelociousRunnerReporter {
       const stackLines = cleanedStack?.split("\n")
 
       if (stackLines) {
-        for (const stackLine of stackLines) {
-          console.error(picocolors.red(`${leftPadding}  ${stackLine}`))
-        }
+        for (const stackLine of stackLines) console.error(picocolors.red(`${leftPadding}  ${stackLine}`))
       }
     } else {
       console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof error}: ${String(error)}`))
     }
 
     testRunner.printFailedConsoleOutput({consoleOutput, leftPadding})
-    testRunner._failedTests++
-    testRunner._failedTestDetails.push({
-      fullDescription: testRunner.buildFullDescription(descriptions, testDescription),
-      filePath: testData.filePath,
-      line: testData.line,
-      error,
-      consoleOutput: consoleOutput || undefined
-    })
+    testRunner.recordFailedTest({descriptions, error, consoleOutput, testData, testDescription})
 
     await this.emitEvent("testFailed", {
       configuration: testRunner.getConfiguration(),
@@ -157,10 +259,6 @@ export default class VelociousRunnerReporter {
    * @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)
-    }
+    for (const listener of testEvents.listeners(eventName)) await listener(payload)
   }
 }

package/src/testing/velocious-suite-hook-executor.js

@@ -14,58 +14,30 @@ export default class VelociousSuiteHookExecutor {
   }
 
   /**
-   * Runs suite setup hooks in declaration order.
-   * @param {object} args - Hook execution arguments.
-   * @param {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} args.hooks - Profiled setup hooks.
-   * @returns {Promise<void>} - Resolves after every setup hook completes.
+   * Supplies the framework configuration while package traversal owns ordering,
+   * timeout enforcement, aggregation, and active-scope cleanup.
+   * @param {import("@velocious/testing/runner").SuiteHookExecutorInput} input - Package hook input.
+   * @returns {Promise<void>} - Resolves after the hook completes.
    */
-  async runBeforeAlls({hooks, ...restArgs}) {
+  async execute({context, defaultExecute, fullName, hook, phase, suite, timeoutMs, ...restArgs}) {
     restArgsError(restArgs)
-
-    for (const hook of hooks) {
-      await this.runHook(hook, "beforeAll")
-    }
-  }
-
-  /**
-   * Runs every suite teardown hook in reverse declaration order.
-   * @param {object} args - Hook execution arguments.
-   * @param {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} args.hooks - Profiled teardown hooks.
-   * @returns {Promise<void>} - Resolves after every teardown hook settles.
-   */
-  async runAfterAlls({hooks, ...restArgs}) {
-    restArgsError(restArgs)
-    /** @type {ReturnType<typeof JSON.parse>[]} */
-    const errors = []
-
-    for (const hook of [...hooks].reverse()) {
-      try {
-        await this.runHook(hook, "afterAll")
-      } catch (error) {
-        errors.push(error)
-      }
-    }
-
-    if (errors.length == 1) throw errors[0]
-    if (errors.length > 1) {
-      throw new AggregateError(errors, "Multiple afterAll hooks failed", {cause: errors[0]})
+    void context
+    void fullName
+    void timeoutMs
+    const metadata = this.testRunner.hookMetadata(hook)
+
+    try {
+      await this.testRunner.runProfileSpan({
+        phase,
+        declarationIndex: metadata.declarationIndex,
+        declarationScopeId: metadata.declarationScopeId,
+        filePath: metadata.ownerFilePath
+      }, async () => {
+        await defaultExecute([{configuration: this.testRunner.getConfiguration()}])
+      })
+    } catch (error) {
+      this.testRunner.recordSuiteHookFailure({suite, phase, error})
+      throw error
     }
   }
-
-  /**
-   * Runs one suite hook with its Velocious profiler attribution.
-   * @param {import("./test-runner.js").BeforeAfterAllCallbackObjectType} hook - Hook registration.
-   * @param {"beforeAll" | "afterAll"} phase - Profiler phase.
-   * @returns {Promise<void>} - Resolves when the hook completes.
-   */
-  async runHook(hook, phase) {
-    await this.testRunner.runProfileSpan({
-      phase,
-      declarationIndex: hook.declarationIndex,
-      declarationScopeId: hook.declarationScopeId,
-      filePath: hook.ownerFilePath
-    }, async () => {
-      await hook.callback({configuration: this.testRunner.getConfiguration()})
-    })
-  }
 }