velocious 1.0.652 → 1.0.654

package/build/src/testing/velocious-runner-reporter.d.ts

@@ -56,6 +56,13 @@ export default class VelociousRunnerReporter {
         testData: import("./test-runner.js").TestData;
         testDescription: string;
     }): Promise<void>;
+    /**
+     * Prints complete primary and secondary stacks once, including cyclic cause graphs.
+     * @param {unknown} error - Thrown value at the reporting boundary.
+     * @param {Set<Error>} [reported] - Error identities already printed.
+     * @returns {void}
+     */
+    printErrorCauses(error: unknown, reported?: Set<Error>): void;
     /**
      * Emits one legacy event and awaits listeners in registration order.
      * @param {string} eventName - Event name.

package/build/src/testing/velocious-runner-reporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"velocious-runner-reporter.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-runner-reporter.js"],"names":[],"mappings":"AAQI,YAA+D,sBAAsB,GAA3E,OAAO,2BAA2B,EAAE,eAAe,CAAwB;AACrF,YAA+D,sBAAsB,GAA3E,OAAO,2BAA2B,EAAE,eAAe,CAAwB;AAkBzF,2EAA2E;AAC3E,qBAAa,wBAAyB,SAAQ,KAAK;CAAG;AAEtD,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAQnC,UAAU;IACf,iGAAiG;IAC5F,qBAAqB,EADf,OAAO,CAAC,sBAAsB,EAAE,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CAAC;IAE7F,iDAAiD;IAC5C,UAAU,EADJ,sBAAsB,GAAG,SAAS;IAV/C;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAOpC;IAED;;;;OAIG;IACG,OAAO,CAAC,KAAK,EAHR,OAAO,2BAA2B,EAAE,WAG5B,GAFN,OAAO,CAAC,IAAI,CAAC,CAuBzB;IAED;;;;OAIG;IACG,kBAAkB,CAAC,KAAK,EAHnB,OAAO,2BAA2B,EAAE,WAGjB,GAFjB,OAAO,CAAC,IAAI,CAAC,CA+FzB;IAED;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAHhB,OAAO,2BAA2B,EAAE,WAGpB,GAFd,OAAO,CAAC,IAAI,CAAC,CAmDzB;IAED;;;;;;;;;;;OAWG;IACG,gBAAgB,CAAC,EAAC,qBAAqB,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAC,EATlH;QAAgE,qBAAqB,EAA7E,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CACzD;QAAuB,YAAY,EAA3B,MAAM,EAAE,CAChB;QAA4C,KAAK,EAAzC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACrC;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAkD,QAAQ,EAAlD,OAAO,kBAAkB,EAAE,QAAQ,CAC3C;QAAkD,QAAQ,EAAlD,OAAO,kBAAkB,EAAE,QAAQ,CAC3C;QAAqB,eAAe,EAA5B,MAAM,CACd;KAEkH,GAFxG,OAAO,CAAC,IAAI,CAAC,CAmCzB;IAED;;;;;OAKG;IACG,SAAS,CAAC,SAAS,EAJd,MAIc,EAAE,OAAO,EAHvB,MAGuB,GAFrB,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF"}
+{"version":3,"file":"velocious-runner-reporter.d.ts","sourceRoot":"","sources":["../../../src/testing/velocious-runner-reporter.js"],"names":[],"mappings":"AAOI,YAA+D,sBAAsB,GAA3E,OAAO,2BAA2B,EAAE,eAAe,CAAwB;AACrF,YAA+D,sBAAsB,GAA3E,OAAO,2BAA2B,EAAE,eAAe,CAAwB;AAoBzF,2EAA2E;AAC3E,qBAAa,wBAAyB,SAAQ,KAAK;CAAG;AAEtD,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAQnC,UAAU;IACf,iGAAiG;IAC5F,qBAAqB,EADf,OAAO,CAAC,sBAAsB,EAAE,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CAAC;IAE7F,iDAAiD;IAC5C,UAAU,EADJ,sBAAsB,GAAG,SAAS;IAV/C;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC,EAFlC;QAAiD,UAAU,EAAnD,OAAO,kBAAkB,EAAE,OAAO,CAC5C;KACoC,EAOpC;IAED;;;;OAIG;IACG,OAAO,CAAC,KAAK,EAHR,OAAO,2BAA2B,EAAE,WAG5B,GAFN,OAAO,CAAC,IAAI,CAAC,CA2CzB;IAED;;;;OAIG;IACG,kBAAkB,CAAC,KAAK,EAHnB,OAAO,2BAA2B,EAAE,WAGjB,GAFjB,OAAO,CAAC,IAAI,CAAC,CA+FzB;IAED;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAHhB,OAAO,2BAA2B,EAAE,WAGpB,GAFd,OAAO,CAAC,IAAI,CAAC,CAmDzB;IAED;;;;;;;;;;;OAWG;IACG,gBAAgB,CAAC,EAAC,qBAAqB,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAC,EATlH;QAAgE,qBAAqB,EAA7E,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CACzD;QAAuB,YAAY,EAA3B,MAAM,EAAE,CAChB;QAA4C,KAAK,EAAzC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACrC;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAkD,QAAQ,EAAlD,OAAO,kBAAkB,EAAE,QAAQ,CAC3C;QAAkD,QAAQ,EAAlD,OAAO,kBAAkB,EAAE,QAAQ,CAC3C;QAAqB,eAAe,EAA5B,MAAM,CACd;KAEkH,GAFxG,OAAO,CAAC,IAAI,CAAC,CA4BzB;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,KAAK,EAJX,OAIW,EAAE,QAAQ,AAH7B,CACA,EADQ,GAAG,CAAC,KAAK,CAGwB,GAF/B,IAAI,CAqBhB;IAED;;;;;OAKG;IACG,SAAS,CAAC,SAAS,EAJd,MAIc,EAAE,OAAO,EAHvB,MAGuB,GAFrB,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF"}

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

@@ -1,6 +1,5 @@
 // @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";
@@ -18,6 +17,10 @@ function errorFromPackageRecord(errorRecord) {
     error.name = errorRecord.name;
     if (errorRecord.stack)
         error.stack = errorRecord.stack;
+    if (errorRecord.cause)
+        error.cause = errorFromPackageRecord(errorRecord.cause);
+    if (errorRecord.terminalResource)
+        Object.assign(error, { terminalResource: errorRecord.terminalResource });
     return error;
 }
 /** Stops package traversal after framework-owned connection quarantine. */
