velocious 1.0.562 → 1.0.564

package/build/http-server/client-delivery-queue.js

@@ -0,0 +1,167 @@
+/**
+ * @typedef {object} DeliveryTask
+ * @property {number} byteLength - Retained complete-buffer bytes.
+ * @property {boolean} countedFrame - Whether this task is an outbound frame.
+ * @property {() => Promise<void>} delivery - Delivery operation.
+ * @property {(error?: Error) => void} settle - Settles the enqueue promise.
+ */
+// @ts-check
+
+export class ClientDeliveryQueueOverflowError extends Error {
+  /**
+   * Builds an outbound queue overflow error.
+   * @param {object} args - Overflow details.
+   * @param {number} args.clientCount - Client identifier.
+   * @param {number} args.maxBytes - Configured byte high-water mark.
+   * @param {number} args.maxFrames - Configured frame high-water mark.
+   * @param {number} args.pendingBytes - Bytes retained before rejecting the frame.
+   * @param {number} args.pendingFrames - Frames retained before rejecting the frame.
+   * @param {number} args.rejectedBytes - Rejected frame size.
+   */
+  constructor({clientCount, maxBytes, maxFrames, pendingBytes, pendingFrames, rejectedBytes}) {
+    super(`WebSocket client ${clientCount} exceeded its outbound queue limit (${pendingFrames}/${maxFrames} frames, ${pendingBytes}/${maxBytes} bytes; rejected ${rejectedBytes} bytes)`)
+    this.name = "ClientDeliveryQueueOverflowError"
+  }
+}
+
+export default class ClientDeliveryQueue {
+  /**
+   * Builds a per-client delivery queue.
+   * @param {object} args - Queue options.
+   * @param {number} args.clientCount - Client identifier.
+   * @param {number} args.maxBytes - Byte high-water mark.
+   * @param {number} args.maxFrames - Frame high-water mark.
+   * @param {(error: ClientDeliveryQueueOverflowError) => void} args.onOverflow - Overflow handler.
+   */
+  constructor({clientCount, maxBytes, maxFrames, onOverflow}) {
+    this.clientCount = clientCount
+    this.maxBytes = maxBytes
+    this.maxFrames = maxFrames
+    this.onOverflow = onOverflow
+    /** @type {DeliveryTask[]} */
+    this.tasks = []
+    /** @type {DeliveryTask | undefined} */
+    this.activeTask = undefined
+    this.pendingBytes = 0
+    this.pendingFrames = 0
+    this.destroyed = false
+  }
+
+  /**
+   * Enqueues one complete output buffer.
+   * @param {object} args - Delivery details.
+   * @param {number} args.byteLength - Exact buffer byte length.
+   * @param {() => Promise<void>} args.delivery - Delivery operation.
+   * @returns {Promise<void>} - Settles after delivery or teardown.
+   */
+  enqueueFrame({byteLength, delivery}) {
+    if (this.destroyed) return Promise.resolve()
+
+    if (this.pendingFrames + 1 > this.maxFrames || this.pendingBytes + byteLength > this.maxBytes) {
+      const error = new ClientDeliveryQueueOverflowError({
+        clientCount: this.clientCount,
+        maxBytes: this.maxBytes,
+        maxFrames: this.maxFrames,
+        pendingBytes: this.pendingBytes,
+        pendingFrames: this.pendingFrames,
+        rejectedBytes: byteLength
+      })
+
+      this.onOverflow(error)
+      return Promise.reject(error)
+    }
+
+    this.pendingFrames += 1
+    this.pendingBytes += byteLength
+    return this._enqueue({byteLength, countedFrame: true, delivery})
+  }
+
+  /**
+   * Enqueues an ordering-only operation that retains no complete output frame.
+   * @param {() => Promise<void>} delivery - Delivery operation.
+   * @returns {Promise<void>} - Settles after delivery or teardown.
+   */
+  enqueueControl(delivery) {
+    if (this.destroyed) return Promise.resolve()
+
+    return this._enqueue({byteLength: 0, countedFrame: false, delivery})
+  }
+
+  /**
+   * Releases queued and active accounting during explicit client teardown.
+   * @returns {void}
+   */
+  destroy() {
+    if (this.destroyed) return
+
+    this.destroyed = true
+    const tasks = this.activeTask ? [this.activeTask, ...this.tasks] : this.tasks
+
+    this.activeTask = undefined
+    this.tasks = []
+    this.pendingBytes = 0
+    this.pendingFrames = 0
+
+    for (const task of tasks) task.settle()
+  }
+
+  /**
+   * Gets current retained-buffer accounting.
+   * @returns {{pendingBytes: number, pendingFrames: number}} - Current retained-buffer accounting.
+   */
+  snapshot() {
+    return {pendingBytes: this.pendingBytes, pendingFrames: this.pendingFrames}
+  }
+
+  /**
+   * Enqueues a delivery task.
+   * @param {Omit<DeliveryTask, "settle">} task - Task to enqueue.
+   * @returns {Promise<void>} - Task completion.
+   */
+  _enqueue(task) {
+    const promise = new Promise((resolve, reject) => {
+      this.tasks.push({
+        ...task,
+        settle: (error) => error ? reject(error) : resolve(undefined)
+      })
+    })
+
+    this._drain()
+    return promise
+  }
+
+  /**
+   * Starts the next task when idle.
+   * @returns {void} - No return value.
+   */
+  _drain() {
+    if (this.destroyed || this.activeTask) return
+
+    const task = this.tasks.shift()
+    if (!task) return
+
+    this.activeTask = task
+    void task.delivery().then(
+      () => this._finish(task),
+      (error) => this._finish(task, error)
+    )
+  }
+
+  /**
+   * Finishes the active delivery task.
+   * @param {DeliveryTask} task - Completed task.
+   * @param {Error} [error] - Delivery error.
+   * @returns {void}
+   */
+  _finish(task, error) {
+    if (this.destroyed || this.activeTask !== task) return
+
+    this.activeTask = undefined
+    if (task.countedFrame) {
+      this.pendingBytes -= task.byteLength
+      this.pendingFrames -= 1
+    }
+    task.settle(error)
+    this._drain()
+  }
+}

