velocious 1.0.594 → 1.0.595

package/build/testing/test-runner.js

@@ -1456,14 +1456,15 @@ export default class TestRunner {
      * @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */
     const consoleObject = /** @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */ (console)
     /**
-     * Original console methods.
+     * Original console methods captured as direct references so stopping restores
+     * the exact method that was installed at capture start.
      * @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */
     const originalConsoleMethods = {
-      debug: consoleObject.debug.bind(console),
-      error: consoleObject.error.bind(console),
-      info: consoleObject.info.bind(console),
-      log: consoleObject.log.bind(console),
-      warn: consoleObject.warn.bind(console)
+      debug: consoleObject.debug,
+      error: consoleObject.error,
+      info: consoleObject.info,
+      log: consoleObject.log,
+      warn: consoleObject.warn
     }
     let stopped = false
     let outputText = ""
@@ -1473,7 +1474,7 @@ export default class TestRunner {
         lines.push(`[${new Date().toISOString()}] [${methodName}] ${format(...args)}`)
 
         if (passthrough) {
-          originalConsoleMethods[methodName](...args)
+          originalConsoleMethods[methodName].apply(consoleObject, args)
         }
       }
     }

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.594",
+  "version": "1.0.595",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [
@@ -27,6 +27,7 @@
     "benchmark:http-client-content-length-byte-length": "node benchmark/http-client-content-length-byte-length.js",
     "benchmark:frontend-model-serialization-resource-metadata": "node benchmark/frontend-model-serialization-resource-metadata.js",
     "benchmark:sql-diagnostic-scans": "node --expose-gc benchmark/sql-diagnostic-scans.js",
+    "benchmark:test-mode-diagnostics": "node --expose-gc benchmark/test-mode-diagnostics.js",
     "build": "node scripts/clean-build.js && npm run compile",
     "compile": "tsc -b && npm run copy:js && npm run copy:ejs && npm run copy:templates && node scripts/ensure-bin-executable.js",
     "copy:js": "cpy \"index.js\" build && cpy \"bin/**/*.js\" build/bin && cpy \"src/**/*.js\" build --parents",

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 SystemTest from "system-testing/build/system-test.js"
 
 /**
  * @typedef {object} BrowserTestChromeRuntime
@@ -29,6 +30,14 @@ import timeout from "awaitery/build/timeout.js"
  * @property {() => Promise<string>} diagnostics - Reads retained ChromeDriver diagnostics.
  */
 
+/**
+ * @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 {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")
@@ -185,6 +194,57 @@ export async function loadOrPrewarmBrowserTestChromeRuntime() {
   }
 }
 
+/**
+ * Formatted default Chrome launch arguments for every browser-test session. Mirrors the
+ * Selenium driver defaults used by system-testing so supplying the list does not drop the
+ * headless container requirements, and adds pipe-mode devtools transport, which ChromeDriver
+ * recommends over the injected `--remote-debugging-port` and which keeps the Chrome instance
+ * alive until a session is created on headless container CI.
+ * @returns {string[]} - Chrome launch arguments.
+ */
+function browserTestChromeArguments() {
+  return [
+    "--disable-backgrounding-occluded-windows",
+    "--disable-background-timer-throttling",
+    "--disable-dev-shm-usage",
+    "--disable-gpu",
+    "--disable-renderer-backgrounding",
+    "--headless=new",
+    "--no-sandbox",
+    "--remote-debugging-pipe",
+    "--window-size=1920,1080"
+  ]
+}
+
+/**
+ * Builds the SystemTest factory used by BrowserTestSession so the Selenium builder path
+ * receives the pinned Chrome binary 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.
+ */
+export function buildBrowserTestSystemTestFactory({
+  chromeArguments = browserTestChromeArguments(),
+  debug = false,
+  httpHost = "127.0.0.1",
+  httpPort = 1984,
+  systemTestCurrent = SystemTest.current
+} = {}) {
+  return ({browserPath}) => systemTestCurrent({
+    debug,
+    driver: {
+      type: "selenium",
+      options: {chromeArguments, chromeBinaryPath: browserPath}
+    },
+    httpHost,
+    httpPort
+  })
+}
+
 /**
  * Formats a child process exit.
  * @param {{code: number | null, error?: Error, signal: NodeJS.Signals | null}} result - Exit result.

package/scripts/test-browser.js

@@ -5,7 +5,6 @@ import path from "node:path"
 import {pathToFileURL} from "node:url"
 import {build} from "esbuild"
 import initSqlJs from "sql.js"
-import SystemTest from "system-testing/build/system-test.js"
 import Application from "../src/application.js"
 import Configuration from "../src/configuration.js"
 import BrowserEnvironmentHandler from "../src/environment-handlers/browser.js"
@@ -22,6 +21,7 @@ import dummyDirectory from "../spec/dummy/dummy-directory.js"
 import {withSourcePeerPackage} from "../src/environment-handlers/node/source-peer-package.js"
 import {
   BrowserTestSession,
+  buildBrowserTestSystemTestFactory,
   loadOrPrewarmBrowserTestChromeRuntime,
   stopBrowserTestSession
 } from "./browser-test-session.js"
@@ -405,12 +405,8 @@ async function runBrowserTests() {
     backendApplication = await startBrowserBackendServer(backendConfiguration, browserBackendPort)
     browserTestSession = new BrowserTestSession({
       runtime: chromeRuntime,
-      systemTestFactory: ({browserPath}) => SystemTest.current({
+      systemTestFactory: buildBrowserTestSystemTestFactory({
         debug: process.env.SYSTEM_TEST_DEBUG === "true",
-        driver: {
-          type: "selenium",
-          options: {chromeBinaryPath: browserPath}
-        },
         httpHost: systemTestHttpHost,
         httpPort: systemTestHttpPort
       })

package/src/configuration.js

@@ -364,6 +364,15 @@ export default class VelociousConfiguration {
      */
     this._websocketChannelSubscriptions = new Map()
 
+    /**
+     * In-flight local (per-process) websocket channel broadcast deliveries,
+     * launched fire-and-forget from `_broadcastToChannelLocal` so one slow
+     * subscriber never blocks another. Tracked here so
+     * `awaitPendingBroadcasts` can snapshot and drain them before settling.
+     * Settled deliveries are removed by the tracking-level cleanup.
+     * @type {Set<Promise<void>>} */
+    this._localBroadcastDeliveries = new Set()
+
     /**
      * Stores the websocket sessions value.
      * @type {Set<import("./http-server/client/websocket-session.js").default>} - Live websocket sessions, including paused sessions within the grace window.
@@ -2810,8 +2819,13 @@ export default class VelociousConfiguration {
     const websocketEvents = this._websocketEvents
 
     if (websocketEvents && typeof websocketEvents.awaitPendingBroadcasts === "function") {
+      // Drain the host/worker publish queues (including event-log persistence)
+      // before draining local deliveries, because host dispatch launches the
+      // local deliveries synchronously and they must be part of the snapshot.
       await websocketEvents.awaitPendingBroadcasts()
     }
+
+    await this._awaitLocalBroadcastDeliveries()
   }
 
   /**
@@ -2845,7 +2859,7 @@ export default class VelociousConfiguration {
 
       if (!matches) continue
 
-      void this.withoutCurrentConnectionContexts(() => {
+      const delivery = this.withoutCurrentConnectionContexts(() => {
         return Promise
           .resolve()
           .then(() => this._deliverWebsocketChannelBroadcast(subscription, body, {eventId: meta?.eventId}))
@@ -2853,9 +2867,35 @@ export default class VelociousConfiguration {
             console.error(`broadcastToChannel: ${name} subscription ${subscription.subscriptionId} deliverBroadcast threw`, error)
           })
       })
+
+      // Keep the fire-and-forget delivery (never awaited at broadcast time) but
+      // track it so `awaitPendingBroadcasts` can drain it before settling. Remove
+      // on settle; the failure handler also satisfies the promise so a rejected
+      // delivery never becomes an unhandled rejection.
+      this._localBroadcastDeliveries.add(delivery)
+
+      delivery.then(
+        () => { this._localBroadcastDeliveries.delete(delivery) },
+        () => { this._localBroadcastDeliveries.delete(delivery) }
+      )
     }
   }
 
+  /**
+   * Awaits a snapshot of the in-flight local (per-process) websocket channel
+   * broadcast deliveries. Called from `awaitPendingBroadcasts` after the host
+   * publish queues drain, so every delivery those queues launched is captured.
+   * New deliveries enqueued after the snapshot are not awaited. Individual
+   * delivery errors are isolated per subscriber — the delivery chain already
+   * logs them and resolves — so a snapshotted rejection never fails this barrier.
+   * @returns {Promise<void>}
+   */
+  async _awaitLocalBroadcastDeliveries() {
+    const snapshot = [...this._localBroadcastDeliveries]
+
+    await Promise.allSettled(snapshot)
+  }
+
   /**
    * Runs deliver websocket channel broadcast.
    * @param {import("./http-server/websocket-channel.js").default} subscription - Channel subscription.

package/src/testing/test-runner.js

@@ -1456,14 +1456,15 @@ export default class TestRunner {
      * @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */
     const consoleObject = /** @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */ (console)
     /**
-     * Original console methods.
+     * Original console methods captured as direct references so stopping restores
+     * the exact method that was installed at capture start.
      * @type {Record<ConsoleMethodName, (...args: Array<ReturnType<typeof JSON.parse>>) => void>} */
     const originalConsoleMethods = {
-      debug: consoleObject.debug.bind(console),
-      error: consoleObject.error.bind(console),
-      info: consoleObject.info.bind(console),
-      log: consoleObject.log.bind(console),
-      warn: consoleObject.warn.bind(console)
+      debug: consoleObject.debug,
+      error: consoleObject.error,
+      info: consoleObject.info,
+      log: consoleObject.log,
+      warn: consoleObject.warn
     }
     let stopped = false
     let outputText = ""
@@ -1473,7 +1474,7 @@ export default class TestRunner {
         lines.push(`[${new Date().toISOString()}] [${methodName}] ${format(...args)}`)
 
         if (passthrough) {
-          originalConsoleMethods[methodName](...args)
+          originalConsoleMethods[methodName].apply(consoleObject, args)
         }
       }
     }