@@ -59,8 +62,27 @@ export default class VelociousRunnerReporter {
             await this.reportTestEvent(event);
             return;
         }
-        if (event.type === "run:finish")
+        if (event.type === "test:not-run") {
+            const test = this.testRunner.findTestDeclaration(event.test.fullName);
+            if (!test)
+                throw new Error(`Package not-run result did not match a declaration: ${event.test.fullName}`);
+            this.testRunner.recordNotRunTest(event.test);
+            this.testRunner.completeTestDeclaration(test);
+            console.error(`Not run: ${event.test.fullName} (terminal resource failure in ${event.test.reason.fullName})`);
+            await this.emitEvent("testNotRun", {
+                configuration: this.testRunner.getConfiguration(),
+                test: event.test,
+                testRunner: this.testRunner
+            });
+            return;
+        }
+        if (event.type === "run:finish") {
             this.testRunner.recordPackageResult(event.result);
+            for (const failure of event.result.errors) {
+                console.error(`Suite ${failure.phase} failed: ${failure.suite}`);
+                this.printErrorCauses(errorFromPackageRecord(failure.error));
+            }
+        }
     }
     /**
      * Projects attempt failure/retry events while retaining the raw thrown value.
@@ -83,7 +105,7 @@ export default class VelociousRunnerReporter {
         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 willRetry = failed && !event.terminalFailure && !outcome?.abortRemainingTests && attempt.attemptNumber <= retryCount;
         const { descriptions, testDescription } = this.testRunner.testMetadata(test);
         const compatibility = this.testRunner.testData(test);
         if (failed) {
@@ -221,14 +243,7 @@ export default class VelociousRunnerReporter {
         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}`));
-            }
+            this.printErrorCauses(error);
         }
         else {
             console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof error}: ${String(error)}`));
@@ -246,6 +261,33 @@ export default class VelociousRunnerReporter {
         });
         testRunner.printRerunCommand({ descriptions, testDescription, testData, leftPadding });
     }
+    /**
+     * Prints complete primary and secondary stacks once, including cyclic cause graphs.
+     * @param {unknown} error - Thrown value at the reporting boundary.
+     * @param {Set<Error>} [reported] - Error identities already printed.
+     * @returns {void}
+     */
+    printErrorCauses(error, reported = new Set()) {
+        if (!(error instanceof Error)) {
+            console.error(String(error));
+            return;
+        }
+        if (reported.has(error))
+            return;
+        reported.add(error);
+        addTrackedStackToError(error);
+        console.error(error.stack || `${error.name}: ${error.message}`);
+        if (error.cause !== undefined) {
+            console.error("Caused by:");
+            this.printErrorCauses(error.cause, reported);
+        }
+        if (error instanceof AggregateError) {
+            for (const secondary of error.errors) {
+                console.error("Related failure:");
+                this.printErrorCauses(secondary, reported);
+            }
+        }
+    }
     /**
      * Emits one legacy event and awaits listeners in registration order.
      * @param {string} eventName - Event name.
@@ -257,4 +299,4 @@ export default class VelociousRunnerReporter {
             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":"AAAA,YAAY;AAEZ,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAA;AACvE,OAAO,gBAAgB,MAAM,oCAAoC,CAAA;AACjE,OAAO,UAAU,MAAM,YAAY,CAAA;AACnC,OAAO,aAAa,MAAM,6BAA6B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAEtC,4FAA4F;AAC5F,4FAA4F;AAE5F;;;;GAIG;AACH,SAAS,sBAAsB,CAAC,WAAW;IACzC,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM;QAC9B,CAAC,CAAC,IAAI,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC;QACzF,CAAC,CAAC,IAAI,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,CAAA;IAElC,KAAK,CAAC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAA;IAC7B,IAAI,WAAW,CAAC,KAAK;QAAE,KAAK,CAAC,KAAK,GAAG,WAAW,CAAC,KAAK,CAAA;IAEtD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,2EAA2E;AAC3E,MAAM,OAAO,wBAAyB,SAAQ,KAAK;CAAG;AAEtD,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAC1C;;;;OAIG;IACH,YAAY,EAAC,UAAU,EAAE,GAAG,QAAQ,EAAC;QACnC,aAAa,CAAC,QAAQ,CAAC,CAAA;QACvB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,iGAAiG;QACjG,IAAI,CAAC,qBAAqB,GAAG,IAAI,OAAO,EAAE,CAAA;QAC1C,iDAAiD;QACjD,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;IAC7B,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,KAAK;QACjB,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;YAChC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;YACrE,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;gBAC9D,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,QAAQ,CAAC,eAAe,EAAE,CAAC,CAAA;YAC9F,CAAC;YACD,OAAM;QACR,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;YACpC,MAAM,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAA;YACpC,OAAM;QACR,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;YACjC,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAA;YACjC,OAAM;QACR,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY;YAAE,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IACpF,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,kBAAkB,CAAC,KAAK;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QAEnF,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,uDAAuD,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAA;QAEnG,qEAAqE;QACrE,MAAM,OAAO,GAAG,oEAAoE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QACpG,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;QAC3E,MAAM,qBAAqB,GAAG,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAA;QAExE,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;YAC1B,qBAAqB,CAAC,IAAI,CAAC,EAAC,aAAa,EAAE,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,OAAO,EAAE,EAAC,CAAC,CAAA;YAC3G,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAA;QAC7D,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;QACnD,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QACxD,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,CAAA;QAC5B,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,EAAE,UAAU,CAAC,CAAA;QAC/D,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,mBAAmB,IAAI,OAAO,CAAC,aAAa,IAAI,UAAU,CAAA;QAChG,MAAM,EAAC,YAAY,EAAE,eAAe,EAAC,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QAC1E,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QAEpD,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,IAAI,CAAC,SAAS,CAAC,mBAAmB,EAAE;gBACxC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE;gBACjD,YAAY;gBACZ,KAAK;gBACL,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,WAAW,EAAE,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS;gBAC9D,WAAW;gBACX,UAAU;gBACV,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,eAAe;gBACf,UAAU,EAAE,IAAI,CAAC,UAAU;gBAC3B,SAAS;aACV,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,eAAe,WAAW,IAAI,UAAU,kBAAkB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAA;YACtL,MAAM,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE;gBACnC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE;gBACjD,YAAY;gBACZ,KAAK;gBACL,WAAW,EAAE,OAAO,CAAC,aAAa,GAAG,CAAC;gBACtC,WAAW;gBACX,UAAU;gBACV,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,eAAe;gBACf,UAAU,EAAE,IAAI,CAAC,UAAU;aAC5B,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,OAAO,CAAC,aAAa,GAAG,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE;gBAClC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE;gBACjD,YAAY;gBACZ,KAAK;gBACL,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,WAAW;gBACX,UAAU;gBACV,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,eAAe;gBACf,UAAU,EAAE,IAAI,CAAC,UAAU;aAC5B,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,OAAO,EAAE,mBAAmB,EAAE,CAAC;YACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;YAEnD,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC;gBACjC,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,QAAQ,IAAI,WAAW;gBACxD,eAAe,EAAE,QAAQ,CAAC,eAAe;gBACzC,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;aACvC,CAAC,CAAA;YACF,MAAM,IAAI,CAAC,gBAAgB,CAAC;gBAC1B,qBAAqB;gBACrB,YAAY;gBACZ,KAAK;gBACL,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;gBAChD,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,eAAe;aAChB,CAAC,CAAA;YACF,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAA;YAC7C,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;YAC3B,MAAM,IAAI,wBAAwB,CAAC,4DAA4D,CAAC,CAAA;QAClG,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,eAAe,CAAC,KAAK;QACzB,qEAAqE;QACrE,MAAM,iBAAiB,GAAG,6DAA6D,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QACpG,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAA;QAE/F,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,iBAAiB,CAAC,QAAQ,EAAE,CAAC,CAAA;QAE9G,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QACnD,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QACpD,MAAM,UAAU,GAAG,iBAAiB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,KAAK,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAA;QAEvG,IAAI,iBAAiB,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC;gBACjC,UAAU;gBACV,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,QAAQ,IAAI,WAAW;gBACxD,eAAe,EAAE,QAAQ,CAAC,eAAe;gBACzC,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;aACvC,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,iBAAiB,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC1C,IAAI,CAAC,UAAU,CAAC,oBAAoB,EAAE,CAAA;QACxC,CAAC;aAAM,CAAC;YACN,MAAM,YAAY,GAAG,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;YACtD,MAAM,OAAO,GAAG,YAAY;gBAC1B,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,aAAa,CAAC;gBAClE,CAAC,CAAC,SAAS,CAAA;YACb,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAA;YACjE,MAAM,KAAK,GAAG,OAAO,EAAE,MAAM;gBAC3B,CAAC,CAAC,OAAO,CAAC,KAAK;gBACf,CAAC,CAAC,YAAY,CAAC,MAAM;oBACnB,CAAC,CAAC,YAAY,CAAC,KAAK;oBACpB,CAAC,CAAC,iBAAiB,CAAC,KAAK;wBACvB,CAAC,CAAC,sBAAsB,CAAC,iBAAiB,CAAC,KAAK,CAAC;wBACjD,CAAC,CAAC,SAAS,CAAA;YAEjB,MAAM,IAAI,CAAC,gBAAgB,CAAC;gBAC1B,qBAAqB,EAAE,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE;gBACjE,YAAY,EAAE,QAAQ,CAAC,YAAY;gBACnC,KAAK;gBACL,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;gBACzD,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,QAAQ,EAAE,aAAa,CAAC,QAAQ;gBAChC,eAAe,EAAE,QAAQ,CAAC,eAAe;aAC1C,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAA;QAC7C,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;IAC7B,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,gBAAgB,CAAC,EAAC,qBAAqB,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAC;QACnH,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAA;QAClC,MAAM,aAAa,GAAG,UAAU,CAAC,kBAAkB,CAAC,qBAAqB,CAAC,CAAA;QAE1E,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;YAC3B,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,WAAW,kBAAkB,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;YAC9E,sBAAsB,CAAC,KAAK,CAAC,CAAA;YAE7B,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,KAAK,CAAC,CAAA;YACpD,MAAM,YAAY,GAAG,gBAAgB,CAAC,eAAe,EAAE,CAAA;YACvD,MAAM,UAAU,GAAG,YAAY,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;YAE5C,IAAI,UAAU,EAAE,CAAC;gBACf,KAAK,MAAM,SAAS,IAAI,UAAU;oBAAE,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,WAAW,KAAK,SAAS,EAAE,CAAC,CAAC,CAAA;YACnG,CAAC;QACH,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,WAAW,wBAAwB,OAAO,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAA;QACvG,CAAC;QAED,UAAU,CAAC,wBAAwB,CAAC,EAAC,aAAa,EAAE,WAAW,EAAC,CAAC,CAAA;QACjE,UAAU,CAAC,gBAAgB,CAAC,EAAC,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,eAAe,EAAC,CAAC,CAAA;QAE5F,MAAM,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE;YACjC,aAAa,EAAE,UAAU,CAAC,gBAAgB,EAAE;YAC5C,YAAY;YACZ,KAAK;YACL,QAAQ;YACR,QAAQ;YACR,eAAe;YACf,UAAU;SACX,CAAC,CAAA;QAEF,UAAU,CAAC,iBAAiB,CAAC,EAAC,YAAY,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAC,CAAC,CAAA;IACtF,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,SAAS,CAAC,SAAS,EAAE,OAAO;QAChC,KAAK,MAAM,QAAQ,IAAI,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC;YAAE,MAAM,QAAQ,CAAC,OAAO,CAAC,CAAA;IACjF,CAAC;CACF","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/** @typedef {import(\"@velocious/testing/runner\").TestErrorRecord} PackageTestErrorRecord */\n\n/**\n * Restores the Error shape serialized by the package runner.\n * @param {PackageTestErrorRecord} errorRecord - Serialized package failure.\n * @returns {Error} - Error compatible with Velocious's legacy reporter contract.\n */\nfunction errorFromPackageRecord(errorRecord) {\n  const error = errorRecord.errors\n    ? new AggregateError(errorRecord.errors.map(errorFromPackageRecord), errorRecord.message)\n    : new Error(errorRecord.message)\n\n  error.name = errorRecord.name\n  if (errorRecord.stack) error.stack = errorRecord.stack\n\n  return error\n}\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 setupFailure = this.testRunner.setupFailureOutcomeFor(test)\n      const error = outcome?.failed\n        ? outcome.error\n        : setupFailure.failed\n          ? setupFailure.error\n          : packageTestResult.error\n            ? errorFromPackageRecord(packageTestResult.error)\n            : undefined\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"]}
