velocious 1.0.643 → 1.0.645

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

@@ -0,0 +1,240 @@
+// @ts-check
+import { addTrackedStackToError } from "../utils/with-tracked-stack.js";
+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.
+     * @param {object} args - Constructor arguments.
+     * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+     */
+    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;
+    }
+    /**
+     * 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 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: this.testRunner.getConfiguration(),
+                descriptions,
+                error,
+                attemptNumber: attempt.attemptNumber,
+                nextAttempt: willRetry ? attempt.attemptNumber + 1 : undefined,
+                retriesUsed,
+                retryCount,
+                testArgs: compatibility.testArgs,
+                testData: compatibility.testData,
+                testDescription,
+                testRunner: this.testRunner,
+                willRetry
+            });
+        }
+        if (willRetry) {
+            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: this.testRunner.getConfiguration(),
+                descriptions,
+                error,
+                nextAttempt: attempt.attemptNumber + 1,
+                retriesUsed,
+                retryCount,
+                testArgs: compatibility.testArgs,
+                testData: compatibility.testData,
+                testDescription,
+                testRunner: this.testRunner
+            });
+        }
+        if (attempt.attemptNumber > 1) {
+            await this.emitEvent("testRetried", {
+                configuration: this.testRunner.getConfiguration(),
+                descriptions,
+                error,
+                attemptNumber: attempt.attemptNumber,
+                retriesUsed,
+                retryCount,
+                testArgs: compatibility.testArgs,
+                testData: compatibility.testData,
+                testDescription,
+                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 (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.
+     * @param {object} args - Final failure metadata.
+     * @param {import("./test-runner.js").AttemptConsoleOutput[]} args.attemptConsoleOutputs - Captured output across attempts.
+     * @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("./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.
+     */
+    async reportFailedTest({ attemptConsoleOutputs, descriptions, error, leftPadding, testArgs, testData, testDescription }) {
+        const testRunner = this.testRunner;
+        const consoleOutput = testRunner.buildConsoleOutput(attemptConsoleOutputs);
+        if (error instanceof Error) {
+            console.error(picocolors.red(`${leftPadding}  Test failed: ${error.message}`));
+            addTrackedStackToError(error);
+            const backtraceCleaner = new BacktraceCleaner(error);
+            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 error}: ${String(error)}`));
+        }
+        testRunner.printFailedConsoleOutput({ consoleOutput, leftPadding });
+        testRunner.recordFailedTest({ descriptions, error, consoleOutput, testData, testDescription });
+        await this.emitEvent("testFailed", {
+            configuration: testRunner.getConfiguration(),
+            descriptions,
+            error,
+            testArgs,
+            testData,
+            testDescription,
+            testRunner
+        });
+        testRunner.printRerunCommand({ descriptions, testDescription, testData, leftPadding });
+    }
+    /**
+     * Emits one legacy event and awaits listeners in registration order.
+     * @param {string} eventName - Event name.
+     * @param {object} payload - Event payload.
+     * @returns {Promise<void>} - Resolves when all listeners complete.
+     */
+    async emitEvent(eventName, payload) {
+        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\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

@@ -0,0 +1,19 @@
+export default class VelociousSuiteHookExecutor {
+    testRunner: import("./test-runner.js").default;
+    /**
+     * Creates an executor for Velocious suite hooks.
+     * @param {object} args - Constructor arguments.
+     * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+     */
+    constructor({ testRunner, ...restArgs }: {
+        testRunner: import("./test-runner.js").default;
+    });
+    /**
+     * 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.
+     */
+    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

@@ -0,0 +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,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

@@ -0,0 +1,41 @@
+// @ts-check
+import restArgsError from "../utils/rest-args-error.js";
+export default class VelociousSuiteHookExecutor {
+    /**
+     * Creates an executor for Velocious suite hooks.
+     * @param {object} args - Constructor arguments.
+     * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+     */
+    constructor({ testRunner, ...restArgs }) {
+        restArgsError(restArgs);
+        this.testRunner = testRunner;
+    }
+    /**
+     * 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 execute({ context, defaultExecute, fullName, hook, phase, suite, timeoutMs, ...restArgs }) {
+        restArgsError(restArgs);
+        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;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,39 @@
+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;
+    /**
+     * Creates the framework-owned test argument adapter.
+     * @param {object} args - Constructor arguments.
+     * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+     */
+    constructor({ testRunner, ...restArgs }: {
+        testRunner: import("./test-runner.js").default;
+    });
+    /**
+     * 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.
+     */
+    resolve({ test }: {
+        test: PackageTestDeclaration;
+    }): Promise<ReturnType<typeof JSON.parse>[]>;
+    /**
+     * Copies declaration metadata before selection can inspect it.
+     * @param {PackageTestDeclaration} testData - Test registration.
+     * @returns {TestArgs} - Independent test arguments.
+     */
+    copy(testData: PackageTestDeclaration): TestArgs;
+    /**
+     * Injects type-specific framework collaborators after selection.
+     * @param {TestArgs} testArgs - Selected test arguments.
+     * @returns {Promise<void>} - Resolves after required collaborators are ready.
+     */
+    inject(testArgs: TestArgs): Promise<void>;
+}
+//# sourceMappingURL=velocious-test-arguments.d.ts.map

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

@@ -0,0 +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;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

@@ -0,0 +1,55 @@
+// @ts-check
+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.
+     * @param {object} args - Constructor arguments.
+     * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+     */
+    constructor({ testRunner, ...restArgs }) {
+        restArgsError(restArgs);
+        this.testRunner = testRunner;
+    }
+    /**
+     * 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 resolve({ test }) {
+        const compatibility = await this.testRunner.testCompatibility(test);
+        return [...test.rowArguments, compatibility.testArgs];
+    }
+    /**
+     * Copies declaration metadata before selection can inspect it.
+     * @param {PackageTestDeclaration} testData - Test registration.
+     * @returns {TestArgs} - Independent test arguments.
+     */
+    copy(testData) {
+        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.
+     * @param {TestArgs} testArgs - Selected test arguments.
+     * @returns {Promise<void>} - Resolves after required collaborators are ready.
+     */
+    async inject(testArgs) {
+        if (testArgs.type == "model" || testArgs.type == "request") {
+            testArgs.application = await this.testRunner.application();
+        }
+        if (testArgs.type == "request") {
+            testArgs.client = await this.testRunner.requestClient();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/utils/model-primary-key.d.ts

@@ -0,0 +1,73 @@
+export type ModelPrimaryKeyScalar = string | number;
+export type ModelPrimaryKeyDefinition = string | string[];
+export type CompositeModelPrimaryKeyValue = Record<string, ModelPrimaryKeyScalar>;
+export type ModelPrimaryKeyValue = ModelPrimaryKeyScalar | CompositeModelPrimaryKeyValue;
+/** @typedef {string | number} ModelPrimaryKeyScalar */
+/** @typedef {string | string[]} ModelPrimaryKeyDefinition */
+/** @typedef {Record<string, ModelPrimaryKeyScalar>} CompositeModelPrimaryKeyValue */
+/** @typedef {ModelPrimaryKeyScalar | CompositeModelPrimaryKeyValue} ModelPrimaryKeyValue */
+/**
+ * Validates an untrusted composite identity and returns its definition-ordered values.
+ * @param {string[]} primaryKey - Composite primary-key definition.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate identity.
+ * @returns {CompositeModelPrimaryKeyValue} - Validated identity.
+ */
+export declare function validatedCompositePrimaryKeyValue(primaryKey: string[], value: ReturnType<typeof JSON.parse>): CompositeModelPrimaryKeyValue;
+/**
+ * Returns a scalar primary-key definition or fails at a feature boundary that cannot represent composite identities.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {string} operation - Operation requiring a scalar identity.
+ * @returns {string} - Scalar primary-key column or attribute name.
+ */
+export declare function scalarModelPrimaryKey(primaryKey: ModelPrimaryKeyDefinition, operation: string): string;
+/**
+ * Returns a scalar identity or fails at a feature boundary that cannot represent composite identities.
+ * @param {ModelPrimaryKeyValue} value - Model identity.
+ * @param {string} operation - Operation requiring a scalar identity.
+ * @returns {ModelPrimaryKeyScalar} - Scalar identity.
+ */
+export declare function scalarModelPrimaryKeyValue(value: ModelPrimaryKeyValue, operation: string): ModelPrimaryKeyScalar;
+/**
+ * Builds query conditions from a scalar or composite model identity.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate identity.
+ * @returns {Record<string, ModelPrimaryKeyScalar>} - Primary-key query conditions.
+ */
+export declare function modelPrimaryKeyConditions(primaryKey: ModelPrimaryKeyDefinition, value: ReturnType<typeof JSON.parse>): Record<string, ModelPrimaryKeyScalar>;
+/**
+ * Builds a qualified SQL predicate matching any supplied composite identity.
+ * @param {object} args - Arguments.
+ * @param {typeof import("../database/record/index.js").default} args.modelClass - Model class owning the identity attributes.
+ * @param {string[]} args.primaryKey - Composite primary-key definition.
+ * @param {import("../database/query/model-class-query.js").default<typeof import("../database/record/index.js").default>} args.query - Query receiving the predicate.
+ * @param {ModelPrimaryKeyValue[]} args.values - Candidate identities.
+ * @returns {string} - Qualified SQL predicate.
+ */
+export declare function compositeModelPrimaryKeyCohortSql({ modelClass, primaryKey, query, values }: {
+    modelClass: typeof import("../database/record/index.js").default;
+    primaryKey: string[];
+    query: import("../database/query/model-class-query.js").default<typeof import("../database/record/index.js").default>;
+    values: ModelPrimaryKeyValue[];
+}): string;
+/**
+ * Reads a scalar or composite identity through the owning model's value reader.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {(key: string) => ReturnType<typeof JSON.parse>} read - Primary-key value reader.
+ * @returns {ModelPrimaryKeyValue} - Model identity.
+ */
+export declare function readModelPrimaryKeyValue(primaryKey: ModelPrimaryKeyDefinition, read: (key: string) => ReturnType<typeof JSON.parse>): ModelPrimaryKeyValue;
+/**
+ * Returns an unambiguous map key while preserving legacy scalar map keys.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate identity.
+ * @returns {string} - Canonical identity key.
+ */
+export declare function modelPrimaryKeyCacheKey(primaryKey: ModelPrimaryKeyDefinition, value: ReturnType<typeof JSON.parse>): string;
+/**
+ * Restores a model identity from its canonical string representation.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {string} cacheKey - Canonical identity key.
+ * @returns {ModelPrimaryKeyValue} - Restored identity.
+ */
+export declare function modelPrimaryKeyValueFromCacheKey(primaryKey: ModelPrimaryKeyDefinition, cacheKey: string): ModelPrimaryKeyValue;
+//# sourceMappingURL=model-primary-key.d.ts.map

package/build/src/utils/model-primary-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-primary-key.d.ts","sourceRoot":"","sources":["../../../src/utils/model-primary-key.js"],"names":[],"mappings":"AAII,YAA2B,qBAAqB,GAAtC,MAAM,GAAG,MAAM,CAAuB;AAChD,YAA6B,yBAAyB,GAA5C,MAAM,GAAG,MAAM,EAAE,CAA2B;AACtD,YAAiD,6BAA6B,GAApE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAA+B;AAC9E,YAAiE,oBAAoB,GAA3E,qBAAqB,GAAG,6BAA6B,CAAsB;AAHzF,uDAAuD;AACvD,6DAA6D;AAC7D,qFAAqF;AACrF,4FAA4F;AAE5F;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAJjD,MAAM,EAI2C,EAAE,KAAK,EAHxD,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAG4B,GAFtD,6BAA6B,CA2BzC;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAJrC,yBAIqC,EAAE,SAAS,EAHhD,MAGgD,GAF9C,MAAM,CAQlB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAJrC,oBAIqC,EAAE,SAAS,EAHhD,MAGgD,GAF9C,qBAAqB,CAQjC;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAJzC,yBAIyC,EAAE,KAAK,EAHhD,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAGoB,GAF9C,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAMjD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAAC,EAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAC,EANtF;IAAmE,UAAU,EAArE,cAAc,6BAA6B,EAAE,OAAO,CAC5D;IAAuB,UAAU,EAAzB,MAAM,EAAE,CAChB;IAA6H,KAAK,EAA1H,OAAO,wCAAwC,EAAE,OAAO,CAAC,cAAc,6BAA6B,EAAE,OAAO,CAAC,CACtH;IAAqC,MAAM,EAAnC,oBAAoB,EAAE,CAC9B;CAEsF,GAF5E,MAAM,CAiBlB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAJxC,yBAIwC,EAAE,IAAI,EAH9C,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAGC,GAF5C,oBAAoB,CAWhC;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAJvC,yBAIuC,EAAE,KAAK,EAH9C,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAGkB,GAF5C,MAAM,CAQlB;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,UAAU,EAJhD,yBAIgD,EAAE,QAAQ,EAH1D,MAG0D,GAFxD,oBAAoB,CA2BhC"}