package/build/http-server/server-client.js

@@ -76,6 +76,15 @@ export default class ServerClient {
     })
   }
 
+  /**
+   * Immediately destroys the socket and all transport-owned write buffers.
+   * @param {Error} error - Destruction reason.
+   * @returns {void}
+   */
+  destroy(error) {
+    if (!this.socket.destroyed) this.socket.destroy(error)
+  }
+
   /**
    * On socket data.
    * @param {Buffer} chunk - Chunk.

package/build/http-server/websocket-event-log-store.js

@@ -4,11 +4,6 @@ import {randomUUID} from "crypto"
 import TableData from "../database/table-data/index.js"
 import Logger from "../logger.js"
 
-const EVENTS_TABLE = "websocket_channel_events"
-const REPLAY_CHANNELS_TABLE = "websocket_replay_channels"
-const DEFAULT_RETENTION_MS = 10 * 60 * 1000
-const stores = new WeakMap()
-
 /**
  * WebsocketEventRow type.
  * @typedef {object} WebsocketEventRow
@@ -18,12 +13,15 @@ const stores = new WeakMap()
  * @property {string} payload_json - Serialized payload.
  * @property {number | string} sequence - Sequence number.
  */
-
 /**
  * WebsocketReplayChannelRow type.
  * @typedef {object} WebsocketReplayChannelRow
  * @property {string} channel - Channel name.
  */
+const EVENTS_TABLE = "websocket_channel_events"
+const REPLAY_CHANNELS_TABLE = "websocket_replay_channels"
+const DEFAULT_RETENTION_MS = 10 * 60 * 1000
+const stores = new WeakMap()
 
 /**
  * Runs the websocketEventLogStoreForConfiguration helper.

package/build/http-server/websocket-events-host.js

@@ -8,6 +8,10 @@ export class VelociousHttpServerWebsocketEventsHost {
      * Narrows the runtime value to the documented type.
      * @type {Set<import("./worker-handler/index.js").default>} */
     this.handlers = new Set()
