velocious 1.0.643 → 1.0.644

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

@@ -0,0 +1,152 @@
+// @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";
+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;
+    }
+    /**
+     * 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.
+     */
+    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++;
+        if (failed) {
+            await this.emitEvent("testAttemptFailed", {
+                configuration: testRunner.getConfiguration(),
+                descriptions,
+                error,
+                attemptNumber,
+                nextAttempt: willRetry ? attemptNumber + 1 : undefined,
+                retriesUsed,
+                retryCount,
+                testArgs,
+                testData,
+                testDescription,
+                testRunner,
+                willRetry
+            });
+        }
+        if (willRetry) {
+            console.warn(picocolors.red(`${leftPadding}  Retrying (${retriesUsed}/${retryCount}) after error: ${error instanceof Error ? error.message : String(error)}`));
+            await this.emitEvent("testRetrying", {
+                configuration: testRunner.getConfiguration(),
+                descriptions,
+                error,
+                nextAttempt: attemptNumber + 1,
+                retriesUsed,
+                retryCount,
+                testArgs,
+                testData,
+                testDescription,
+                testRunner
+            });
+        }
+        if (attemptNumber > 1) {
+            await this.emitEvent("testRetried", {
+                configuration: testRunner.getConfiguration(),
+                descriptions,
+                error,
+                attemptNumber,
+                retriesUsed,
+                retryCount,
+                testArgs,
+                testData,
+                testDescription,
+                testRunner
+            });
+        }
+        if (failed && !willRetry) {
+            await this.reportFailedTest({ attemptConsoleOutputs, descriptions, error, leftPadding, testArgs, testData, testDescription });
+        }
+    }
+    /**
+     * 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("./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.
+     * @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._failedTests++;
+        testRunner._failedTestDetails.push({
+            fullDescription: testRunner.buildFullDescription(descriptions, testDescription),
+            filePath: testData.filePath,
+            line: testData.line,
+            error,
+            consoleOutput: consoleOutput || undefined
+        });
+        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) {
+        const listeners = testEvents.listeners(eventName);
+        for (const listener of listeners) {
+            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"]}

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

@@ -0,0 +1,37 @@
+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;
+    });
+    /**
+     * 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.
+     */
+    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>;
+}
+//# 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,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"}

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

@@ -0,0 +1,66 @@
+// @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;
+    }
+    /**
+     * 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.
+     */
+    async runBeforeAlls({ hooks, ...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] });
+        }
+    }
+    /**
+     * 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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

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

@@ -0,0 +1,34 @@
+export type TestArgs = import("./test-runner.js").TestArgs;
+export type TestData = import("./test-runner.js").TestData;
+/** @typedef {import("./test-runner.js").TestArgs} TestArgs */
+/** @typedef {import("./test-runner.js").TestData} TestData */
+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;
+    });
+    /**
+     * Builds the stable framework-owned argument object for one selected test.
+     * @param {TestData} testData - Selected test registration.
+     * @returns {Promise<TestArgs>} - Attempt-shared callback arguments.
+     */
+    build(testData: TestData): Promise<TestArgs>;
+    /**
+     * Copies declaration metadata before selection can inspect it.
+     * @param {TestData} testData - Test registration.
+     * @returns {TestArgs} - Independent test arguments.
+     */
+    copy(testData: TestData): 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;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"}

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

@@ -0,0 +1,47 @@
+// @ts-check
+import restArgsError from "../utils/rest-args-error.js";
+/** @typedef {import("./test-runner.js").TestArgs} TestArgs */
+/** @typedef {import("./test-runner.js").TestData} TestData */
+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;
+    }
+    /**
+     * Builds the stable framework-owned argument object for one selected test.
+     * @param {TestData} testData - Selected test registration.
+     * @returns {Promise<TestArgs>} - Attempt-shared callback arguments.
+     */
+    async build(testData) {
+        const testArgs = this.copy(testData);
+        await this.inject(testArgs);
+        return testArgs;
+    }
+    /**
+     * Copies declaration metadata before selection can inspect it.
+     * @param {TestData} testData - Test registration.
+     * @returns {TestArgs} - Independent test arguments.
+     */
+    copy(testData) {
+        return /** @type {TestArgs} */ (Object.assign({}, testData.args));
+    }
+    /**
+     * 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/sha256-bytes-hex.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Computes a SHA-256 hex digest for arbitrary bytes without Node-only imports.
+ * @param {Uint8Array} bytes - Bytes to digest.
+ * @returns {string} Hex digest.
+ */
+export default function sha256BytesHex(bytes: Uint8Array): string;
+//# sourceMappingURL=sha256-bytes-hex.d.ts.map

