velocious 1.0.562 → 1.0.563

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

@@ -6,6 +6,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();
     }
     /**
@@ -26,7 +30,19 @@ export class VelociousHttpServerWebsocketEventsHost {
      */
     register(handler) {
         this.handlers.add(handler);
-        return () => this.handlers.delete(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);
+            if (configurationHandlers.size === 0) {
+                this.broadcastHandlersByConfiguration.delete(handler.configuration);
+            }
+        };
     }
     /**
      * Runs publish.
@@ -60,16 +76,22 @@ 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 });
-            for (const handler of this.handlers) {
+            const persistedEvent = await this._persistV2EventIfNeeded({ body, channel, configuration });
+            const dispatchedTargets = new Set();
+            for (const handler of this.broadcastHandlersByConfiguration.get(configuration) || []) {
+                const dispatchKey = handler.websocketV2BroadcastDispatchKey();
+                if (dispatchedTargets.has(dispatchKey))
+                    continue;
+                dispatchedTargets.add(dispatchKey);
                 handler.dispatchWebsocketV2Broadcast({
                     body,
                     broadcastParams,
@@ -78,17 +100,18 @@ 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 () => {
             if (configuration) {
@@ -106,10 +129,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 });
     }
     /**
      * Runs persist event if needed.
@@ -126,13 +150,15 @@ 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;
-        if (!handler?.configuration)
+        const eventConfiguration = configuration || handler?.configuration;
+        if (!eventConfiguration)
             return null;
-        const websocketEventLogStore = websocketEventLogStoreForConfiguration(handler.configuration);
+        const websocketEventLogStore = websocketEventLogStoreForConfiguration(eventConfiguration);
         const shouldPersist = await websocketEventLogStore.shouldPersistChannel(channel);
         if (!shouldPersist)
             return null;
@@ -145,4 +171,4 @@ export class VelociousHttpServerWebsocketEventsHost {
 }
 const websocketEventsHost = new VelociousHttpServerWebsocketEventsHost();
 export default websocketEventsHost;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-events-host.js","sourceRoot":"","sources":["../../../src/http-server/websocket-events-host.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {websocketEventLogStoreForConfiguration} from \"./websocket-event-log-store.js\"\n\nexport class VelociousHttpServerWebsocketEventsHost {\n  constructor() {\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {Set<import(\"./worker-handler/index.js\").default>} */\n    this.handlers = new Set()\n    this.publishQueue = Promise.resolve()\n  }\n\n  /**\n   * Returns a promise that resolves when all pending publish/broadcast\n   * operations have completed (including event-log persistence). Useful\n   * when a request handler needs to guarantee its broadcast is persisted\n   * before responding — without this, the HTTP response can return before\n   * the async event-log write finishes.\n   * @returns {Promise<void>}\n   */\n  async awaitPendingBroadcasts() {\n    await this.publishQueue\n  }\n\n  /**\n   * Runs register.\n   * @param {import(\"./worker-handler/index.js\").default} handler - Handler instance.\n   * @returns {() => void} - The register.\n   */\n  register(handler) {\n    this.handlers.add(handler)\n\n    return () => this.handlers.delete(handler)\n  }\n\n  /**\n   * Runs publish.\n   * @param {object | string} channelOrArgs - Channel name or options object.\n   * @param {?} [payloadArg] - Payload data when channel is passed separately.\n   * @returns {void} - No return value.\n   */\n  publish(channelOrArgs, payloadArg) {\n    const publishArgs = typeof channelOrArgs === \"string\"\n      ? {channel: channelOrArgs, payload: payloadArg}\n      : /** @type {{channel: string, payload: ?}} */ (channelOrArgs)\n    const channel = publishArgs.channel\n    const payload = publishArgs.payload\n\n    this._queuePublish(async () => {\n      const persistedEvent = await this._persistEventIfNeeded({channel, payload})\n\n      for (const handler of this.handlers) {\n        handler.dispatchWebsocketEvent({\n          channel,\n          createdAt: persistedEvent?.createdAt,\n          eventId: persistedEvent?.id,\n          payload\n        })\n      }\n    }, \"Failed to publish websocket event\")\n  }\n\n  /**\n   * Fan a V2 channel broadcast out to every registered worker handler.\n   * Persists the event to the event-log store (if the channel is marked\n   * interested) so clients can resume from a `lastEventId` checkpoint.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {Record<string, ?>} args.broadcastParams - Routing filter params.\n   * @param {?} args.body - Message body.\n   * @returns {void}\n   */\n  broadcastV2({body, broadcastParams, channel}) {\n    // Chain onto publishQueue so persistence completes before\n    // the next broadcast — without this, a subscriber that connects\n    // immediately after a broadcast could miss the just-persisted\n    // event when replaying from lastEventId on a slow DB.\n    this._queuePublish(async () => {\n      const persistedEvent = await this._persistV2EventIfNeeded({body, channel})\n\n      for (const handler of this.handlers) {\n        handler.dispatchWebsocketV2Broadcast({\n          body,\n          broadcastParams,\n          channel,\n          eventId: persistedEvent?.id,\n          createdAt: persistedEvent?.createdAt\n        })\n      }\n    }, \"Failed to persist/broadcast V2 event\")\n  }\n\n  /**\n   * Runs queue publish.\n   * @param {() => Promise<void>} callback - Publish work to run in order.\n   * @param {string} errorMessage - Message logged when publish work fails.\n   * @returns {void}\n   */\n  _queuePublish(callback, errorMessage) {\n    const handler = this.handlers.values().next().value\n    const configuration = handler?.configuration\n\n    this.publishQueue = this.publishQueue\n      .then(async () => {\n        if (configuration) {\n          return await configuration.withoutCurrentConnectionContexts(callback)\n        }\n\n        return await callback()\n      })\n      .catch((error) => {\n        console.error(errorMessage, error)\n        throw error\n      })\n  }\n\n  /**\n   * Runs persist v2 event if needed.\n   * @param {object} args - Options.\n   * @param {?} args.body - Event body.\n   * @param {string} args.channel - Channel name.\n   * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata when storage is enabled.\n   */\n  async _persistV2EventIfNeeded({body, channel}) {\n    return await this._persistChannelEventIfNeeded({channel, payload: body})\n  }\n\n  /**\n   * Runs persist event if needed.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {?} args.payload - Payload data.\n   * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata.\n   */\n  async _persistEventIfNeeded({channel, payload}) {\n    return await this._persistChannelEventIfNeeded({channel, payload})\n  }\n\n  /**\n   * Runs persist channel event if needed.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {?} args.payload - Payload data.\n   * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata.\n   */\n  async _persistChannelEventIfNeeded({channel, payload}) {\n    const handler = this.handlers.values().next().value\n\n    if (!handler?.configuration) return null\n\n    const websocketEventLogStore = websocketEventLogStoreForConfiguration(handler.configuration)\n    const shouldPersist = await websocketEventLogStore.shouldPersistChannel(channel)\n\n    if (!shouldPersist) return null\n\n    const persistedEvent = await websocketEventLogStore.appendEvent({channel, payload})\n\n    return {\n      createdAt: persistedEvent.createdAt,\n      id: persistedEvent.id\n    }\n  }\n}\n\nconst websocketEventsHost = new VelociousHttpServerWebsocketEventsHost()\n\nexport default websocketEventsHost\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-events-host.js","sourceRoot":"","sources":["../../../src/http-server/websocket-events-host.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {websocketEventLogStoreForConfiguration} from \"./websocket-event-log-store.js\"\n\nexport class VelociousHttpServerWebsocketEventsHost {\n  constructor() {\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {Set<import(\"./worker-handler/index.js\").default>} */\n    this.handlers = new Set()\n    /**\n     * Broadcast handlers grouped by the configuration that owns them.\n     * @type {Map<import(\"../configuration.js\").default, Set<import(\"./worker-handler/index.js\").default>>} */\n    this.broadcastHandlersByConfiguration = new Map()\n    this.publishQueue = Promise.resolve()\n  }\n\n  /**\n   * Returns a promise that resolves when all pending publish/broadcast\n   * operations have completed (including event-log persistence). Useful\n   * when a request handler needs to guarantee its broadcast is persisted\n   * before responding — without this, the HTTP response can return before\n   * the async event-log write finishes.\n   * @returns {Promise<void>}\n   */\n  async awaitPendingBroadcasts() {\n    await this.publishQueue\n  }\n\n  /**\n   * Runs register.\n   * @param {import(\"./worker-handler/index.js\").default} handler - Handler instance.\n   * @returns {() => void} - The register.\n   */\n  register(handler) {\n    this.handlers.add(handler)\n    let configurationHandlers = this.broadcastHandlersByConfiguration.get(handler.configuration)\n\n    if (!configurationHandlers) {\n      configurationHandlers = new Set()\n      this.broadcastHandlersByConfiguration.set(handler.configuration, configurationHandlers)\n    }\n\n    configurationHandlers.add(handler)\n\n    return () => {\n      this.handlers.delete(handler)\n      configurationHandlers.delete(handler)\n\n      if (configurationHandlers.size === 0) {\n        this.broadcastHandlersByConfiguration.delete(handler.configuration)\n      }\n    }\n  }\n\n  /**\n   * Runs publish.\n   * @param {object | string} channelOrArgs - Channel name or options object.\n   * @param {?} [payloadArg] - Payload data when channel is passed separately.\n   * @returns {void} - No return value.\n   */\n  publish(channelOrArgs, payloadArg) {\n    const publishArgs = typeof channelOrArgs === \"string\"\n      ? {channel: channelOrArgs, payload: payloadArg}\n      : /** @type {{channel: string, payload: ?}} */ (channelOrArgs)\n    const channel = publishArgs.channel\n    const payload = publishArgs.payload\n\n    this._queuePublish(async () => {\n      const persistedEvent = await this._persistEventIfNeeded({channel, payload})\n\n      for (const handler of this.handlers) {\n        handler.dispatchWebsocketEvent({\n          channel,\n          createdAt: persistedEvent?.createdAt,\n          eventId: persistedEvent?.id,\n          payload\n        })\n      }\n    }, \"Failed to publish websocket event\")\n  }\n\n  /**\n   * Fan a V2 channel broadcast out to every registered worker handler.\n   * Persists the event to the event-log store (if the channel is marked\n   * interested) so clients can resume from a `lastEventId` checkpoint.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {Record<string, ?>} args.broadcastParams - Routing filter params.\n   * @param {?} args.body - Message body.\n   * @param {import(\"../configuration.js\").default} args.configuration - Originating configuration.\n   * @returns {void}\n   */\n  broadcastV2({body, broadcastParams, channel, configuration}) {\n    // Chain onto publishQueue so persistence completes before\n    // the next broadcast — without this, a subscriber that connects\n    // immediately after a broadcast could miss the just-persisted\n    // event when replaying from lastEventId on a slow DB.\n    this._queuePublish(async () => {\n      const persistedEvent = await this._persistV2EventIfNeeded({body, channel, configuration})\n      const dispatchedTargets = new Set()\n\n      for (const handler of this.broadcastHandlersByConfiguration.get(configuration) || []) {\n        const dispatchKey = handler.websocketV2BroadcastDispatchKey()\n\n        if (dispatchedTargets.has(dispatchKey)) continue\n\n        dispatchedTargets.add(dispatchKey)\n        handler.dispatchWebsocketV2Broadcast({\n          body,\n          broadcastParams,\n          channel,\n          eventId: persistedEvent?.id,\n          createdAt: persistedEvent?.createdAt\n        })\n      }\n    }, \"Failed to persist/broadcast V2 event\", configuration)\n  }\n\n  /**\n   * Runs queue publish.\n   * @param {() => Promise<void>} callback - Publish work to run in order.\n   * @param {string} errorMessage - Message logged when publish work fails.\n   * @param {import(\"../configuration.js\").default} [originatingConfiguration] - Configuration whose context owns the work.\n   * @returns {void}\n   */\n  _queuePublish(callback, errorMessage, originatingConfiguration) {\n    const handler = this.handlers.values().next().value\n    const configuration = originatingConfiguration || handler?.configuration\n\n    this.publishQueue = this.publishQueue\n      .then(async () => {\n        if (configuration) {\n          return await configuration.withoutCurrentConnectionContexts(callback)\n        }\n\n        return await callback()\n      })\n      .catch((error) => {\n        console.error(errorMessage, error)\n        throw error\n      })\n  }\n\n  /**\n   * Runs persist v2 event if needed.\n   * @param {object} args - Options.\n   * @param {?} args.body - Event body.\n   * @param {string} args.channel - Channel name.\n   * @param {import(\"../configuration.js\").default} args.configuration - Originating configuration.\n   * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata when storage is enabled.\n   */\n  async _persistV2EventIfNeeded({body, channel, configuration}) {\n    return await this._persistChannelEventIfNeeded({channel, payload: body, configuration})\n  }\n\n  /**\n   * Runs persist event if needed.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {?} args.payload - Payload data.\n   * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata.\n   */\n  async _persistEventIfNeeded({channel, payload}) {\n    return await this._persistChannelEventIfNeeded({channel, payload})\n  }\n\n  /**\n   * Runs persist channel event if needed.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {?} args.payload - Payload data.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration owning the event store.\n   * @returns {Promise<{createdAt: string, id: string} | null>} - Persisted event metadata.\n   */\n  async _persistChannelEventIfNeeded({channel, payload, configuration}) {\n    const handler = this.handlers.values().next().value\n    const eventConfiguration = configuration || handler?.configuration\n\n    if (!eventConfiguration) return null\n\n    const websocketEventLogStore = websocketEventLogStoreForConfiguration(eventConfiguration)\n    const shouldPersist = await websocketEventLogStore.shouldPersistChannel(channel)\n\n    if (!shouldPersist) return null\n\n    const persistedEvent = await websocketEventLogStore.appendEvent({channel, payload})\n\n    return {\n      createdAt: persistedEvent.createdAt,\n      id: persistedEvent.id\n    }\n  }\n}\n\nconst websocketEventsHost = new VelociousHttpServerWebsocketEventsHost()\n\nexport default websocketEventsHost\n"]}