+//# 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 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/** @typedef {import(\"@velocious/testing/runner\").TestErrorRecord} PackageTestErrorRecord */\n\n/**\n * Restores the Error shape serialized by the package runner.\n * @param {PackageTestErrorRecord} errorRecord - Serialized package failure.\n * @returns {Error} - Error compatible with Velocious's legacy reporter contract.\n */\nfunction errorFromPackageRecord(errorRecord) {\n  const error = errorRecord.errors\n    ? new AggregateError(errorRecord.errors.map(errorFromPackageRecord), errorRecord.message)\n    : new Error(errorRecord.message)\n\n  error.name = errorRecord.name\n  if (errorRecord.stack) error.stack = errorRecord.stack\n  if (errorRecord.cause) error.cause = errorFromPackageRecord(errorRecord.cause)\n  if (errorRecord.terminalResource) Object.assign(error, {terminalResource: errorRecord.terminalResource})\n\n  return error\n}\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 === \"test:not-run\") {\n      const test = this.testRunner.findTestDeclaration(event.test.fullName)\n      if (!test) throw new Error(`Package not-run result did not match a declaration: ${event.test.fullName}`)\n      this.testRunner.recordNotRunTest(event.test)\n      this.testRunner.completeTestDeclaration(test)\n      console.error(`Not run: ${event.test.fullName} (terminal resource failure in ${event.test.reason.fullName})`)\n      await this.emitEvent(\"testNotRun\", {\n        configuration: this.testRunner.getConfiguration(),\n        test: event.test,\n        testRunner: this.testRunner\n      })\n      return\n    }\n\n    if (event.type === \"run:finish\") {\n      this.testRunner.recordPackageResult(event.result)\n      for (const failure of event.result.errors) {\n        console.error(`Suite ${failure.phase} failed: ${failure.suite}`)\n        this.printErrorCauses(errorFromPackageRecord(failure.error))\n      }\n    }\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 && !event.terminalFailure && !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 setupFailure = this.testRunner.setupFailureOutcomeFor(test)\n      const error = outcome?.failed\n        ? outcome.error\n        : setupFailure.failed\n          ? setupFailure.error\n          : packageTestResult.error\n            ? errorFromPackageRecord(packageTestResult.error)\n            : undefined\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      this.printErrorCauses(error)\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   * Prints complete primary and secondary stacks once, including cyclic cause graphs.\n   * @param {unknown} error - Thrown value at the reporting boundary.\n   * @param {Set<Error>} [reported] - Error identities already printed.\n   * @returns {void}\n   */\n  printErrorCauses(error, reported = new Set()) {\n    if (!(error instanceof Error)) {\n      console.error(String(error))\n      return\n    }\n    if (reported.has(error)) return\n    reported.add(error)\n    addTrackedStackToError(error)\n    console.error(error.stack || `${error.name}: ${error.message}`)\n    if (error.cause !== undefined) {\n      console.error(\"Caused by:\")\n      this.printErrorCauses(error.cause, reported)\n    }\n    if (error instanceof AggregateError) {\n      for (const secondary of error.errors) {\n        console.error(\"Related failure:\")\n        this.printErrorCauses(secondary, reported)\n      }\n    }\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/testing/test-runner.js