package/build/src/utils/sha256-bytes-hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256-bytes-hex.d.ts","sourceRoot":"","sources":["../../../src/utils/sha256-bytes-hex.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,KAAK,EAHjC,UAGiC,GAF/B,MAAM,CAmFlB"}

package/build/src/utils/sha256-bytes-hex.js

@@ -0,0 +1,117 @@
+// @ts-check
+/**
+ * Computes a SHA-256 hex digest for arbitrary bytes without Node-only imports.
+ * @param {Uint8Array} bytes - Bytes to digest.
+ * @returns {string} Hex digest.
+ */
+export default function sha256BytesHex(bytes) {
+    const bitLength = bytes.length * 8;
+    const blockCount = Math.ceil((bytes.length + 9) / 64);
+    const block = new Uint8Array(64);
+    const hash = SHA256_INITIAL_HASH.slice();
+    /** @type {number[]} */
+    const words = new Array(64);
+    const highLength = Math.floor(bitLength / 0x100000000);
+    const lowLength = bitLength >>> 0;
+    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {
+        const offset = blockIndex * 64;
+        const chunkLength = Math.min(64, Math.max(0, bytes.length - offset));
+        block.fill(0);
+        if (chunkLength > 0)
+            block.set(bytes.subarray(offset, offset + chunkLength));
+        if (bytes.length >= offset && bytes.length < offset + 64)
+            block[bytes.length - offset] = 0x80;
+        if (blockIndex === blockCount - 1) {
+            block[56] = (highLength >>> 24) & 0xff;
+            block[57] = (highLength >>> 16) & 0xff;
+            block[58] = (highLength >>> 8) & 0xff;
+            block[59] = highLength & 0xff;
+            block[60] = (lowLength >>> 24) & 0xff;
+            block[61] = (lowLength >>> 16) & 0xff;
+            block[62] = (lowLength >>> 8) & 0xff;
+            block[63] = lowLength & 0xff;
+        }
+        for (let index = 0; index < 16; index++) {
+            const byteIndex = index * 4;
+            words[index] = ((block[byteIndex] << 24) | (block[byteIndex + 1] << 16) | (block[byteIndex + 2] << 8) | block[byteIndex + 3]) >>> 0;
+        }
+        for (let index = 16; index < 64; index++) {
+            const s0 = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ (words[index - 15] >>> 3);
+            const s1 = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ (words[index - 2] >>> 10);
+            words[index] = add32(words[index - 16], s0, words[index - 7], s1);
+        }
+        let a = hash[0];
+        let b = hash[1];
+        let c = hash[2];
+        let d = hash[3];
+        let e = hash[4];
+        let f = hash[5];
+        let g = hash[6];
+        let h = hash[7];
+        for (let index = 0; index < 64; index++) {
+            const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+            const ch = (e & f) ^ ((~e) & g);
+            const temp1 = add32(h, s1, ch, SHA256_K[index], words[index]);
+            const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = add32(s0, maj);
+            h = g;
+            g = f;
+            f = e;
+            e = add32(d, temp1);
+            d = c;
+            c = b;
+            b = a;
+            a = add32(temp1, temp2);
+        }
+        hash[0] = add32(hash[0], a);
+        hash[1] = add32(hash[1], b);
+        hash[2] = add32(hash[2], c);
+        hash[3] = add32(hash[3], d);
+        hash[4] = add32(hash[4], e);
+        hash[5] = add32(hash[5], f);
+        hash[6] = add32(hash[6], g);
+        hash[7] = add32(hash[7], h);
+    }
+    return hash.map((value) => value.toString(16).padStart(8, "0")).join("");
+}
+const SHA256_INITIAL_HASH = [
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+];
+const SHA256_K = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+];
+/**
+ * Rotates an unsigned value right.
+ * @param {number} value Unsigned value.
+ * @param {number} bits Rotation count.
+ * @returns {number} Rotated value.
+ */
+function rotateRight(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}
+/**
+ * Adds numbers with unsigned 32-bit overflow.
+ * @param {...number} values Values to add.
+ * @returns {number} Unsigned sum.
+ */
+function add32(...values) {
+    return values.reduce((sum, value) => (sum + value) >>> 0, 0);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sha256-bytes-hex.js","sourceRoot":"","sources":["../../../src/utils/sha256-bytes-hex.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Computes a SHA-256 hex digest for arbitrary bytes without Node-only imports.\n * @param {Uint8Array} bytes - Bytes to digest.\n * @returns {string} Hex digest.\n */\nexport default function sha256BytesHex(bytes) {\n  const bitLength = bytes.length * 8\n  const blockCount = Math.ceil((bytes.length + 9) / 64)\n  const block = new Uint8Array(64)\n  const hash = SHA256_INITIAL_HASH.slice()\n  /** @type {number[]} */\n  const words = new Array(64)\n\n  const highLength = Math.floor(bitLength / 0x100000000)\n  const lowLength = bitLength >>> 0\n\n  for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {\n    const offset = blockIndex * 64\n    const chunkLength = Math.min(64, Math.max(0, bytes.length - offset))\n\n    block.fill(0)\n    if (chunkLength > 0) block.set(bytes.subarray(offset, offset + chunkLength))\n    if (bytes.length >= offset && bytes.length < offset + 64) block[bytes.length - offset] = 0x80\n\n    if (blockIndex === blockCount - 1) {\n      block[56] = (highLength >>> 24) & 0xff\n      block[57] = (highLength >>> 16) & 0xff\n      block[58] = (highLength >>> 8) & 0xff\n      block[59] = highLength & 0xff\n      block[60] = (lowLength >>> 24) & 0xff\n      block[61] = (lowLength >>> 16) & 0xff\n      block[62] = (lowLength >>> 8) & 0xff\n      block[63] = lowLength & 0xff\n    }\n\n    for (let index = 0; index < 16; index++) {\n      const byteIndex = index * 4\n\n      words[index] = ((block[byteIndex] << 24) | (block[byteIndex + 1] << 16) | (block[byteIndex + 2] << 8) | block[byteIndex + 3]) >>> 0\n    }\n\n    for (let index = 16; index < 64; index++) {\n      const s0 = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ (words[index - 15] >>> 3)\n      const s1 = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ (words[index - 2] >>> 10)\n\n      words[index] = add32(words[index - 16], s0, words[index - 7], s1)\n    }\n\n    let a = hash[0]\n    let b = hash[1]\n    let c = hash[2]\n    let d = hash[3]\n    let e = hash[4]\n    let f = hash[5]\n    let g = hash[6]\n    let h = hash[7]\n\n    for (let index = 0; index < 64; index++) {\n      const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25)\n      const ch = (e & f) ^ ((~e) & g)\n      const temp1 = add32(h, s1, ch, SHA256_K[index], words[index])\n      const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22)\n      const maj = (a & b) ^ (a & c) ^ (b & c)\n      const temp2 = add32(s0, maj)\n\n      h = g\n      g = f\n      f = e\n      e = add32(d, temp1)\n      d = c\n      c = b\n      b = a\n      a = add32(temp1, temp2)\n    }\n\n    hash[0] = add32(hash[0], a)\n    hash[1] = add32(hash[1], b)\n    hash[2] = add32(hash[2], c)\n    hash[3] = add32(hash[3], d)\n    hash[4] = add32(hash[4], e)\n    hash[5] = add32(hash[5], f)\n    hash[6] = add32(hash[6], g)\n    hash[7] = add32(hash[7], h)\n  }\n\n  return hash.map((value) => value.toString(16).padStart(8, \"0\")).join(\"\")\n}\n\nconst SHA256_INITIAL_HASH = [\n  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,\n  0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]\n\nconst SHA256_K = [\n  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,\n  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,\n  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,\n  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,\n  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,\n  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,\n  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]\n\n/**\n * Rotates an unsigned value right.\n * @param {number} value Unsigned value.\n * @param {number} bits Rotation count.\n * @returns {number} Rotated value.\n */\nfunction rotateRight(value, bits) {\n  return (value >>> bits) | (value << (32 - bits))\n}\n\n/**\n * Adds numbers with unsigned 32-bit overflow.\n * @param {...number} values Values to add.\n * @returns {number} Unsigned sum.\n */\nfunction add32(...values) {\n  return values.reduce((sum, value) => (sum + value) >>> 0, 0)\n}\n"]}

package/build/src/utils/sha256-hex.d.ts

@@ -1,10 +1,8 @@
 /**
  * Computes SHA-256 without importing Node-only crypto modules, keeping this
- * module safe for Expo/browser bundles. Implementation is a straightforward
- * pure-JavaScript SHA-256 derived from FIPS 180-4, using only 32-bit unsigned
- * integer arithmetic.
+ * module safe for Expo/browser bundles.
  * @param {string} message - UTF-8 message.
- * @returns {string} - Hex digest.
+ * @returns {string} Hex digest.
  */
 export default function sha256Hex(message: string): string;
 //# sourceMappingURL=sha256-hex.d.ts.map

package/build/src/utils/sha256-hex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sha256-hex.d.ts","sourceRoot":"","sources":["../../../src/utils/sha256-hex.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,OAAO,EAH9B,MAG8B,GAF5B,MAAM,CAiElB"}
+{"version":3,"file":"sha256-hex.d.ts","sourceRoot":"","sources":["../../../src/utils/sha256-hex.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,OAAO,EAH9B,MAG8B,GAF5B,MAAM,CAIlB"}