package/build/src/http-server/worker-handler/in-process.d.ts

@@ -18,8 +18,9 @@ export default class VelociousHttpServerInProcessHandler {
     configuration: import("../../configuration.js").default;
     /**
      * 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}>} */
     clients: Record<number, {
+        deliveryQueue: ClientDeliveryQueue;
         httpClient: Client;
         serverClient: import("../server-client.js").default;
     }>;
@@ -39,6 +40,17 @@ export default class VelociousHttpServerInProcessHandler {
      * @returns {void}
      */
     addSocketConnection(serverClient: import("../server-client.js").default): void;
+    /**
+     * 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 }: {
+        clientCount: number;
+        error: Error;
+    }): void;
     /**
      * Runs stop.
      * @returns {Promise<void>} */
@@ -60,6 +72,11 @@ export default class VelociousHttpServerInProcessHandler {
         body: unknown;
         eventId?: string | undefined;
     }): void;
+    /**
+     * Gets the configuration-wide V2 broadcast target shared by in-process handlers.
+     * @returns {import("../../configuration.js").default} - Shared configuration target.
+     */
+    websocketV2BroadcastDispatchKey(): import("../../configuration.js").default;
     /**
      * Runs dispatch websocket event.
      * @param {object} args - Options object.
@@ -76,6 +93,7 @@ export default class VelociousHttpServerInProcessHandler {
         payload: unknown;
     }): void;
 }
+import ClientDeliveryQueue from "../client-delivery-queue.js";
 import Client from "../client/index.js";
 import Logger from "../../logger.js";
 //# sourceMappingURL=in-process.d.ts.map

package/build/src/http-server/worker-handler/in-process.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-process.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/in-process.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH;IACE;;;;;OAKG;IACH,4CAHG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QAC3B,WAAW,EAAxB,MAAM;KAChB,EAgBA;IAdC,wDAAkC;IAElC;;2GAEuG;IACvG,SADU,MAAM,CAAC,MAAM,EAAE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,CAAC,CAClF;IAEjB,iCAAiC;IACjC,4BADW,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CACc;IAE3C,eAA8B;IAC9B,oBAA8B;IAC9B,qCAAqF;IACrF,mBAAsB;IAGxB;;kCAE8B;IAC9B,SADa,OAAO,CAAC,IAAI,CAAC,CAGzB;IAED;;;;OAIG;IACH,kCAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAuEhB;IAED;;kCAE8B;IAC9B,QADa,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED;;;;;;;;;;OAUG;IACH,0EANG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;QACa,OAAO;KAC7B,GAAU,IAAI,CAMhB;IAED;;;;;;;;OAQG;IACH,iEANG;QAAqB,OAAO,EAApB,MAAM;QACQ,SAAS;QACT,OAAO;QACb,OAAO,EAAf,OAAC;KACT,GAAU,IAAI,CAiBhB;CACF;mBAvLkB,oBAAoB;mBAEpB,iBAAiB"}
+{"version":3,"file":"in-process.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/in-process.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH;IACE;;;;;OAKG;IACH,4CAHG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QAC3B,WAAW,EAAxB,MAAM;KAChB,EAgBA;IAdC,wDAAkC;IAElC;;+IAE2I;IAC3I,SADU,MAAM,CAAC,MAAM,EAAE;QAAC,aAAa,EAAE,mBAAmB,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,CAAC,CACtH;IAEjB,iCAAiC;IACjC,4BADW,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CACc;IAE3C,eAA8B;IAC9B,oBAA8B;IAC9B,qCAAqF;IACrF,mBAAsB;IAGxB;;kCAE8B;IAC9B,SADa,OAAO,CAAC,IAAI,CAAC,CAGzB;IAED;;;;OAIG;IACH,kCAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAmFhB;IAED;;;;;;OAMG;IACH,qDAJG;QAAqB,WAAW,EAAxB,MAAM;QACM,KAAK,EAAjB,KAAK;KACb,GAAU,IAAI,CAWhB;IAED;;kCAE8B;IAC9B,QADa,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED;;;;;;;;;;OAUG;IACH,0EANG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;QACa,OAAO;KAC7B,GAAU,IAAI,CAMhB;IAED;;;OAGG;IACH,mCAFa,OAAO,wBAAwB,EAAE,OAAO,CAIpD;IAED;;;;;;;;OAQG;IACH,iEANG;QAAqB,OAAO,EAApB,MAAM;QACQ,SAAS;QACT,OAAO;QACb,OAAO,EAAf,OAAC;KACT,GAAU,IAAI,CAiBhB;CACF;gCA7N+B,6BAA6B;mBAD1C,oBAAoB;mBAGpB,iBAAiB"}

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

@@ -1,5 +1,6 @@
 // @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";
@@ -20,7 +21,7 @@ export default class VelociousHttpServerInProcessHandler {
         this.configuration = configuration;
         /**
          * 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>>} */
         this.pendingClientCloseCleanups = new Set();
@@ -47,22 +48,33 @@ export default class VelociousHttpServerInProcessHandler {
             configuration: this.configuration,
             remoteAddress: serverClient.remoteAddress
         });