@@ -142,6 +142,8 @@ import VelociousTestArguments from "./velocious-test-arguments.js"
  * @property {import("../database/pool/base.js").TestSharedConnectionRegistration | undefined} sharedRegistration - Physical-key shared registration once published.
  */
 
+const testingPackageDirectory = path.dirname(fileURLToPath(import.meta.resolve("@velocious/testing/package.json")))
+
 /**
  * Runs to file slug.
  * @param {string} value - Value to sanitize.
@@ -197,6 +199,8 @@ export default class TestRunner {
     this._successfulTests = 0
     this._testsCount = 0
     this._failedTestDetails = []
+    /** @type {import("@velocious/testing/runner").NonRunTestResult[]} */
+    this._notRunTestDetails = []
     /** @type {{fullDescription: string, filePath: string, line: number} | null} */
     this._lastTestContext = null
     /** @type {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} */
@@ -1007,6 +1011,25 @@ export default class TestRunner {
     return this._failedTests
   }
 
+  /**
+   * Counts selected tests blocked by a terminal resource.
+   * @returns {number} - Selected tests not executed because a shared resource failed.
+   */
+  getNotRunTests() { return this._notRunTestDetails.length }
+
+  /**
+   * Returns runtime non-run attribution.
+   * @returns {import("@velocious/testing/runner").NonRunTestResult[]} - Runtime non-run details with the originating failure.
+   */
+  getNotRunTestDetails() { return this._notRunTestDetails }
+
+  /**
+   * Records a selected test that did not execute.
+   * @param {import("@velocious/testing/runner").NonRunTestResult} result - Terminal-resource non-run record.
+   * @returns {void}
+   */
+  recordNotRunTest(result) { this._notRunTestDetails.push(result) }
+
   /**
    * Runs get failed test details.
    * @returns {FailedTestDetail[]} - Failed test details.
@@ -1087,6 +1110,14 @@ export default class TestRunner {
     return this._packageResult?.tests.length ?? this._testDurations.length
   }
 
+  /**
+   * Distinguishes an empty selection from a failure before selected cases execute.
+   * @returns {boolean} - Whether selection matched no declarations.
+   */
+  hasNoMatches() {
+    return this._packageResult?.noMatches === true
+  }
+
   /**
    * Returns the tests recorded during the run, slowest first.
    * @param {number} [limit] - Maximum number of tests to return (0 returns all).
@@ -1105,6 +1136,7 @@ export default class TestRunner {
   async prepare() {
     this.anyTestsFocussed = false
     this._failedTests = 0
+    this._notRunTestDetails = []
     this._successfulTests = 0
     this._testsCount = 0
     this._abortRemainingTests = false
@@ -1177,7 +1209,7 @@ export default class TestRunner {
 
       if (portablePath.endsWith("/src/testing/test-runner.js")) continue
       if (portablePath.endsWith("/src/testing/test.js")) continue
-      if (portablePath.includes("/node_modules/@velocious/testing/")) continue
+      if (resolvedFilePath.startsWith(`${testingPackageDirectory}${path.sep}`)) continue
 
       return {filePath: resolvedFilePath, line: Number(match[2])}
     }

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

@@ -1,7 +1,6 @@
 // @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"
@@ -21,6 +20,8 @@ function errorFromPackageRecord(errorRecord) {
 
   error.name = errorRecord.name
   if (errorRecord.stack) error.stack = errorRecord.stack
+  if (errorRecord.cause) error.cause = errorFromPackageRecord(errorRecord.cause)
+  if (errorRecord.terminalResource) Object.assign(error, {terminalResource: errorRecord.terminalResource})
 
   return error
 }
@@ -68,7 +69,27 @@ export default class VelociousRunnerReporter {
       return
     }
 
-    if (event.type === "run:finish") this.testRunner.recordPackageResult(event.result)
+    if (event.type === "test:not-run") {
+      const test = this.testRunner.findTestDeclaration(event.test.fullName)
+      if (!test) throw new Error(`Package not-run result did not match a declaration: ${event.test.fullName}`)
+      this.testRunner.recordNotRunTest(event.test)
+      this.testRunner.completeTestDeclaration(test)
+      console.error(`Not run: ${event.test.fullName} (terminal resource failure in ${event.test.reason.fullName})`)
+      await this.emitEvent("testNotRun", {
+        configuration: this.testRunner.getConfiguration(),
+        test: event.test,
+        testRunner: this.testRunner
+      })
+      return
+    }
+
+    if (event.type === "run:finish") {
+      this.testRunner.recordPackageResult(event.result)
+      for (const failure of event.result.errors) {
+        console.error(`Suite ${failure.phase} failed: ${failure.suite}`)
+        this.printErrorCauses(errorFromPackageRecord(failure.error))
+      }
+    }
   }
 
   /**
@@ -95,7 +116,7 @@ export default class VelociousRunnerReporter {
     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 willRetry = failed && !event.terminalFailure && !outcome?.abortRemainingTests && attempt.attemptNumber <= retryCount
     const {descriptions, testDescription} = this.testRunner.testMetadata(test)
     const compatibility = this.testRunner.testData(test)
 
@@ -245,15 +266,8 @@ export default class VelociousRunnerReporter {
 
     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")
+      this.printErrorCauses(error)
 
-      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)}`))
     }
@@ -274,6 +288,33 @@ export default class VelociousRunnerReporter {
     testRunner.printRerunCommand({descriptions, testDescription, testData, leftPadding})
   }
 
+  /**
+   * Prints complete primary and secondary stacks once, including cyclic cause graphs.
+   * @param {unknown} error - Thrown value at the reporting boundary.
+   * @param {Set<Error>} [reported] - Error identities already printed.
+   * @returns {void}
+   */
+  printErrorCauses(error, reported = new Set()) {
+    if (!(error instanceof Error)) {
+      console.error(String(error))
+      return
+    }
+    if (reported.has(error)) return
+    reported.add(error)
+    addTrackedStackToError(error)
+    console.error(error.stack || `${error.name}: ${error.message}`)
+    if (error.cause !== undefined) {
+      console.error("Caused by:")
+      this.printErrorCauses(error.cause, reported)
+    }
+    if (error instanceof AggregateError) {
+      for (const secondary of error.errors) {
+        console.error("Related failure:")
+        this.printErrorCauses(secondary, reported)
+      }
+    }
+  }
+
   /**
    * Emits one legacy event and awaits listeners in registration order.
    * @param {string} eventName - Event name.

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.652",
+  "version": "1.0.654",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [
@@ -91,7 +91,7 @@
     "ws": "^8.21.3"
   },
   "peerDependencies": {
-    "@velocious/testing": "0.0.9",
+    "@velocious/testing": "^0.0.12",
     "react": ">=18",
     "smtp-connection": "^4.0.2",
     "sqlite": "^5.1.1",
@@ -121,7 +121,7 @@
     "@types/react-dom": "^19.2.3",
     "@types/strftime": "^0.9.8",
     "@types/ws": "^8.18.1",
-    "@velocious/testing": "0.0.9",
+    "@velocious/testing": "0.0.12",
     "chokidar-cli": "^3.0.0",
     "cpy-cli": "^7.0.0",
     "esbuild": "^0.28.0",
@@ -142,7 +142,7 @@
     "selenium-webdriver": "^4.39.0",
     "sqlite": "^5.1.1",
     "sqlite3": "^6.0.1",
-    "system-testing": "^1.0.108",
+    "system-testing": "^1.0.137",
     "tedious": "^20.0.0",
     "typescript": "^7.0.2",
     "uniqunize": "^1.0.3"

package/scripts/browser-test-session.js

@@ -7,6 +7,7 @@ import { createRequire } from "node:module"
 import path from "node:path"
 import { promisify } from "node:util"
 import timeout from "awaitery/build/timeout.js"
+import { resolveChromeRuntime } from "system-testing/build/chrome-runtime-manager.js"
 import SystemTest from "system-testing/build/system-test.js"
 
 /**
@@ -33,13 +34,12 @@ import SystemTest from "system-testing/build/system-test.js"
 /**
  * @typedef {object} BrowserTestSystemTestConfig
  * @property {boolean} debug - Whether SystemTest should emit debug output.
- * @property {{type: "selenium", options: {chromeArguments: string[], chromeBinaryPath: string}}} driver - Selenium driver config.
+ * @property {{type: "selenium", options: {chromeArguments: string[], chromeBinaryPath: string, chromedriverPath: string}}} driver - Selenium driver config.
  * @property {string} httpHost - HTTP host for the browser-test app.
  * @property {number} httpPort - HTTP port for the browser-test app.
  */
 
 const require = createRequire(import.meta.url)
