velocious 1.0.644 → 1.0.646

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

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

package/build/src/testing/velocious-suite-hook-executor.d.ts

@@ -9,29 +9,11 @@ export default class VelociousSuiteHookExecutor {
         testRunner: import("./test-runner.js").default;
     });
     /**
-     * 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.
      */
-    runBeforeAlls({ hooks, ...restArgs }: {
-        hooks: import("./test-runner.js").BeforeAfterAllCallbackObjectType[];
-    }): Promise<void>;
-    /**
-     * 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.
-     */
-    runAfterAlls({ hooks, ...restArgs }: {
-        hooks: import("./test-runner.js").BeforeAfterAllCallbackObjectType[];
-    }): Promise<void>;
-    /**
-     * 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.
-     */
-    runHook(hook: import("./test-runner.js").BeforeAfterAllCallbackObjectType, phase: "beforeAll" | "afterAll"): Promise<void>;
+    execute({ context, defaultExecute, fullName, hook, phase, suite, timeoutMs, ...restArgs }: import("@velocious/testing/runner").SuiteHookExecutorInput): Promise<void>;
 }
 //# sourceMappingURL=velocious-suite-hook-executor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"velocious-suite-hook-executor.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-suite-hook-executor.js"],"names":[],"mappings":"AAIA,MAAM,CAAC,OAAO,OAAO,0BAA0B;IAQtC,UAAU;IAPjB;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAGpC;IAED;;;;;OAKG;IACG,aAAa,CAAC,EAAC,KAAK,EAAE,GAAG,QAAQ,EAAC,EAHrC;QAA4E,KAAK,EAAzE,OAAO,kBAAkB,EAAE,gCAAgC,EAAE,CACrE;KAEqC,GAF3B,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;;OAKG;IACG,YAAY,CAAC,EAAC,KAAK,EAAE,GAAG,QAAQ,EAAC,EAHpC;QAA4E,KAAK,EAAzE,OAAO,kBAAkB,EAAE,gCAAgC,EAAE,CACrE;KAEoC,GAF1B,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED;;;;;OAKG;IACG,OAAO,CAAC,IAAI,EAJP,OAAO,kBAAkB,EAAE,gCAIpB,EAAE,KAAK,EAHd,WAAW,GAAG,UAGA,GAFZ,OAAO,CAAC,IAAI,CAAC,CAWzB;CACF"}
+{"version":3,"file":"velocious-suite-hook-executor.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-suite-hook-executor.js"],"names":[],"mappings":"AAIA,MAAM,CAAC,OAAO,OAAO,0BAA0B;IAQtC,UAAU;IAPjB;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAGpC;IAED;;;;;OAKG;IACG,OAAO,CAAC,EAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,QAAQ,EAAC,EAHlF,OAAO,2BAA2B,EAAE,sBAG8C,GAFhF,OAAO,CAAC,IAAI,CAAC,CAsBzB;CACF"}

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

@@ -11,56 +11,31 @@ export default class VelociousSuiteHookExecutor {
         this.testRunner = testRunner;
     }
     /**
-     * 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");
+        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() }]);
+            });
         }
-    }
-    /**
-     * 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);
-            }
+        catch (error) {
+            this.testRunner.recordSuiteHookFailure({ suite, phase, error });
+            throw error;
         }
-        if (errors.length == 1)
-            throw errors[0];
-        if (errors.length > 1) {
-            throw new AggregateError(errors, "Multiple afterAll hooks failed", { cause: errors[0] });
-        }
-    }
-    /**
-     * 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() });
-        });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/velocious-test-arguments.d.ts

@@ -1,7 +1,9 @@
 export type TestArgs = import("./test-runner.js").TestArgs;
 export type TestData = import("./test-runner.js").TestData;
+export type PackageTestDeclaration = import("@velocious/testing/runner").TestDeclaration;
 /** @typedef {import("./test-runner.js").TestArgs} TestArgs */
 /** @typedef {import("./test-runner.js").TestData} TestData */