-        let deliveryQueue = Promise.resolve();
-        const enqueueDelivery = (/** @type {() => Promise<void>} */ delivery) => {
-            deliveryQueue = deliveryQueue
-                .catch(() => { })
-                .then(delivery);
-            return deliveryQueue;
-        };
-        httpClient.events.on("output", (output) => {
+        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, { 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]);
@@ -70,10 +82,11 @@ 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);
@@ -84,7 +97,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.
         const messagePortShim = /** @type {import("worker_threads").Worker} */ ( /** @type {?} */({
@@ -98,6 +111,22 @@ export default class VelociousHttpServerInProcessHandler {
         serverClient.setWorker(messagePortShim);
         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>} */
@@ -133,6 +162,13 @@ export default class VelociousHttpServerInProcessHandler {
             return;
         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.
@@ -157,4 +193,4 @@ export default class VelociousHttpServerInProcessHandler {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"in-process.js","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/in-process.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Client from \"../client/index.js\"\nimport dispatchChannelSubscribers from \"./channel-subscriber-dispatch.js\"\nimport Logger from \"../../logger.js\"\nimport websocketEventsHost from \"../websocket-events-host.js\"\n\n/**\n * In-process worker handler that processes HTTP requests in the main thread\n * instead of spawning a Worker thread. This allows the test runner's database\n * connection context to be shared with HTTP request handlers, so model-created\n * records in tests are visible to HTTP endpoints.\n */\nexport default class VelociousHttpServerInProcessHandler {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {number} args.workerCount - Worker count.\n   */\n  constructor({configuration, workerCount}) {\n    this.configuration = configuration\n\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {Record<number, {httpClient: Client, serverClient: import(\"../server-client.js\").default}>} */\n    this.clients = {}\n\n    /** @type {Set<Promise<void>>} */\n    this.pendingClientCloseCleanups = new Set()\n\n    this.logger = new Logger(this)\n    this.workerCount = workerCount\n    this.unregisterFromEventsHost = websocketEventsHost.register(/** @type {?} */ (this))\n    this._stopping = false\n  }\n\n  /**\n   * Runs start.\n   * @returns {Promise<void>} */\n  async start() {\n    await this.logger.debug(() => `In-process handler ${this.workerCount} started`)\n  }\n\n  /**\n   * Runs add socket connection.\n   * @param {import(\"../server-client.js\").default} serverClient - Server client instance.\n   * @returns {void}\n   */\n  addSocketConnection(serverClient) {\n    const clientCount = serverClient.clientCount\n\n    const httpClient = new Client({\n      clientCount,\n      configuration: this.configuration,\n      remoteAddress: serverClient.remoteAddress\n    })\n\n    let deliveryQueue = Promise.resolve()\n    const enqueueDelivery = (/** @type {() => Promise<void>} */ delivery) => {\n      deliveryQueue = deliveryQueue\n        .catch(() => {})\n        .then(delivery)\n\n      return deliveryQueue\n    }\n\n    httpClient.events.on(\"output\", (output) => {\n      if (output !== null && output !== undefined) {\n        void enqueueDelivery(() => serverClient.send(output)).catch((error) => {\n          this.logger.error(() => [\"Failed to deliver client output\", {clientCount}, error])\n        })\n      }\n    })\n\n    httpClient.events.on(\"file\", ({filePath, sendBody, settle}) => {\n      void enqueueDelivery(async () => {\n        await settle(await serverClient.sendFile(filePath, sendBody))\n      }).catch((error) => {\n        this.logger.error(() => [\"Failed to deliver file response\", {clientCount, filePath}, error])\n        void settle(\"aborted\")\n      })\n    })\n\n    httpClient.events.on(\"close\", () => {\n      void enqueueDelivery(() => serverClient.end())\n        .finally(() => delete this.clients[clientCount])\n    })\n\n    serverClient.events.on(\"close\", () => {\n      const cleanup = httpClient.abortPendingFileResponses()\n        .catch((error) => {\n          this.logger.warn(\"Failed to abort file responses after client close\", error)\n        })\n        .finally(() => {\n          this.pendingClientCloseCleanups.delete(cleanup)\n          delete this.clients[clientCount]\n        })\n\n      this.pendingClientCloseCleanups.add(cleanup)\n    })\n\n    this.clients[clientCount] = {httpClient, serverClient}\n\n    // Create a message-port shim so ServerClient.onSocketData can route data\n    // to the in-process HTTP Client without needing a real worker thread.\n    const messagePortShim = /** @type {import(\"worker_threads\").Worker} */ (/** @type {?} */ ({\n      postMessage: (/** @type {{command: string, chunk?: Buffer | Uint8Array | string, clientCount?: number}} */ data) => {\n        if (data.command === \"clientWrite\" && data.chunk) {\n          const chunk = typeof data.chunk === \"string\" ? Buffer.from(data.chunk) : Buffer.from(data.chunk)\n\n          httpClient.onWrite(chunk)\n        }\n      }\n    }))\n\n    serverClient.setWorker(messagePortShim)\n    serverClient.listen()\n  }\n\n  /**\n   * Runs stop.\n   * @returns {Promise<void>} */\n  async stop() {\n    this._stopping = true\n\n    for (const {httpClient, serverClient} of Object.values(this.clients)) {\n      await Promise.all([\n        httpClient.abortPendingFileResponses().catch((error) => {\n          this.logger.warn(\"Failed to abort file responses during shutdown\", error)\n        }),\n        serverClient.end().catch((error) => {\n          this.logger.warn(\"Failed to close client during shutdown\", error)\n        })\n      ])\n    }\n\n    await Promise.all(this.pendingClientCloseCleanups)\n\n    this.clients = {}\n    this.unregisterFromEventsHost?.()\n  }\n\n  /**\n   * In-process handler path for V2 channel broadcasts. No worker\n   * boundary to cross — dispatch directly to any matching live\n   * subscriptions on the shared configuration.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {Record<string, ?>} args.broadcastParams - Routing filter params.\n   * @param {?} args.body - Message body.\n   * @param {string} [args.eventId] - Persisted event id for replay.\n   * @returns {void}\n   */\n  dispatchWebsocketV2Broadcast({body, broadcastParams, channel, eventId}) {\n    if (!this.configuration) return\n\n    return this.configuration._broadcastToChannelLocal(channel, broadcastParams, body, {eventId})\n  }\n\n  /**\n   * Runs dispatch websocket event.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {string} [args.createdAt] - Event creation time.\n   * @param {string} [args.eventId] - Event identifier.\n   * @param {?} args.payload - Payload data.\n   * @returns {void}\n   */\n  dispatchWebsocketEvent({channel, createdAt, eventId, payload}) {\n    for (const {httpClient} of Object.values(this.clients)) {\n      const session = httpClient.websocketSession\n\n      if (!session) continue\n\n      void session.sendEvent(channel, payload, {createdAt, eventId})\n    }\n\n    if (this.configuration) {\n      // Isolate subscriber failures from breaking the in-process handler,\n      // but still surface them to the framework error events so bug\n      // reporters can pick them up.\n      void dispatchChannelSubscribers({channel, configuration: this.configuration, createdAt, eventId, logger: this.logger, payload})\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"in-process.js","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/in-process.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Client from \"../client/index.js\"\nimport ClientDeliveryQueue from \"../client-delivery-queue.js\"\nimport dispatchChannelSubscribers from \"./channel-subscriber-dispatch.js\"\nimport Logger from \"../../logger.js\"\nimport websocketEventsHost from \"../websocket-events-host.js\"\n\n/**\n * In-process worker handler that processes HTTP requests in the main thread\n * instead of spawning a Worker thread. This allows the test runner's database\n * connection context to be shared with HTTP request handlers, so model-created\n * records in tests are visible to HTTP endpoints.\n */\nexport default class VelociousHttpServerInProcessHandler {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {number} args.workerCount - Worker count.\n   */\n  constructor({configuration, workerCount}) {\n    this.configuration = configuration\n\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {Record<number, {deliveryQueue: ClientDeliveryQueue, httpClient: Client, serverClient: import(\"../server-client.js\").default}>} */\n    this.clients = {}\n\n    /** @type {Set<Promise<void>>} */\n    this.pendingClientCloseCleanups = new Set()\n\n    this.logger = new Logger(this)\n    this.workerCount = workerCount\n    this.unregisterFromEventsHost = websocketEventsHost.register(/** @type {?} */ (this))\n    this._stopping = false\n  }\n\n  /**\n   * Runs start.\n   * @returns {Promise<void>} */\n  async start() {\n    await this.logger.debug(() => `In-process handler ${this.workerCount} started`)\n  }\n\n  /**\n   * Runs add socket connection.\n   * @param {import(\"../server-client.js\").default} serverClient - Server client instance.\n   * @returns {void}\n   */\n  addSocketConnection(serverClient) {\n    const clientCount = serverClient.clientCount\n\n    const httpClient = new Client({\n      clientCount,\n      configuration: this.configuration,\n      remoteAddress: serverClient.remoteAddress\n    })\n\n    const {maxBytes, maxFrames} = this.configuration.getWebsocketOutboundQueueLimits()\n    const deliveryQueue = new ClientDeliveryQueue({\n      clientCount,\n      maxBytes,\n      maxFrames,\n      onOverflow: (error) => {\n        deliveryQueue.destroy()\n        serverClient.destroy(error)\n        this._reportOutboundQueueOverflow({clientCount, error})\n      }\n    })\n\n    httpClient.events.on(\"output\", (output, {websocketFrame = false} = {}) => {\n      if (output !== null && output !== undefined) {\n        const delivery = () => serverClient.send(output)\n        const queued = websocketFrame\n          ? deliveryQueue.enqueueFrame({\n            byteLength: typeof output === \"string\" ? Buffer.byteLength(output) : output.byteLength,\n            delivery\n          })\n          : deliveryQueue.enqueueControl(delivery)\n\n        void queued.catch((error) => {\n          this.logger.error(() => [\"Failed to deliver client output\", {clientCount}, error])\n        })\n      }\n    })\n\n    httpClient.events.on(\"file\", ({filePath, sendBody, settle}) => {\n      void deliveryQueue.enqueueControl(async () => {\n        await settle(await serverClient.sendFile(filePath, sendBody))\n      }).catch((error) => {\n        this.logger.error(() => [\"Failed to deliver file response\", {clientCount, filePath}, error])\n        void settle(\"aborted\")\n      })\n    })\n\n    httpClient.events.on(\"close\", () => {\n      void deliveryQueue.enqueueControl(() => serverClient.end())\n        .finally(() => delete this.clients[clientCount])\n    })\n\n    serverClient.events.on(\"close\", () => {\n      deliveryQueue.destroy()\n      const cleanup = httpClient.abortPendingFileResponses()\n        .catch((error) => {\n          this.logger.warn(\"Failed to abort file responses after client close\", error)\n        })\n        .finally(() => {\n          this.pendingClientCloseCleanups.delete(cleanup)\n          delete this.clients[clientCount]\n        })\n\n      this.pendingClientCloseCleanups.add(cleanup)\n    })\n\n    this.clients[clientCount] = {deliveryQueue, httpClient, serverClient}\n\n    // Create a message-port shim so ServerClient.onSocketData can route data\n    // to the in-process HTTP Client without needing a real worker thread.\n    const messagePortShim = /** @type {import(\"worker_threads\").Worker} */ (/** @type {?} */ ({\n      postMessage: (/** @type {{command: string, chunk?: Buffer | Uint8Array | string, clientCount?: number}} */ data) => {\n        if (data.command === \"clientWrite\" && data.chunk) {\n          const chunk = typeof data.chunk === \"string\" ? Buffer.from(data.chunk) : Buffer.from(data.chunk)\n\n          httpClient.onWrite(chunk)\n        }\n      }\n    }))\n\n    serverClient.setWorker(messagePortShim)\n    serverClient.listen()\n  }\n\n  /**\n   * Reports a per-client outbound queue overflow.\n   * @param {object} args - Overflow details.\n   * @param {number} args.clientCount - Affected client.\n   * @param {Error} args.error - Overflow error.\n   * @returns {void}\n   */\n  _reportOutboundQueueOverflow({clientCount, error}) {\n    const errorPayload = {\n      context: {clientCount, websocketOutboundQueueOverflow: true, workerCount: this.workerCount},\n      error\n    }\n    const errorEvents = this.configuration.getErrorEvents()\n\n    errorEvents.emit(\"framework-error\", errorPayload)\n    errorEvents.emit(\"all-error\", {...errorPayload, errorType: \"framework-error\"})\n  }\n\n  /**\n   * Runs stop.\n   * @returns {Promise<void>} */\n  async stop() {\n    this._stopping = true\n\n    for (const {httpClient, serverClient} of Object.values(this.clients)) {\n      await Promise.all([\n        httpClient.abortPendingFileResponses().catch((error) => {\n          this.logger.warn(\"Failed to abort file responses during shutdown\", error)\n        }),\n        serverClient.end().catch((error) => {\n          this.logger.warn(\"Failed to close client during shutdown\", error)\n        })\n      ])\n    }\n\n    await Promise.all(this.pendingClientCloseCleanups)\n\n    this.clients = {}\n    this.unregisterFromEventsHost?.()\n  }\n\n  /**\n   * In-process handler path for V2 channel broadcasts. No worker\n   * boundary to cross — dispatch directly to any matching live\n   * subscriptions on the shared configuration.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {Record<string, ?>} args.broadcastParams - Routing filter params.\n   * @param {?} args.body - Message body.\n   * @param {string} [args.eventId] - Persisted event id for replay.\n   * @returns {void}\n   */\n  dispatchWebsocketV2Broadcast({body, broadcastParams, channel, eventId}) {\n    if (!this.configuration) return\n\n    return this.configuration._broadcastToChannelLocal(channel, broadcastParams, body, {eventId})\n  }\n\n  /**\n   * Gets the configuration-wide V2 broadcast target shared by in-process handlers.\n   * @returns {import(\"../../configuration.js\").default} - Shared configuration target.\n   */\n  websocketV2BroadcastDispatchKey() {\n    return this.configuration\n  }\n\n  /**\n   * Runs dispatch websocket event.\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {string} [args.createdAt] - Event creation time.\n   * @param {string} [args.eventId] - Event identifier.\n   * @param {?} args.payload - Payload data.\n   * @returns {void}\n   */\n  dispatchWebsocketEvent({channel, createdAt, eventId, payload}) {\n    for (const {httpClient} of Object.values(this.clients)) {\n      const session = httpClient.websocketSession\n\n      if (!session) continue\n\n      void session.sendEvent(channel, payload, {createdAt, eventId})\n    }\n\n    if (this.configuration) {\n      // Isolate subscriber failures from breaking the in-process handler,\n      // but still surface them to the framework error events so bug\n      // reporters can pick them up.\n      void dispatchChannelSubscribers({channel, configuration: this.configuration, createdAt, eventId, logger: this.logger, payload})\n    }\n  }\n}\n"]}

package/build/src/http-server/worker-handler/index.d.ts

@@ -25,8 +25,8 @@ export default class VelociousHttpServerWorker {
     _debugSnapshotRequests: Map<number, {
         resolve: (snapshot: Record<string, unknown>) => void;
     }>;
-    /** @type {Map<number, Promise<void>>} */
-    _clientDeliveryQueues: Map<number, Promise<void>>;
+    /** @type {Map<number, ClientDeliveryQueue>} */
+    _clientDeliveryQueues: Map<number, ClientDeliveryQueue>;
     start(): Promise<any>;
     onStartCallback: ((value: any) => void) | null | undefined;
     _spawnWorker(): Promise<void>;
@@ -70,6 +70,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.
@@ -85,6 +86,7 @@ export default class VelociousHttpServerWorker {
         filePath?: string | undefined;
         sendBody?: boolean | undefined;
         transferId?: number | undefined;
+        websocketFrame?: boolean | undefined;
         channel?: string | undefined;
         requestId?: number | undefined;
         snapshot?: Record<string, any> | undefined;
@@ -94,11 +96,35 @@ export default class VelociousHttpServerWorker {
     }) => void;
     /**
      * 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: import("../server-client.js").default, output: string | Uint8Array): Promise<void>;
+    /**
+     * 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: number, delivery: () => Promise<void>): Promise<void>;
+    enqueueClientControl(client: import("../server-client.js").default, delivery: () => Promise<void>): Promise<void>;
+    /**
+     * 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: import("../server-client.js").default): ClientDeliveryQueue;
+    /**
+     * 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 }: {
+        clientCount: number;
+        error: Error;
+    }): void;
     /**
      * Runs get debug snapshot.
      * @returns {Promise<Record<string, ?>>} - Worker-local debug snapshot.
@@ -142,6 +168,11 @@ export default class VelociousHttpServerWorker {
         eventId?: string | undefined;
         createdAt?: string | undefined;
     }): void;
+    /**
+     * Gets this worker's isolated V2 broadcast target.
+     * @returns {VelociousHttpServerWorker} - This worker handler.
+     */
+    websocketV2BroadcastDispatchKey(): VelociousHttpServerWorker;
     /**
      * Runs register with events host.
      * @returns {void} */
@@ -153,5 +184,6 @@ export default class VelociousHttpServerWorker {
     unregisterFromEventsHostIfNeeded(): void;
 }
 import Logger from "../../logger.js";
+import ClientDeliveryQueue from "../client-delivery-queue.js";
 import { Worker } from "worker_threads";
 //# sourceMappingURL=index.d.ts.map

package/build/src/http-server/worker-handler/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/index.js"],"names":[],"mappings":"AAoCA;IACE;;;;;OAKG;IACH,4CAHG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QAC3B,WAAW,EAAxB,MAAM;KAChB,EAqBA;IAnBC,wDAAkC;IAElC;;uEAEmE;IACnE,SADU,MAAM,CAAC,MAAM,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC,CAC9C;IAEjB,eAA8B;IAC9B,oBAA8B;IAC9B,uBAA0B;IAC1B,mBAAsB;IACtB,wBAAwB;IACxB;;+EAE2E;IAC3E,wBADU,GAAG,CAAC,MAAM,EAAE;QAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,KAAK,IAAI,CAAA;KAAC,CAAC,CAChC;IAEvC,yCAAyC;IACzC,uBADW,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CACC;IAGxC,sBAKC;IAHG,2DAA8B;IAKlC,8BAgBC;IAXC,2BAOE;IAMJ;;;;OAIG;IACH,4BAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAehB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,IAAI,CAQhB;IAED;;;OAGG;IACH,gBAAiB,OAFN,OAEW,WAKrB;IAED;;;;OAIG;IACH,eAAgB,MAHL,MAGS,KAFP,IAAI,CAmBhB;IAhBC,gCAAsB;IAetB,6EAAwB;IAG1B;;;OAGG;IACH,oBAFa,IAAI,CAahB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,kBAAmB,MAdhB;QAAqB,OAAO,EAApB,MAAM;QACQ,WAAW;QACE,MAAM;QACnB,QAAQ;QACP,QAAQ;QACT,UAAU;QACV,OAAO;QACP,SAAS;QACE,QAAQ;QACxB,OAAO,GAAhB,OAAC;QACwB,eAAe;QAC/B,IAAI,GAAb,OAAC;KAGW,KAFV,IAAI,CAyGhB;IAED;;;;;OAKG;IACH,mCAJW,MAAM,YACN,MAAM,OAAO,CAAC,IAAI,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,oBAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAiCtC;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAiBzB;IAED;;;;;;;;OAQG;IACH,iEANG;QAAqB,OAAO,EAApB,MAAM;QACQ,SAAS;QACT,OAAO;QACb,OAAO,EAAf,OAAC;KACT,GAAU,IAAI,CAQhB;IAED;;;;;;;;;;OAUG;IACH,qFAPG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;QACa,OAAO;QACP,SAAS;KAC/B,GAAU,IAAI,CAOhB;IAED;;yBAEqB;IACrB,0BADa,IAAI,CAKhB;IADC,0DAAkE;IAGpE;;yBAEqB;IACrB,oCADa,IAAI,CAMhB;CACF;mBA3akB,iBAAiB;uBACf,gBAAgB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/index.js"],"names":[],"mappings":"AAqCA;IACE;;;;;OAKG;IACH,4CAHG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QAC3B,WAAW,EAAxB,MAAM;KAChB,EAqBA;IAnBC,wDAAkC;IAElC;;uEAEmE;IACnE,SADU,MAAM,CAAC,MAAM,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC,CAC9C;IAEjB,eAA8B;IAC9B,oBAA8B;IAC9B,uBAA0B;IAC1B,mBAAsB;IACtB,wBAAwB;IACxB;;+EAE2E;IAC3E,wBADU,GAAG,CAAC,MAAM,EAAE;QAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,KAAK,IAAI,CAAA;KAAC,CAAC,CAChC;IAEvC,+CAA+C;IAC/C,uBADW,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CACL;IAGxC,sBAKC;IAHG,2DAA8B;IAKlC,8BAgBC;IAXC,2BAOE;IAMJ;;;;OAIG;IACH,4BAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAehB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,gBAAiB,OAFN,OAEW,WAKrB;IAED;;;;OAIG;IACH,eAAgB,MAHL,MAGS,KAFP,IAAI,CAmBhB;IAhBC,gCAAsB;IAetB,6EAAwB;IAG1B;;;OAGG;IACH,oBAFa,IAAI,CAiBhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAAmB,MAfhB;QAAqB,OAAO,EAApB,MAAM;QACQ,WAAW;QACE,MAAM;QACnB,QAAQ;QACP,QAAQ;QACT,UAAU;QACT,cAAc;QACf,OAAO;QACP,SAAS;QACE,QAAQ;QACxB,OAAO,GAAhB,OAAC;QACwB,eAAe;QAC/B,IAAI,GAAb,OAAC;KAGW,KAFV,IAAI,CAkHhB;IAED;;;;;OAKG;IACH,2BAJW,OAAO,qBAAqB,EAAE,OAAO,UACrC,MAAM,GAAG,UAAU,GACjB,OAAO,CAAC,IAAI,CAAC,CASzB;IAED;;;;;OAKG;IACH,6BAJW,OAAO,qBAAqB,EAAE,OAAO,YACrC,MAAM,OAAO,CAAC,IAAI,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,0BAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,mBAAmB,CAoB/B;IAED;;;;;;OAMG;IACH,qDAJG;QAAqB,WAAW,EAAxB,MAAM;QACM,KAAK,EAAjB,KAAK;KACb,GAAU,IAAI,CAWhB;IAED;;;OAGG;IACH,oBAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAiCtC;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAiBzB;IAED;;;;;;;;OAQG;IACH,iEANG;QAAqB,OAAO,EAApB,MAAM;QACQ,SAAS;QACT,OAAO;QACb,OAAO,EAAf,OAAC;KACT,GAAU,IAAI,CAQhB;IAED;;;;;;;;;;OAUG;IACH,qFAPG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;QACa,OAAO;QACP,SAAS;KAC/B,GAAU,IAAI,CAOhB;IAED;;;OAGG;IACH,mCAFa,yBAAyB,CAIrC;IAED;;yBAEqB;IACrB,0BADa,IAAI,CAKhB;IADC,0DAAkE;IAGpE;;yBAEqB;IACrB,oCADa,IAAI,CAMhB;CACF;mBAjfkB,iBAAiB;gCACJ,6BAA6B;uBACxC,gBAAgB"}