+    /**
+     * Broadcast handlers grouped by the configuration that owns them.
+     * @type {Map<import("../configuration.js").default, Set<import("./worker-handler/index.js").default>>} */
+    this.broadcastHandlersByConfiguration = new Map()
     this.publishQueue = Promise.resolve()
   }
 
@@ -30,8 +34,23 @@ export class VelociousHttpServerWebsocketEventsHost {
    */
   register(handler) {
     this.handlers.add(handler)
+    let configurationHandlers = this.broadcastHandlersByConfiguration.get(handler.configuration)
+
+    if (!configurationHandlers) {
+      configurationHandlers = new Set()
+      this.broadcastHandlersByConfiguration.set(handler.configuration, configurationHandlers)
+    }
+
+    configurationHandlers.add(handler)
+
+    return () => {
+      this.handlers.delete(handler)
+      configurationHandlers.delete(handler)
 
-    return () => this.handlers.delete(handler)
+      if (configurationHandlers.size === 0) {
+        this.broadcastHandlersByConfiguration.delete(handler.configuration)
+      }
+    }
   }
 
   /**
@@ -69,17 +88,24 @@ export class VelociousHttpServerWebsocketEventsHost {
    * @param {string} args.channel - Channel name.
    * @param {Record<string, ?>} args.broadcastParams - Routing filter params.
    * @param {?} args.body - Message body.
+   * @param {import("../configuration.js").default} args.configuration - Originating configuration.
    * @returns {void}
    */
-  broadcastV2({body, broadcastParams, channel}) {
+  broadcastV2({body, broadcastParams, channel, configuration}) {
     // Chain onto publishQueue so persistence completes before
     // the next broadcast — without this, a subscriber that connects
     // immediately after a broadcast could miss the just-persisted
     // event when replaying from lastEventId on a slow DB.
     this._queuePublish(async () => {
-      const persistedEvent = await this._persistV2EventIfNeeded({body, channel})
+      const persistedEvent = await this._persistV2EventIfNeeded({body, channel, configuration})
+      const dispatchedTargets = new Set()
 
-      for (const handler of this.handlers) {
+      for (const handler of this.broadcastHandlersByConfiguration.get(configuration) || []) {
+        const dispatchKey = handler.websocketV2BroadcastDispatchKey()
+
+        if (dispatchedTargets.has(dispatchKey)) continue
+
+        dispatchedTargets.add(dispatchKey)
         handler.dispatchWebsocketV2Broadcast({
           body,
           broadcastParams,
@@ -88,18 +114,19 @@ export class VelociousHttpServerWebsocketEventsHost {
           createdAt: persistedEvent?.createdAt
         })
       }
-    }, "Failed to persist/broadcast V2 event")
+    }, "Failed to persist/broadcast V2 event", configuration)
   }
 
   /**
    * Runs queue publish.
    * @param {() => Promise<void>} callback - Publish work to run in order.
    * @param {string} errorMessage - Message logged when publish work fails.
+   * @param {import("../configuration.js").default} [originatingConfiguration] - Configuration whose context owns the work.
    * @returns {void}
    */
-  _queuePublish(callback, errorMessage) {
+  _queuePublish(callback, errorMessage, originatingConfiguration) {
     const handler = this.handlers.values().next().value
-    const configuration = handler?.configuration
+    const configuration = originatingConfiguration || handler?.configuration
 
     this.publishQueue = this.publishQueue
       .then(async () => {
@@ -120,10 +147,11 @@ export class VelociousHttpServerWebsocketEventsHost {
    * @param {object} args - Options.
    * @param {?} args.body - Event body.
    * @param {string} args.channel - Channel name.
+   * @param {import("../configuration.js").default} args.configuration - Originating configuration.
    * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata when storage is enabled.
    */
-  async _persistV2EventIfNeeded({body, channel}) {
-    return await this._persistChannelEventIfNeeded({channel, payload: body})
+  async _persistV2EventIfNeeded({body, channel, configuration}) {
+    return await this._persistChannelEventIfNeeded({channel, payload: body, configuration})
   }
 
   /**
@@ -142,14 +170,16 @@ export class VelociousHttpServerWebsocketEventsHost {
    * @param {object} args - Options object.
    * @param {string} args.channel - Channel name.
    * @param {?} args.payload - Payload data.
+   * @param {import("../configuration.js").default} [args.configuration] - Configuration owning the event store.
    * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata.
    */
-  async _persistChannelEventIfNeeded({channel, payload}) {
+  async _persistChannelEventIfNeeded({channel, payload, configuration}) {
     const handler = this.handlers.values().next().value
+    const eventConfiguration = configuration || handler?.configuration
 
-    if (!handler?.configuration) return null
+    if (!eventConfiguration) return null
 
-    const websocketEventLogStore = websocketEventLogStoreForConfiguration(handler.configuration)
+    const websocketEventLogStore = websocketEventLogStoreForConfiguration(eventConfiguration)
     const shouldPersist = await websocketEventLogStore.shouldPersistChannel(channel)
 
     if (!shouldPersist) return null

package/build/http-server/worker-handler/in-process.js

@@ -1,6 +1,7 @@
 // @ts-check
 
 import Client from "../client/index.js"
+import ClientDeliveryQueue from "../client-delivery-queue.js"
 import dispatchChannelSubscribers from "./channel-subscriber-dispatch.js"
 import Logger from "../../logger.js"
 import websocketEventsHost from "../websocket-events-host.js"
@@ -23,7 +24,7 @@ export default class VelociousHttpServerInProcessHandler {
 
     /**
      * Narrows the runtime value to the documented type.
-     * @type {Record<number, {httpClient: Client, serverClient: import("../server-client.js").default}>} */
+     * @type {Record<number, {deliveryQueue: ClientDeliveryQueue, httpClient: Client, serverClient: import("../server-client.js").default}>} */
     this.clients = {}
 
     /** @type {Set<Promise<void>>} */
@@ -56,25 +57,36 @@ export default class VelociousHttpServerInProcessHandler {
       remoteAddress: serverClient.remoteAddress
     })
 
-    let deliveryQueue = Promise.resolve()
-    const enqueueDelivery = (/** @type {() => Promise<void>} */ delivery) => {
-      deliveryQueue = deliveryQueue
-        .catch(() => {})
-        .then(delivery)
-
-      return deliveryQueue
-    }
+    const {maxBytes, maxFrames} = this.configuration.getWebsocketOutboundQueueLimits()
+    const deliveryQueue = new ClientDeliveryQueue({
+      clientCount,
+      maxBytes,
+      maxFrames,
+      onOverflow: (error) => {
+        deliveryQueue.destroy()
+        serverClient.destroy(error)
+        this._reportOutboundQueueOverflow({clientCount, error})
+      }
+    })
 
-    httpClient.events.on("output", (output) => {
+    httpClient.events.on("output", (output, {websocketFrame = false} = {}) => {
       if (output !== null && output !== undefined) {
-        void enqueueDelivery(() => serverClient.send(output)).catch((error) => {
+        const delivery = () => serverClient.send(output)
+        const queued = websocketFrame
+          ? deliveryQueue.enqueueFrame({
+            byteLength: typeof output === "string" ? Buffer.byteLength(output) : output.byteLength,
+            delivery
+          })
+          : deliveryQueue.enqueueControl(delivery)
+
+        void queued.catch((error) => {
           this.logger.error(() => ["Failed to deliver client output", {clientCount}, error])
         })
       }
     })
 
     httpClient.events.on("file", ({filePath, sendBody, settle}) => {
-      void enqueueDelivery(async () => {
+      void deliveryQueue.enqueueControl(async () => {
         await settle(await serverClient.sendFile(filePath, sendBody))
       }).catch((error) => {
         this.logger.error(() => ["Failed to deliver file response", {clientCount, filePath}, error])
@@ -83,11 +95,12 @@ export default class VelociousHttpServerInProcessHandler {
     })
 
     httpClient.events.on("close", () => {
-      void enqueueDelivery(() => serverClient.end())
+      void deliveryQueue.enqueueControl(() => serverClient.end())
         .finally(() => delete this.clients[clientCount])
     })
 
     serverClient.events.on("close", () => {
+      deliveryQueue.destroy()
       const cleanup = httpClient.abortPendingFileResponses()
         .catch((error) => {
           this.logger.warn("Failed to abort file responses after client close", error)
@@ -100,7 +113,7 @@ export default class VelociousHttpServerInProcessHandler {
       this.pendingClientCloseCleanups.add(cleanup)
     })
 
-    this.clients[clientCount] = {httpClient, serverClient}
+    this.clients[clientCount] = {deliveryQueue, httpClient, serverClient}
 
     // Create a message-port shim so ServerClient.onSocketData can route data
     // to the in-process HTTP Client without needing a real worker thread.
@@ -118,6 +131,24 @@ export default class VelociousHttpServerInProcessHandler {
     serverClient.listen()
   }
 
+  /**
+   * Reports a per-client outbound queue overflow.
+   * @param {object} args - Overflow details.
+   * @param {number} args.clientCount - Affected client.
+   * @param {Error} args.error - Overflow error.
+   * @returns {void}
+   */
+  _reportOutboundQueueOverflow({clientCount, error}) {
+    const errorPayload = {
+      context: {clientCount, websocketOutboundQueueOverflow: true, workerCount: this.workerCount},
+      error
+    }
+    const errorEvents = this.configuration.getErrorEvents()
+
+    errorEvents.emit("framework-error", errorPayload)
+    errorEvents.emit("all-error", {...errorPayload, errorType: "framework-error"})
+  }
+
   /**
    * Runs stop.
    * @returns {Promise<void>} */
@@ -158,6 +189,14 @@ export default class VelociousHttpServerInProcessHandler {
     return this.configuration._broadcastToChannelLocal(channel, broadcastParams, body, {eventId})
   }
 
+  /**
+   * Gets the configuration-wide V2 broadcast target shared by in-process handlers.
+   * @returns {import("../../configuration.js").default} - Shared configuration target.
+   */
+  websocketV2BroadcastDispatchKey() {
+    return this.configuration
+  }
+
   /**
    * Runs dispatch websocket event.
    * @param {object} args - Options object.

package/build/http-server/worker-handler/index.js

@@ -2,6 +2,7 @@
 
 import {ensureError} from "typanic"
 import Logger from "../../logger.js"
+import ClientDeliveryQueue from "../client-delivery-queue.js"
 import {Worker} from "worker_threads"
 import websocketEventsHost from "../websocket-events-host.js"
 
@@ -59,7 +60,7 @@ export default class VelociousHttpServerWorker {
      * @type {Map<number, {resolve: (snapshot: Record<string, ?>) => void}>} */
     this._debugSnapshotRequests = new Map()
 
-    /** @type {Map<number, Promise<void>>} */
+    /** @type {Map<number, ClientDeliveryQueue>} */
     this._clientDeliveryQueues = new Map()
   }
 
@@ -117,6 +118,7 @@ export default class VelociousHttpServerWorker {
     if (!this.clients[clientCount] && !this._clientDeliveryQueues.has(clientCount)) return
 
     delete this.clients[clientCount]
+    this._clientDeliveryQueues.get(clientCount)?.destroy()
     this._clientDeliveryQueues.delete(clientCount)
     this.worker?.postMessage({command: "clientAbort", clientCount})
   }
@@ -163,6 +165,10 @@ export default class VelociousHttpServerWorker {
   _closeAllClients() {
     const clients = Object.values(this.clients)
     this.clients = {}
+    const deliveryQueues = this._clientDeliveryQueues
+    this._clientDeliveryQueues = new Map()
+
+    for (const queue of deliveryQueues.values()) queue.destroy()
 
     for (const client of clients) {
       try {
@@ -182,6 +188,7 @@ export default class VelociousHttpServerWorker {
    * @param {string} [data.filePath] - File path.
    * @param {boolean} [data.sendBody] - Whether to send the file body.
    * @param {number} [data.transferId] - File transfer id.
+   * @param {boolean} [data.websocketFrame] - Whether output is a completed WebSocket frame.
    * @param {string} [data.channel] - Channel name.
    * @param {number} [data.requestId] - Debug request id.
    * @param {Record<string, ?>} [data.snapshot] - Worker debug snapshot.
@@ -219,7 +226,11 @@ export default class VelociousHttpServerWorker {
       if (output !== null && output !== undefined) {
         const outputLength = typeof output === "string" ? output.length : output.byteLength
 
-        void this.enqueueClientDelivery(client.clientCount, () => client.send(output)).then(() => {
+        const delivery = data.websocketFrame === true
+          ? this.enqueueClientFrame(client, output)
+          : this.enqueueClientControl(client, () => client.send(output))
+
+        void delivery.then(() => {
           this.logger.debug(() => ["Client output delivered", {
             clientCount,
             outputLength,
@@ -243,7 +254,7 @@ export default class VelociousHttpServerWorker {
         return
       }
 
-      void this.enqueueClientDelivery(client.clientCount, async () => {
+      void this.enqueueClientControl(client, async () => {
         const result = await client.sendFile(filePath, sendBody !== false)
 
         this.worker?.postMessage({command: "clientFileResult", result, transferId})
@@ -260,7 +271,7 @@ export default class VelociousHttpServerWorker {
         return
       }
 
-      void this.enqueueClientDelivery(client.clientCount, () => client.end())
+      void this.enqueueClientControl(client, () => client.end())
         .finally(() => delete this.clients[client.clientCount])
     } else if (command == "debugSnapshot") {
       const {requestId, snapshot} = data
@@ -289,7 +300,12 @@ export default class VelociousHttpServerWorker {
         throw new Error("Worker websocket v2-broadcast channel must be a string")
       }
 
-      websocketEventsHost.broadcastV2({body, broadcastParams: broadcastParams || {}, channel})
+      websocketEventsHost.broadcastV2({
+        body,
+        broadcastParams: broadcastParams || {},
+        channel,
+        configuration: this.configuration
+      })
     } else {
       throw new Error(`Unknown command: ${command}`)
     }
@@ -297,24 +313,70 @@ export default class VelociousHttpServerWorker {
 
   /**
    * Preserves socket output ordering for one client.
-   * @param {number} clientCount - Client count.
+   * @param {import("../server-client.js").default} client - Client instance.
+   * @param {string | Uint8Array} output - Complete output buffer.
+   * @returns {Promise<void>} - Queued delivery.
+   */
+  enqueueClientFrame(client, output) {
+    const byteLength = typeof output === "string" ? Buffer.byteLength(output) : output.byteLength
+
+    return this._deliveryQueueFor(client).enqueueFrame({
+      byteLength,
+      delivery: () => client.send(output)
+    })
+  }
+
+  /**
+   * Preserves ordering for a delivery that retains no complete output frame.
+   * @param {import("../server-client.js").default} client - Client instance.
    * @param {() => Promise<void>} delivery - Delivery operation.
    * @returns {Promise<void>} - Queued delivery.
    */
-  enqueueClientDelivery(clientCount, delivery) {
-    const previous = this._clientDeliveryQueues.get(clientCount) || Promise.resolve()
-    const queued = previous
-      .catch(() => {})
-      .then(delivery)
-
-    this._clientDeliveryQueues.set(clientCount, queued)
-    const clearQueue = () => {
-      if (this._clientDeliveryQueues.get(clientCount) === queued) this._clientDeliveryQueues.delete(clientCount)
-    }
+  enqueueClientControl(client, delivery) {
+    return this._deliveryQueueFor(client).enqueueControl(delivery)
+  }
 
-    void queued.then(clearQueue, clearQueue)
+  /**
+   * Gets or creates one client's delivery queue.
+   * @param {import("../server-client.js").default} client - Client instance.
+   * @returns {ClientDeliveryQueue} - Client-owned delivery queue.
+   */
+  _deliveryQueueFor(client) {
+    const existing = this._clientDeliveryQueues.get(client.clientCount)
+    if (existing) return existing
+
+    const {maxBytes, maxFrames} = this.configuration.getWebsocketOutboundQueueLimits()
+    const queue = new ClientDeliveryQueue({
+      clientCount: client.clientCount,
+      maxBytes,
+      maxFrames,
+      onOverflow: (error) => {
+        queue.destroy()
+        client.destroy(error)
+        this._reportOutboundQueueOverflow({clientCount: client.clientCount, error})
+      }
+    })
+
+    this._clientDeliveryQueues.set(client.clientCount, queue)
+    return queue
+  }
+
+  /**
+   * Reports a per-client outbound queue overflow.
+   * @param {object} args - Overflow details.
+   * @param {number} args.clientCount - Affected client.
+   * @param {Error} args.error - Overflow error.
+   * @returns {void}
+   */
+  _reportOutboundQueueOverflow({clientCount, error}) {
+    const errorPayload = {
+      context: {clientCount, websocketOutboundQueueOverflow: true, workerCount: this.workerCount},
+      error
+    }
+    const errorEvents = this.configuration.getErrorEvents()
 
-    return queued
+    errorEvents.emit("framework-error", errorPayload)
+    errorEvents.emit("all-error", {...errorPayload, errorType: "framework-error"})
   }
 
   /**
@@ -410,6 +472,14 @@ export default class VelociousHttpServerWorker {
     this.worker.postMessage({body, broadcastParams, channel, command: "websocketV2Broadcast", eventId, createdAt})
   }
 
+  /**
+   * Gets this worker's isolated V2 broadcast target.
+   * @returns {VelociousHttpServerWorker} - This worker handler.
+   */
+  websocketV2BroadcastDispatchKey() {
+    return this
+  }
+
   /**
    * Runs register with events host.
    * @returns {void} */

package/build/http-server/worker-handler/worker-thread.js

@@ -154,8 +154,8 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
       remoteAddress
     })
 
-    client.events.on("output", (output) => {
-      this.parentPort.postMessage({command: "clientOutput", clientCount, output})
+    client.events.on("output", (output, {websocketFrame = false} = {}) => {
+      this.parentPort.postMessage({command: "clientOutput", clientCount, output, websocketFrame})
     })
 
     client.events.on("file", ({filePath, sendBody, settle}) => {

package/build/plugins/sqljs-wasm-route.js

@@ -2,23 +2,21 @@ import {createRequire} from "node:module"
 import path from "node:path"
 import SqlJsWasmRouteController from "./sqljs-wasm-route-controller.js"
 
-const require = createRequire(import.meta.url)
-const sqlJsEntryPath = require.resolve("sql.js")
-const sqlJsDistDirectory = path.dirname(sqlJsEntryPath)
-
 /**
  * InstallSqlJsWasmRouteArgs type.
  * @typedef {object} InstallSqlJsWasmRouteArgs
  * @property {import("../configuration.js").default} configuration - Velocious configuration instance.
  * @property {string} [routePrefix] - Route prefix used for sql.js asset serving.
  */
-
 /**
  * SqlJsLocateFileFromBackendArgs type.
  * @typedef {object} SqlJsLocateFileFromBackendArgs
  * @property {string} backendBaseUrl - Backend base URL (for example `https://api.example.com`).
  * @property {string} [routePrefix] - Route prefix used for sql.js asset serving.
  */
+const require = createRequire(import.meta.url)
+const sqlJsEntryPath = require.resolve("sql.js")
+const sqlJsDistDirectory = path.dirname(sqlJsEntryPath)
 
 /**
  * Runs normalize route prefix.