+/** @typedef {import("@velocious/testing/runner").TestDeclaration} PackageTestDeclaration */
 export default class VelociousTestArguments {
     testRunner: import("./test-runner.js").default;
     /**
@@ -13,17 +15,20 @@ export default class VelociousTestArguments {
         testRunner: import("./test-runner.js").default;
     });
     /**
-     * Builds the stable framework-owned argument object for one selected test.
-     * @param {TestData} testData - Selected test registration.
-     * @returns {Promise<TestArgs>} - Attempt-shared callback arguments.
+     * Resolves stable Velocious arguments after package-owned table arguments.
+     * @param {object} input - Package resolver input.
+     * @param {PackageTestDeclaration} input.test - Selected declaration.
+     * @returns {Promise<ReturnType<typeof JSON.parse>[]>} - Callback arguments.
      */
-    build(testData: TestData): Promise<TestArgs>;
+    resolve({ test }: {
+        test: PackageTestDeclaration;
+    }): Promise<ReturnType<typeof JSON.parse>[]>;
     /**
      * Copies declaration metadata before selection can inspect it.
-     * @param {TestData} testData - Test registration.
+     * @param {PackageTestDeclaration} testData - Test registration.
      * @returns {TestArgs} - Independent test arguments.
      */
-    copy(testData: TestData): TestArgs;
+    copy(testData: PackageTestDeclaration): TestArgs;
     /**
      * Injects type-specific framework collaborators after selection.
      * @param {TestArgs} testArgs - Selected test arguments.

package/build/src/testing/velocious-test-arguments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"velocious-test-arguments.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-test-arguments.js"],"names":[],"mappings":"AAII,YAA+C,QAAQ,GAA7C,OAAO,kBAAkB,EAAE,QAAQ,CAAU;AACvD,YAA+C,QAAQ,GAA7C,OAAO,kBAAkB,EAAE,QAAQ,CAAU;AAD3D,8DAA8D;AAC9D,8DAA8D;AAE9D,MAAM,CAAC,OAAO,OAAO,sBAAsB;IAQlC,UAAU;IAPjB;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAGpC;IAED;;;;OAIG;IACG,KAAK,CAAC,QAAQ,EAHT,QAGS,GAFP,OAAO,CAAC,QAAQ,CAAC,CAQ7B;IAED;;;;OAIG;IACH,IAAI,CAAC,QAAQ,EAHF,QAGE,GAFA,QAAQ,CAIpB;IAED;;;;OAIG;IACG,MAAM,CAAC,QAAQ,EAHV,QAGU,GAFR,OAAO,CAAC,IAAI,CAAC,CAUzB;CACF"}
+{"version":3,"file":"velocious-test-arguments.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-test-arguments.js"],"names":[],"mappings":"AAII,YAA+C,QAAQ,GAA7C,OAAO,kBAAkB,EAAE,QAAQ,CAAU;AACvD,YAA+C,QAAQ,GAA7C,OAAO,kBAAkB,EAAE,QAAQ,CAAU;AACvD,YAA+D,sBAAsB,GAA3E,OAAO,2BAA2B,EAAE,eAAe,CAAwB;AAFzF,8DAA8D;AAC9D,8DAA8D;AAC9D,4FAA4F;AAE5F,MAAM,CAAC,OAAO,OAAO,sBAAsB;IAQlC,UAAU;IAPjB;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAGpC;IAED;;;;;OAKG;IACG,OAAO,CAAC,EAAC,IAAI,EAAC,EAHjB;QAAsC,IAAI,EAAlC,sBAAsB,CAC9B;KAEiB,GAFP,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAMpD;IAED;;;;OAIG;IACH,IAAI,CAAC,QAAQ,EAHF,sBAGE,GAFA,QAAQ,CAapB;IAED;;;;OAIG;IACG,MAAM,CAAC,QAAQ,EAHV,QAGU,GAFR,OAAO,CAAC,IAAI,CAAC,CAUzB;CACF"}

package/build/src/testing/velocious-test-arguments.js

@@ -2,6 +2,7 @@
 import restArgsError from "../utils/rest-args-error.js";
 /** @typedef {import("./test-runner.js").TestArgs} TestArgs */
 /** @typedef {import("./test-runner.js").TestData} TestData */
+/** @typedef {import("@velocious/testing/runner").TestDeclaration} PackageTestDeclaration */
 export default class VelociousTestArguments {
     /**
      * Creates the framework-owned test argument adapter.
@@ -13,22 +14,29 @@ export default class VelociousTestArguments {
         this.testRunner = testRunner;
     }
     /**
-     * Builds the stable framework-owned argument object for one selected test.
-     * @param {TestData} testData - Selected test registration.
-     * @returns {Promise<TestArgs>} - Attempt-shared callback arguments.
+     * Resolves stable Velocious arguments after package-owned table arguments.
+     * @param {object} input - Package resolver input.
+     * @param {PackageTestDeclaration} input.test - Selected declaration.
+     * @returns {Promise<ReturnType<typeof JSON.parse>[]>} - Callback arguments.
      */
-    async build(testData) {
-        const testArgs = this.copy(testData);
-        await this.inject(testArgs);
-        return testArgs;
+    async resolve({ test }) {
+        const compatibility = await this.testRunner.testCompatibility(test);
+        return [...test.rowArguments, compatibility.testArgs];
     }
     /**
      * Copies declaration metadata before selection can inspect it.
-     * @param {TestData} testData - Test registration.
+     * @param {PackageTestDeclaration} testData - Test registration.
      * @returns {TestArgs} - Independent test arguments.
      */
     copy(testData) {
-        return /** @type {TestArgs} */ (Object.assign({}, testData.args));
+        const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.options));
+        if (testArgs.retry === undefined && typeof testData.options.retries === "number") {
+            testArgs.retry = testData.options.retries;
+        }
+        if (testArgs.timeoutSeconds === undefined && typeof testData.options.timeoutMs === "number") {
+            testArgs.timeoutSeconds = testData.options.timeoutMs / 1000;
+        }
+        return testArgs;
     }
     /**
      * Injects type-specific framework collaborators after selection.
@@ -44,4 +52,4 @@ export default class VelociousTestArguments {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVsb2Npb3VzLXRlc3QtYXJndW1lbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Rlc3RpbmcvdmVsb2Npb3VzLXRlc3QtYXJndW1lbnRzLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixPQUFPLGFBQWEsTUFBTSw2QkFBNkIsQ0FBQTtBQUV2RCw4REFBOEQ7QUFDOUQsOERBQThEO0FBQzlELDRGQUE0RjtBQUU1RixNQUFNLENBQUMsT0FBTyxPQUFPLHNCQUFzQjtJQUN6Qzs7OztPQUlHO0lBQ0gsWUFBWSxFQUFDLFVBQVUsRUFBRSxHQUFHLFFBQVEsRUFBQztRQUNuQyxhQUFhLENBQUMsUUFBUSxDQUFDLENBQUE7UUFDdkIsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUE7SUFDOUIsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsS0FBSyxDQUFDLE9BQU8sQ0FBQyxFQUFDLElBQUksRUFBQztRQUNsQixNQUFNLGFBQWEsR0FBRyxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLENBQUE7UUFFbkUsT0FBTyxDQUFDLEdBQUcsSUFBSSxDQUFDLFlBQVksRUFBRSxhQUFhLENBQUMsUUFBUSxDQUFDLENBQUE7SUFDdkQsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxJQUFJLENBQUMsUUFBUTtRQUNYLE1BQU0sUUFBUSxHQUFHLHVCQUF1QixDQUFDLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxFQUFFLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUE7UUFFOUUsSUFBSSxRQUFRLENBQUMsS0FBSyxLQUFLLFNBQVMsSUFBSSxPQUFPLFFBQVEsQ0FBQyxPQUFPLENBQUMsT0FBTyxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQ2pGLFFBQVEsQ0FBQyxLQUFLLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUE7UUFDM0MsQ0FBQztRQUNELElBQUksUUFBUSxDQUFDLGNBQWMsS0FBSyxTQUFTLElBQUksT0FBTyxRQUFRLENBQUMsT0FBTyxDQUFDLFNBQVMsS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUM1RixRQUFRLENBQUMsY0FBYyxHQUFHLFFBQVEsQ0FBQyxPQUFPLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQTtRQUM3RCxDQUFDO1FBRUQsT0FBTyxRQUFRLENBQUE7SUFDakIsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxLQUFLLENBQUMsTUFBTSxDQUFDLFFBQVE7UUFDbkIsSUFBSSxRQUFRLENBQUMsSUFBSSxJQUFJLE9BQU8sSUFBSSxRQUFRLENBQUMsSUFBSSxJQUFJLFNBQVMsRUFBRSxDQUFDO1lBQzNELFFBQVEsQ0FBQyxXQUFXLEdBQUcsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLFdBQVcsRUFBRSxDQUFBO1FBQzVELENBQUM7UUFFRCxJQUFJLFFBQVEsQ0FBQyxJQUFJLElBQUksU0FBUyxFQUFFLENBQUM7WUFDL0IsUUFBUSxDQUFDLE1BQU0sR0FBRyxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsYUFBYSxFQUFFLENBQUE7UUFDekQsQ0FBQztJQUNILENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5pbXBvcnQgcmVzdEFyZ3NFcnJvciBmcm9tIFwiLi4vdXRpbHMvcmVzdC1hcmdzLWVycm9yLmpzXCJcblxuLyoqIEB0eXBlZGVmIHtpbXBvcnQoXCIuL3Rlc3QtcnVubmVyLmpzXCIpLlRlc3RBcmdzfSBUZXN0QXJncyAqL1xuLyoqIEB0eXBlZGVmIHtpbXBvcnQoXCIuL3Rlc3QtcnVubmVyLmpzXCIpLlRlc3REYXRhfSBUZXN0RGF0YSAqL1xuLyoqIEB0eXBlZGVmIHtpbXBvcnQoXCJAdmVsb2Npb3VzL3Rlc3RpbmcvcnVubmVyXCIpLlRlc3REZWNsYXJhdGlvbn0gUGFja2FnZVRlc3REZWNsYXJhdGlvbiAqL1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBWZWxvY2lvdXNUZXN0QXJndW1lbnRzIHtcbiAgLyoqXG4gICAqIENyZWF0ZXMgdGhlIGZyYW1ld29yay1vd25lZCB0ZXN0IGFyZ3VtZW50IGFkYXB0ZXIuXG4gICAqIEBwYXJhbSB7b2JqZWN0fSBhcmdzIC0gQ29uc3RydWN0b3IgYXJndW1lbnRzLlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4vdGVzdC1ydW5uZXIuanNcIikuZGVmYXVsdH0gYXJncy50ZXN0UnVubmVyIC0gT3duaW5nIFZlbG9jaW91cyBydW5uZXIuXG4gICAqL1xuICBjb25zdHJ1Y3Rvcih7dGVzdFJ1bm5lciwgLi4ucmVzdEFyZ3N9KSB7XG4gICAgcmVzdEFyZ3NFcnJvcihyZXN0QXJncylcbiAgICB0aGlzLnRlc3RSdW5uZXIgPSB0ZXN0UnVubmVyXG4gIH1cblxuICAvKipcbiAgICogUmVzb2x2ZXMgc3RhYmxlIFZlbG9jaW91cyBhcmd1bWVudHMgYWZ0ZXIgcGFja2FnZS1vd25lZCB0YWJsZSBhcmd1bWVudHMuXG4gICAqIEBwYXJhbSB7b2JqZWN0fSBpbnB1dCAtIFBhY2thZ2UgcmVzb2x2ZXIgaW5wdXQuXG4gICAqIEBwYXJhbSB7UGFja2FnZVRlc3REZWNsYXJhdGlvbn0gaW5wdXQudGVzdCAtIFNlbGVjdGVkIGRlY2xhcmF0aW9uLlxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTxSZXR1cm5UeXBlPHR5cGVvZiBKU09OLnBhcnNlPltdPn0gLSBDYWxsYmFjayBhcmd1bWVudHMuXG4gICAqL1xuICBhc3luYyByZXNvbHZlKHt0ZXN0fSkge1xuICAgIGNvbnN0IGNvbXBhdGliaWxpdHkgPSBhd2FpdCB0aGlzLnRlc3RSdW5uZXIudGVzdENvbXBhdGliaWxpdHkodGVzdClcblxuICAgIHJldHVybiBbLi4udGVzdC5yb3dBcmd1bWVudHMsIGNvbXBhdGliaWxpdHkudGVzdEFyZ3NdXG4gIH1cblxuICAvKipcbiAgICogQ29waWVzIGRlY2xhcmF0aW9uIG1ldGFkYXRhIGJlZm9yZSBzZWxlY3Rpb24gY2FuIGluc3BlY3QgaXQuXG4gICAqIEBwYXJhbSB7UGFja2FnZVRlc3REZWNsYXJhdGlvbn0gdGVzdERhdGEgLSBUZXN0IHJlZ2lzdHJhdGlvbi5cbiAgICogQHJldHVybnMge1Rlc3RBcmdzfSAtIEluZGVwZW5kZW50IHRlc3QgYXJndW1lbnRzLlxuICAgKi9cbiAgY29weSh0ZXN0RGF0YSkge1xuICAgIGNvbnN0IHRlc3RBcmdzID0gLyoqIEB0eXBlIHtUZXN0QXJnc30gKi8gKE9iamVjdC5hc3NpZ24oe30sIHRlc3REYXRhLm9wdGlvbnMpKVxuXG4gICAgaWYgKHRlc3RBcmdzLnJldHJ5ID09PSB1bmRlZmluZWQgJiYgdHlwZW9mIHRlc3REYXRhLm9wdGlvbnMucmV0cmllcyA9PT0gXCJudW1iZXJcIikge1xuICAgICAgdGVzdEFyZ3MucmV0cnkgPSB0ZXN0RGF0YS5vcHRpb25zLnJldHJpZXNcbiAgICB9XG4gICAgaWYgKHRlc3RBcmdzLnRpbWVvdXRTZWNvbmRzID09PSB1bmRlZmluZWQgJiYgdHlwZW9mIHRlc3REYXRhLm9wdGlvbnMudGltZW91dE1zID09PSBcIm51bWJlclwiKSB7XG4gICAgICB0ZXN0QXJncy50aW1lb3V0U2Vjb25kcyA9IHRlc3REYXRhLm9wdGlvbnMudGltZW91dE1zIC8gMTAwMFxuICAgIH1cblxuICAgIHJldHVybiB0ZXN0QXJnc1xuICB9XG5cbiAgLyoqXG4gICAqIEluamVjdHMgdHlwZS1zcGVjaWZpYyBmcmFtZXdvcmsgY29sbGFib3JhdG9ycyBhZnRlciBzZWxlY3Rpb24uXG4gICAqIEBwYXJhbSB7VGVzdEFyZ3N9IHRlc3RBcmdzIC0gU2VsZWN0ZWQgdGVzdCBhcmd1bWVudHMuXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fSAtIFJlc29sdmVzIGFmdGVyIHJlcXVpcmVkIGNvbGxhYm9yYXRvcnMgYXJlIHJlYWR5LlxuICAgKi9cbiAgYXN5bmMgaW5qZWN0KHRlc3RBcmdzKSB7XG4gICAgaWYgKHRlc3RBcmdzLnR5cGUgPT0gXCJtb2RlbFwiIHx8IHRlc3RBcmdzLnR5cGUgPT0gXCJyZXF1ZXN0XCIpIHtcbiAgICAgIHRlc3RBcmdzLmFwcGxpY2F0aW9uID0gYXdhaXQgdGhpcy50ZXN0UnVubmVyLmFwcGxpY2F0aW9uKClcbiAgICB9XG5cbiAgICBpZiAodGVzdEFyZ3MudHlwZSA9PSBcInJlcXVlc3RcIikge1xuICAgICAgdGVzdEFyZ3MuY2xpZW50ID0gYXdhaXQgdGhpcy50ZXN0UnVubmVyLnJlcXVlc3RDbGllbnQoKVxuICAgIH1cbiAgfVxufVxuIl19