velocious 1.0.649 → 1.0.651

package/src/http-client/websocket-client.js

@@ -118,19 +118,51 @@ export default class VelociousWebsocketClient extends SnapReqWebSocketClient {
     if (this.gracefulClosePromise) return await this.gracefulClosePromise
 
     this.autoReconnect = false
+    const channelSubscriptions = [...this._channelSubscriptions.values()]
     const socket = this.socket
+
+    this._channelSubscriptions.clear()
+    const {promise: publishedClosePromise, reject: rejectPublishedClose, resolve: resolvePublishedClose} = Promise.withResolvers()
+
+    this.gracefulClosePromise = publishedClosePromise
+    // This internal bridge exists only for synchronous reentrancy. Its rejection
+    // duplicates closePromise, which remains the public error source below.
+    void publishedClosePromise.catch(() => {})
     const closePromise = (async () => {
-      if (socket && socket.readyState === socket.OPEN) {
-        await new Promise((resolve) => {
-          socket.addEventListener("close", () => resolve(undefined), {once: true})
-          socket.close(1000)
-        })
+      /** @type {unknown[]} */
+      const closeErrors = []
+
+      for (const subscription of channelSubscriptions) {
+        try {
+          subscription._handleClosed("client_close")
+        } catch (error) {
+          closeErrors.push(error)
+        }
+      }
+
+      try {
+        if (socket && socket.readyState === socket.OPEN) {
+          await new Promise((resolve) => {
+            socket.addEventListener("close", () => resolve(undefined), {once: true})
+            socket.close(1000)
+          })
+        }
+      } catch (error) {
+        closeErrors.push(error)
+      }
+
+      try {
+        await super.close()
+      } catch (error) {
+        closeErrors.push(error)
       }
 
-      await super.close()
+      if (closeErrors.length === 1) throw closeErrors[0]
+      if (closeErrors.length > 1) throw new AggregateError(closeErrors, "Failed to close WebSocket client")
     })()
 
     this.gracefulClosePromise = closePromise
+    void closePromise.then(resolvePublishedClose, rejectPublishedClose)
 
     try {
       await closePromise

package/src/testing/test-runner.js

@@ -1484,13 +1484,15 @@ export default class TestRunner {
   recordSuiteHookFailure(failure) { this._suiteHookFailures.push(failure) }
 
   /**
-   * Gets the raw ancestor setup failure for a package test.
+   * Gets the raw ancestor setup failure outcome for a package test.
    * @param {PackageTestDeclaration} test - Package test declaration.
-   * @returns {ReturnType<typeof JSON.parse>} - Raw setup failure.
+   * @returns {{failed: false} | {failed: true, error: ReturnType<typeof JSON.parse>}} - Raw setup failure outcome.
    */
-  setupFailureFor(test) {
+  setupFailureOutcomeFor(test) {
     const suites = this.testMetadata(test).suites
-    return this._suiteHookFailures.find((failure) => failure.phase === "beforeAll" && suites.includes(failure.suite))?.error
+    const failure = this._suiteHookFailures.find((entry) => entry.phase === "beforeAll" && suites.includes(entry.suite))
+
+    return failure ? {failed: true, error: failure.error} : {failed: false}
   }
 
   /**

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

@@ -7,6 +7,23 @@ import restArgsError from "../utils/rest-args-error.js"
 import { testEvents } from "./test.js"
 
 /** @typedef {import("@velocious/testing/runner").TestDeclaration} PackageTestDeclaration */
+/** @typedef {import("@velocious/testing/runner").TestErrorRecord} PackageTestErrorRecord */
+
+/**
+ * Restores the Error shape serialized by the package runner.
+ * @param {PackageTestErrorRecord} errorRecord - Serialized package failure.
+ * @returns {Error} - Error compatible with Velocious's legacy reporter contract.
+ */
+function errorFromPackageRecord(errorRecord) {
+  const error = errorRecord.errors
+    ? new AggregateError(errorRecord.errors.map(errorFromPackageRecord), errorRecord.message)
+    : new Error(errorRecord.message)
+
+  error.name = errorRecord.name
+  if (errorRecord.stack) error.stack = errorRecord.stack
+
+  return error
+}
 
 /** Stops package traversal after framework-owned connection quarantine. */
 export class AbortRemainingTestsError extends Error {}
@@ -186,9 +203,14 @@ export default class VelociousRunnerReporter {
       const outcome = finalAttempt
         ? this.testRunner.attemptOutcome(test, finalAttempt.attemptNumber)
         : undefined
+      const setupFailure = this.testRunner.setupFailureOutcomeFor(test)
       const error = outcome?.failed
         ? outcome.error
-        : this.testRunner.setupFailureFor(test)
+        : setupFailure.failed
+          ? setupFailure.error
+          : packageTestResult.error
+            ? errorFromPackageRecord(packageTestResult.error)
+            : undefined
 
       await this.reportFailedTest({
         attemptConsoleOutputs: this.attemptConsoleOutputs.get(test) || [],