-const { binaryPaths } = require("selenium-webdriver/common/seleniumManager.js")
 const { CancellationError, waitForServer } = require("selenium-webdriver/http/util.js")
 const { findFreePort } = require("selenium-webdriver/net/portprober.js")
 const execFileAsync = promisify(execFile)
@@ -97,30 +97,24 @@ async function assertExecutable(executablePath, description) {
 }
 
 /**
- * Resolves, validates, and persists the exact Chrome/ChromeDriver pair.
+ * Resolves, validates, and persists the exact Chrome-for-Testing runtime pair.
  * @param {object} [args] - Prewarm options.
- * @param {() => {browserPath?: string, driverPath?: string}} [args.binaryPathsResolver] - Selenium path resolver.
  * @param {string} [args.manifestPath] - Runtime manifest path.
+ * @param {() => Promise<{chromeBinaryPath: string, chromedriverPath: string} | undefined>} [args.runtimeResolver] - System-testing runtime resolver.
  * @param {(executablePath: string) => Promise<string>} [args.versionReader] - Executable version reader.
  * @returns {Promise<BrowserTestChromeRuntime>} - Prewarmed runtime.
  */
 export async function prewarmBrowserTestChromeRuntime({
-  binaryPathsResolver = () => binaryPaths([
-    "--browser",
-    "chrome",
-    "--language-binding",
-    "javascript",
-    "--output",
-    "json",
-    "--avoid-browser-download"
-  ]),
   manifestPath = defaultManifestPath(),
+  runtimeResolver = resolveChromeRuntime,
   versionReader = readExecutableVersion
 } = {}) {
-  const { browserPath, driverPath } = binaryPathsResolver()
+  const chromeRuntime = await runtimeResolver()
+  const browserPath = chromeRuntime?.chromeBinaryPath
+  const driverPath = chromeRuntime?.chromedriverPath
 
-  if (!browserPath) throw new Error("Selenium Manager did not resolve a Chrome executable")
-  if (!driverPath) throw new Error("Selenium Manager did not resolve a ChromeDriver executable")
+  if (!browserPath) throw new Error("System-testing did not resolve a Chrome executable")
+  if (!driverPath) throw new Error("System-testing did not resolve a ChromeDriver executable")
 
   await assertExecutable(browserPath, "Chrome")
   await assertExecutable(driverPath, "ChromeDriver")
@@ -143,7 +137,7 @@ export async function prewarmBrowserTestChromeRuntime({
   const browserVersion = parseExecutableVersion(browserVersionOutput, "Chrome")
   const driverVersion = parseExecutableVersion(driverVersionOutput, "ChromeDriver")
 
-  if (browserVersion.split(".")[0] !== driverVersion.split(".")[0]) {
+  if (browserVersion !== driverVersion) {
     throw new Error(`Chrome ${browserVersion} is incompatible with ChromeDriver ${driverVersion}`)
   }
 
@@ -218,14 +212,14 @@ function browserTestChromeArguments() {
 
 /**
  * Builds the SystemTest factory used by BrowserTestSession so the Selenium builder path
- * receives the pinned Chrome binary and the required headless container Chrome arguments.
+ * receives the pinned Chrome runtime and the required headless container Chrome arguments.
  * @param {object} [args] - Factory options.
  * @param {string[]} [args.chromeArguments] - Chrome launch arguments.
  * @param {boolean} [args.debug] - Whether SystemTest should emit debug output.
  * @param {string} [args.httpHost] - HTTP host for the browser-test app.
  * @param {number} [args.httpPort] - HTTP port for the browser-test app.
  * @param {(config: BrowserTestSystemTestConfig) => BrowserTestSystemTest} [args.systemTestCurrent] - SystemTest factory.
- * @returns {(args: {browserPath: string, remoteUrl: string}) => BrowserTestSystemTest} - SystemTest factory.
+ * @returns {(args: {browserPath: string, driverPath: string, remoteUrl: string}) => BrowserTestSystemTest} - SystemTest factory.
  */
 export function buildBrowserTestSystemTestFactory({
   chromeArguments = browserTestChromeArguments(),
@@ -234,11 +228,11 @@ export function buildBrowserTestSystemTestFactory({
   httpPort = 1984,
   systemTestCurrent = SystemTest.current
 } = {}) {
-  return ({browserPath}) => systemTestCurrent({
+  return ({browserPath, driverPath}) => systemTestCurrent({
     debug,
     driver: {
       type: "selenium",
-      options: {chromeArguments, chromeBinaryPath: browserPath}
+      options: {chromeArguments, chromeBinaryPath: browserPath, chromedriverPath: driverPath}
     },
     httpHost,
     httpPort
@@ -428,7 +422,7 @@ export class BrowserTestSession {
    * @param {(runtime: BrowserTestChromeRuntime) => Promise<BrowserTestChromeDriverService>} [args.chromeDriverServiceFactory] - Driver service factory.
    * @param {(phase: string) => Promise<string>} [args.processSnapshot] - Process snapshot callback.
    * @param {BrowserTestChromeRuntime} args.runtime - Chrome runtime.
-   * @param {(args: {browserPath: string, remoteUrl: string}) => BrowserTestSystemTest} args.systemTestFactory - SystemTest factory.
+   * @param {(args: {browserPath: string, driverPath: string, remoteUrl: string}) => BrowserTestSystemTest} args.systemTestFactory - SystemTest factory.
    */
   constructor({
     chromeDriverServiceFactory = async (runtime) => new ManagedChromeDriverProcess(runtime),
@@ -463,7 +457,11 @@ export class BrowserTestSession {
       this.startupPhase = "starting ChromeDriver service"
       this.remoteUrl = await this.chromeDriverService.start()
       process.env.SELENIUM_REMOTE_URL = this.remoteUrl
-      this.systemTest = this.systemTestFactory({browserPath: this.runtime.browserPath, remoteUrl: this.remoteUrl})
+      this.systemTest = this.systemTestFactory({
+        browserPath: this.runtime.browserPath,
+        driverPath: this.runtime.driverPath,
+        remoteUrl: this.remoteUrl
+      })
       this.startupPhase = "creating Selenium WebDriver session"
       await this.systemTest.start()
 

package/src/database/query/model-class-query.js

@@ -1468,7 +1468,9 @@ function splitWhereHash({hash, modelClass}) {
     const isNested = isPlainObject(value)
     const relationship = getRelationshipByName(modelClass, key)
 
-    if (isNested) {
+    if (isNested && !relationship && resolveColumnName(modelClass, key)) {
+      resolvedHash[key] = value
+    } else if (isNested) {
       if (relationship) {
         const rawTargetModelClass = relationship.getTargetModelClass()
         if (!rawTargetModelClass) {

package/src/database/query/where-hash.js

@@ -1,6 +1,7 @@
 // @ts-check
 
 import WhereBase from "./where-base.js"
+import WhereIn from "./where-in.js"
 
 /**
  * VelociousDatabaseQueryWhereHash class.
@@ -50,7 +51,17 @@ export default class VelociousDatabaseQueryWhereHash extends WhereBase {
         if (index > 0) sql += " AND "
         sql += "1=0"
       } else if (!Array.isArray(whereValue) && whereValue !== null && typeof whereValue == "object") {
-        sql += this._whereSQLFromHash(whereValue, whereKey, index)
+        if (tableName && "in" in whereValue) {
+          if (index > 0) sql += " AND "
+
+          sql += WhereIn.toSql({
+            columnSql: `${options.quoteTableName(tableName)}.${options.quoteColumnName(whereKey)}`,
+            options,
+            values: WhereIn.values(whereValue)
+          })
+        } else {
+          sql += this._whereSQLFromHash(whereValue, whereKey, index)
+        }
       } else {
         if (index > 0) sql += " AND "