velocious 1.0.423 → 1.0.424

package/build/src/http-server/worker-handler/channel-subscriber-dispatch.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @param {object} args - Dispatch arguments.
+ * @param {string} args.channel - Channel name.
+ * @param {string | undefined} args.createdAt - Event creation timestamp.
+ * @param {string | undefined} args.eventId - Event identifier.
+ * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
+ * @param {import("../../logger.js").default} args.logger - Logger for isolated subscriber failures.
+ * @param {any} args.payload - Broadcast payload.
+ * @returns {Promise<void>} Resolves after subscribers have been attempted.
+ */
+export default function dispatchChannelSubscribers({ channel, configuration, createdAt, eventId, logger, payload }: {
+    channel: string;
+    createdAt: string | undefined;
+    eventId: string | undefined;
+    configuration: import("../../configuration.js").default;
+    logger: import("../../logger.js").default;
+    payload: any;
+}): Promise<void>;
+//# sourceMappingURL=channel-subscriber-dispatch.d.ts.map

package/build/src/http-server/worker-handler/channel-subscriber-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-subscriber-dispatch.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/channel-subscriber-dispatch.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,oHARG;IAAqB,OAAO,EAApB,MAAM;IACmB,SAAS,EAAlC,MAAM,GAAG,SAAS;IACO,OAAO,EAAhC,MAAM,GAAG,SAAS;IAC6B,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;IACA,MAAM,EAA9C,OAAO,iBAAiB,EAAE,OAAO;IACvB,OAAO,EAAjB,GAAG;CACX,GAAU,OAAO,CAAC,IAAI,CAAC,CAgBzB"}

package/build/src/http-server/worker-handler/channel-subscriber-dispatch.js

@@ -0,0 +1,26 @@
+// @ts-check
+/**
+ * @param {object} args - Dispatch arguments.
+ * @param {string} args.channel - Channel name.
+ * @param {string | undefined} args.createdAt - Event creation timestamp.
+ * @param {string | undefined} args.eventId - Event identifier.
+ * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
+ * @param {import("../../logger.js").default} args.logger - Logger for isolated subscriber failures.
+ * @param {any} args.payload - Broadcast payload.
+ * @returns {Promise<void>} Resolves after subscribers have been attempted.
+ */
+export default async function dispatchChannelSubscribers({ channel, configuration, createdAt, eventId, logger, payload }) {
+    try {
+        await configuration.getWebsocketChannelSubscribers().dispatch({ channel, createdAt, eventId, payload });
+    }
+    catch (error) {
+        logger.error(() => [`Channel subscriber dispatch failed for ${channel}`, error]);
+        const errorPayload = {
+            context: { channel, createdAt, eventId, source: "websocket-channel-subscribers" },
+            error
+        };
+        configuration.getErrorEvents().emit("framework-error", errorPayload);
+        configuration.getErrorEvents().emit("all-error", { ...errorPayload, errorType: "framework-error" });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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":"AAMA;;;;;GAKG;AACH;IACE;;;;OAIG;IACH,4CAHG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QAC3B,WAAW,EAAxB,MAAM;KAChB,EAWA;IATC,wDAAkC;IAElC,wGAAwG;IACxG,SADW,MAAM,CAAC,MAAM,EAAE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,CAAC,CACnF;IAEjB,eAA8B;IAC9B,oBAA8B;IAC9B,qCAAuF;IACvF,mBAAsB;IAGxB,+BAA+B;IAC/B,SADc,OAAO,CAAC,IAAI,CAAC,CAG1B;IAED;;;OAGG;IACH,kCAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAwChB;IAED,+BAA+B;IAC/B,QADc,OAAO,CAAC,IAAI,CAAC,CAc1B;IAED;;;;;;;OAOG;IACH;;;;;;;;;;;OAWG;IACH,0EANG;QAAqB,OAAO,EAApB,MAAM;QACoB,eAAe,EAAzC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACT,IAAI,EAAd,GAAG;QACW,OAAO;KAC7B,GAAU,IAAI,CAMhB;IAED;;;;;;;OAOG;IACH,iEANG;QAAqB,OAAO,EAApB,MAAM;QACQ,SAAS;QACT,OAAO;QACX,OAAO,EAAjB,GAAG;KACX,GAAU,IAAI,CA+BhB;CACF;mBA7JkB,oBAAoB;mBACpB,iBAAiB"}
+{"version":3,"file":"in-process.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/in-process.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH;IACE;;;;OAIG;IACH,4CAHG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QAC3B,WAAW,EAAxB,MAAM;KAChB,EAWA;IATC,wDAAkC;IAElC,wGAAwG;IACxG,SADW,MAAM,CAAC,MAAM,EAAE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAA;KAAC,CAAC,CACnF;IAEjB,eAA8B;IAC9B,oBAA8B;IAC9B,qCAAuF;IACvF,mBAAsB;IAGxB,+BAA+B;IAC/B,SADc,OAAO,CAAC,IAAI,CAAC,CAG1B;IAED;;;OAGG;IACH,kCAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAwChB;IAED,+BAA+B;IAC/B,QADc,OAAO,CAAC,IAAI,CAAC,CAc1B;IAED;;;;;;;OAOG;IACH;;;;;;;;;;;OAWG;IACH,0EANG;QAAqB,OAAO,EAApB,MAAM;QACoB,eAAe,EAAzC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACT,IAAI,EAAd,GAAG;QACW,OAAO;KAC7B,GAAU,IAAI,CAMhB;IAED;;;;;;;OAOG;IACH,iEANG;QAAqB,OAAO,EAApB,MAAM;QACQ,SAAS;QACT,OAAO;QACX,OAAO,EAAjB,GAAG;KACX,GAAU,IAAI,CAiBhB;CACF;mBAhJkB,oBAAoB;mBAEpB,iBAAiB"}

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

@@ -1,5 +1,6 @@
 // @ts-check
 import Client from "../client/index.js";
+import dispatchChannelSubscribers from "./channel-subscriber-dispatch.js";
 import Logger from "../../logger.js";
 import websocketEventsHost from "../websocket-events-host.js";
 /**
@@ -118,22 +119,11 @@ export default class VelociousHttpServerInProcessHandler {
             void session.sendEvent(channel, payload, { createdAt, eventId });
         }
         if (this.configuration) {
-            const configuration = this.configuration;
             // Isolate subscriber failures from breaking the in-process handler,
             // but still surface them to the framework error events so bug
             // reporters can pick them up.
-            void configuration.getWebsocketChannelSubscribers()
-                .dispatch({ channel, createdAt, eventId, payload })
-                .catch((error) => {
-                this.logger.error(() => [`Channel subscriber dispatch failed for ${channel}`, error]);
-                const errorPayload = {
-                    context: { channel, createdAt, eventId, source: "websocket-channel-subscribers" },
-                    error
-                };
-                configuration.getErrorEvents().emit("framework-error", errorPayload);
-                configuration.getErrorEvents().emit("all-error", { ...errorPayload, errorType: "framework-error" });
-            });
+            void dispatchChannelSubscribers({ channel, configuration: this.configuration, createdAt, eventId, logger: this.logger, payload });
         }
     }
 }
-//# 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 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   * @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    /** @type {Record<number, {httpClient: Client, serverClient: import(\"../server-client.js\").default}>} */\n    this.clients = {}\n\n    this.logger = new Logger(this)\n    this.workerCount = workerCount\n    this.unregisterFromEventsHost = websocketEventsHost.register(/** @type {any} */ (this))\n    this._stopping = false\n  }\n\n  /** @returns {Promise<void>} */\n  async start() {\n    await this.logger.debug(() => `In-process handler ${this.workerCount} started`)\n  }\n\n  /**\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    httpClient.events.on(\"output\", (output) => {\n      if (output !== null && output !== undefined) {\n        void serverClient.send(output).catch((error) => {\n          this.logger.error(() => [\"Failed to deliver client output\", {clientCount}, error])\n        })\n      }\n    })\n\n    httpClient.events.on(\"close\", () => {\n      void serverClient.end()\n      delete this.clients[clientCount]\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 {unknown} */ ({\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  /** @returns {Promise<void>} */\n  async stop() {\n    this._stopping = true\n\n    for (const {serverClient} of Object.values(this.clients)) {\n      try {\n        void serverClient.end()\n      } catch (error) {\n        this.logger.warn(\"Failed to close client during shutdown\", error)\n      }\n    }\n\n    this.clients = {}\n    this.unregisterFromEventsHost?.()\n  }\n\n  /**\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 {any} args.payload - Payload data.\n   * @returns {void}\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   *\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {Record<string, any>} args.broadcastParams - Routing filter params.\n   * @param {any} 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    /** @type {any} */ (this.configuration)._broadcastToChannelLocal(channel, broadcastParams, body, {eventId})\n  }\n\n  /**\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 {any} 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      const configuration = this.configuration\n\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 configuration.getWebsocketChannelSubscribers()\n        .dispatch({channel, createdAt, eventId, payload})\n        .catch((error) => {\n          this.logger.error(() => [`Channel subscriber dispatch failed for ${channel}`, error])\n\n          const errorPayload = {\n            context: {channel, createdAt, eventId, source: \"websocket-channel-subscribers\"},\n            error\n          }\n\n          configuration.getErrorEvents().emit(\"framework-error\", errorPayload)\n          configuration.getErrorEvents().emit(\"all-error\", {...errorPayload, errorType: \"framework-error\"})\n        })\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 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   * @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    /** @type {Record<number, {httpClient: Client, serverClient: import(\"../server-client.js\").default}>} */\n    this.clients = {}\n\n    this.logger = new Logger(this)\n    this.workerCount = workerCount\n    this.unregisterFromEventsHost = websocketEventsHost.register(/** @type {any} */ (this))\n    this._stopping = false\n  }\n\n  /** @returns {Promise<void>} */\n  async start() {\n    await this.logger.debug(() => `In-process handler ${this.workerCount} started`)\n  }\n\n  /**\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    httpClient.events.on(\"output\", (output) => {\n      if (output !== null && output !== undefined) {\n        void serverClient.send(output).catch((error) => {\n          this.logger.error(() => [\"Failed to deliver client output\", {clientCount}, error])\n        })\n      }\n    })\n\n    httpClient.events.on(\"close\", () => {\n      void serverClient.end()\n      delete this.clients[clientCount]\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 {unknown} */ ({\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  /** @returns {Promise<void>} */\n  async stop() {\n    this._stopping = true\n\n    for (const {serverClient} of Object.values(this.clients)) {\n      try {\n        void serverClient.end()\n      } catch (error) {\n        this.logger.warn(\"Failed to close client during shutdown\", error)\n      }\n    }\n\n    this.clients = {}\n    this.unregisterFromEventsHost?.()\n  }\n\n  /**\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 {any} args.payload - Payload data.\n   * @returns {void}\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   *\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {Record<string, any>} args.broadcastParams - Routing filter params.\n   * @param {any} 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    /** @type {any} */ (this.configuration)._broadcastToChannelLocal(channel, broadcastParams, body, {eventId})\n  }\n\n  /**\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 {any} 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/worker-thread.d.ts

@@ -59,6 +59,64 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
         broadcastParams?: Record<string, any> | undefined;
         body?: any;
     }) => Promise<void>;
+    /**
+     * @param {object} data - Data payload.
+     * @param {number} [data.clientCount] - Client count.
+     * @param {string} [data.remoteAddress] - Remote address.
+     * @returns {void}
+     */
+    handleNewClient(data: {
+        clientCount?: number | undefined;
+        remoteAddress?: string | undefined;
+    }): void;
+    /**
+     * @param {object} data - Data payload.
+     * @param {Buffer | Uint8Array | string} [data.chunk] - Chunk.
+     * @param {number} [data.clientCount] - Client count.
+     * @returns {Promise<void>} Resolves when the client write is dispatched.
+     */
+    handleClientWrite(data: {
+        chunk?: string | Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | undefined;
+        clientCount?: number | undefined;
+    }): Promise<void>;
+    /**
+     * @param {object} data - Data payload.
+     * @param {string} [data.channel] - Channel name.
+     * @param {string} [data.createdAt] - Event creation time.
+     * @param {string} [data.eventId] - Event identifier.
+     * @param {any} [data.payload] - Payload data.
+     * @returns {Promise<void>} Resolves when the websocket event is dispatched.
+     */
+    handleWebsocketEvent(data: {
+        channel?: string | undefined;
+        createdAt?: string | undefined;
+        eventId?: string | undefined;
+        payload?: any;
+    }): Promise<void>;
+    /**
+     * @param {object} data - Data payload.
+     * @param {Record<string, any>} [data.broadcastParams] - V2 broadcast filter params.
+     * @param {any} [data.body] - V2 broadcast body.
+     * @param {string} [data.channel] - Channel name.
+     * @param {string} [data.eventId] - Event identifier.
+     * @returns {void}
+     */
+    handleWebsocketV2Broadcast(data: {
+        broadcastParams?: Record<string, any> | undefined;
+        body?: any;
+        channel?: string | undefined;
+        eventId?: string | undefined;
+    }): void;
+    /**
+     * @param {object} data - Data payload.
+     * @param {number} [data.requestId] - Debug request id.
+     * @returns {void}
+     */
+    handleDebugSnapshot(data: {
+        requestId?: number | undefined;
+    }): void;
+    /** @returns {Promise<void>} Resolves after worker shutdown has been requested. */
+    handleShutdown(): Promise<void>;
     /**
      * @param {object} args - Options object.
      * @param {string} args.channel - Channel name.

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

@@ -1 +1 @@
-{"version":3,"file":"worker-thread.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-thread.js"],"names":[],"mappings":"AAqBA;IACE;;;;OAIG;IACH,wCAHG;QAAkD,UAAU,EAApD,gDAAmC;QACiD,UAAU,EAA9F;YAAC,KAAK,EAAE,OAAO,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAA;SAAC;KACvF,EAwBA;IAlBC,qCAAqC;IACrC,SADW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAChB;IAEjB,eAA8B;IAC9B,sDAA4B;IAC5B;eAZiB,OAAO;mBAAa,MAAM;qBAAe,MAAM;qBAAe,MAAM;MAYzD;IAC5B,oBAA8B;IAchC;;OAEG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CA0BzB;IAnBC,uDAAuD;IACvD,oEAAgD;IAUhD,6CAAwG;IAGxG,qCAA2E;IAO7E;;;;;;;;;;;;;OAaG;IACH,YAAmB,MAZhB;QAAqB,OAAO,EAApB,MAAM;QAC8B,KAAK;QAC3B,aAAa;QACb,WAAW;QACX,OAAO;QACP,SAAS;QACT,OAAO;QACP,SAAS;QACZ,OAAO,GAAlB,GAAG;QACwB,eAAe;QAC/B,IAAI,GAAf,GAAG;KAES,mBA4EtB;IAED;;;;;;;OAOG;IACH,kEANG;QAAqB,OAAO,EAApB,MAAM;QACmB,SAAS,EAAlC,MAAM,GAAG,SAAS;QACO,OAAO,EAAhC,MAAM,GAAG,SAAS;QACR,OAAO,EAAjB,GAAG;KACX,GAAU,OAAO,CAAC,IAAI,CAAC,CA2CzB;CACF;mBA5NkB,oBAAoB;mBAGpB,iBAAiB;4BAER,wBAAwB;wBAN5B,sBAAsB"}
+{"version":3,"file":"worker-thread.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-thread.js"],"names":[],"mappings":"AAsBA;IACE;;;;OAIG;IACH,wCAHG;QAAkD,UAAU,EAApD,gDAAmC;QACiD,UAAU,EAA9F;YAAC,KAAK,EAAE,OAAO,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAA;SAAC;KACvF,EAwBA;IAlBC,qCAAqC;IACrC,SADW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAChB;IAEjB,eAA8B;IAC9B,sDAA4B;IAC5B;eAZiB,OAAO;mBAAa,MAAM;qBAAe,MAAM;qBAAe,MAAM;MAYzD;IAC5B,oBAA8B;IAchC;;OAEG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CA0BzB;IAnBC,uDAAuD;IACvD,oEAAgD;IAUhD,6CAAwG;IAGxG,qCAA2E;IAO7E;;;;;;;;;;;;;OAaG;IACH,YAAmB,MAZhB;QAAqB,OAAO,EAApB,MAAM;QAC8B,KAAK;QAC3B,aAAa;QACb,WAAW;QACX,OAAO;QACP,SAAS;QACT,OAAO;QACP,SAAS;QACZ,OAAO,GAAlB,GAAG;QACwB,eAAe;QAC/B,IAAI,GAAf,GAAG;KAES,mBAoBtB;IAED;;;;;OAKG;IACH,sBAJG;QAAsB,WAAW;QACX,aAAa;KACnC,GAAU,IAAI,CAyBhB;IAED;;;;;OAKG;IACH,wBAJG;QAA4C,KAAK;QAC3B,WAAW;KACjC,GAAU,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;;;;;OAOG;IACH,2BANG;QAAsB,OAAO;QACP,SAAS;QACT,OAAO;QACV,OAAO,GAAlB,GAAG;KACX,GAAU,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;;;;OAOG;IACH,iCANG;QAAmC,eAAe;QAC/B,IAAI,GAAf,GAAG;QACW,OAAO;QACP,OAAO;KAC7B,GAAU,IAAI,CAShB;IAED;;;;OAIG;IACH,0BAHG;QAAsB,SAAS;KAC/B,GAAU,IAAI,CAahB;IAED,kFAAkF;IAClF,kBADc,OAAO,CAAC,IAAI,CAAC,CAQ1B;IAED;;;;;;;OAOG;IACH,kEANG;QAAqB,OAAO,EAApB,MAAM;QACmB,SAAS,EAAlC,MAAM,GAAG,SAAS;QACO,OAAO,EAAhC,MAAM,GAAG,SAAS;QACR,OAAO,EAAjB,GAAG;KACX,GAAU,OAAO,CAAC,IAAI,CAAC,CA2BzB;CACF;mBAvQkB,oBAAoB;mBAIpB,iBAAiB;4BAER,wBAAwB;wBAP5B,sBAAsB"}

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

@@ -1,6 +1,7 @@
 // @ts-check
 import Application from "../../application.js";
 import Client from "../client/index.js";
+import dispatchChannelSubscribers from "./channel-subscriber-dispatch.js";
 import { digg } from "diggerize";
 import errorLogger from "../../error-logger.js";
 import Logger from "../../logger.js";
@@ -82,74 +83,126 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
         await this.logger.debugLowLevel(() => [`Worker ${this.workerCount} received command`, data]);
         const command = data.command;
         if (command == "newClient") {
-            if (!this.configuration)
-                throw new Error("Configuration not initialized");
-            const { clientCount, remoteAddress } = data;
-            if (typeof clientCount !== "number")
-                throw new Error("clientCount must be a number");
-            const client = new Client({
-                clientCount,
-                configuration: this.configuration,
-                remoteAddress
-            });
-            client.events.on("output", (output) => {
-                this.parentPort.postMessage({ command: "clientOutput", clientCount, output });
-            });
-            client.events.on("close", (output) => {
-                this.logger.debugLowLevel(() => "Close received from client in worker - forwarding to worker parent");
-                this.parentPort.postMessage({ command: "clientClose", clientCount, output });
-            });
-            this.clients[clientCount] = client;
+            this.handleNewClient(data);
         }
         else if (command == "clientWrite") {
-            await this.logger.debugLowLevel("Looking up client");
-            const { chunk, clientCount } = data;
-            if (!chunk)
-                throw new Error("No chunk given");
-            const client = /** @type {Client | undefined} */ (digg(this.clients, clientCount));
-            if (!client)
-                throw new Error(`Client not found for clientWrite: ${clientCount}`);
-            const clientChunk = typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk);
-            await this.logger.debug(() => ["Sending clientWrite to parser", { clientCount, ...summarizeClientWriteChunk(clientChunk) }]);
-            client.onWrite(clientChunk);
+            await this.handleClientWrite(data);
         }
         else if (command == "websocketEvent") {
-            const { channel, createdAt, eventId, payload } = data;
-            if (typeof channel !== "string")
-                throw new Error("No channel given");
-            await this.broadcastWebsocketEvent({ channel, createdAt, eventId, payload });
+            await this.handleWebsocketEvent(data);
         }
         else if (command == "websocketV2Broadcast") {
-            const { body, broadcastParams, channel, eventId } = data;
-            if (typeof channel !== "string")
-                throw new Error("No channel given");
-            if (!this.configuration)
-                throw new Error("Configuration not initialized");
-            this.configuration._broadcastToChannelLocal(channel, broadcastParams || {}, body, { eventId });
+            this.handleWebsocketV2Broadcast(data);
         }
         else if (command == "debugSnapshot") {
-            const { requestId } = data;
-            if (typeof requestId !== "number")
-                throw new Error("debugSnapshot requestId must be a number");
-            if (!this.configuration)
-                throw new Error("Configuration not initialized");
-            this.parentPort.postMessage({
-                command: "debugSnapshot",
-                requestId,
-                snapshot: this.configuration.getLocalDebugSnapshot()
-            });
+            this.handleDebugSnapshot(data);
         }
         else if (command == "shutdown") {
-            if (this.configuration?.closeDatabaseConnections) {
-                await this.configuration.closeDatabaseConnections();
-            }
-            this.parentPort.postMessage({ command: "shutdownComplete" });
-            process.exit(0);
+            await this.handleShutdown();
         }
         else {
             throw new Error(`Unknown command: ${command}`);
         }
     };
+    /**
+     * @param {object} data - Data payload.
+     * @param {number} [data.clientCount] - Client count.
+     * @param {string} [data.remoteAddress] - Remote address.
+     * @returns {void}
+     */
+    handleNewClient(data) {
+        if (!this.configuration)
+            throw new Error("Configuration not initialized");
+        const { clientCount, remoteAddress } = data;
+        if (typeof clientCount !== "number")
+            throw new Error("clientCount must be a number");
+        const client = new Client({
+            clientCount,
+            configuration: this.configuration,
+            remoteAddress
+        });
+        client.events.on("output", (output) => {
+            this.parentPort.postMessage({ command: "clientOutput", clientCount, output });
+        });
+        client.events.on("close", (output) => {
+            this.logger.debugLowLevel(() => "Close received from client in worker - forwarding to worker parent");
+            this.parentPort.postMessage({ command: "clientClose", clientCount, output });
+        });
+        this.clients[clientCount] = client;
+    }
+    /**
+     * @param {object} data - Data payload.
+     * @param {Buffer | Uint8Array | string} [data.chunk] - Chunk.
+     * @param {number} [data.clientCount] - Client count.
+     * @returns {Promise<void>} Resolves when the client write is dispatched.
+     */
+    async handleClientWrite(data) {
+        await this.logger.debugLowLevel("Looking up client");
+        const { chunk, clientCount } = data;
+        if (!chunk)
+            throw new Error("No chunk given");
+        const client = /** @type {Client | undefined} */ (digg(this.clients, clientCount));
+        if (!client)
+            throw new Error(`Client not found for clientWrite: ${clientCount}`);
+        const clientChunk = typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk);
+        await this.logger.debug(() => ["Sending clientWrite to parser", { clientCount, ...summarizeClientWriteChunk(clientChunk) }]);
+        client.onWrite(clientChunk);
+    }
+    /**
+     * @param {object} data - Data payload.
+     * @param {string} [data.channel] - Channel name.
+     * @param {string} [data.createdAt] - Event creation time.
+     * @param {string} [data.eventId] - Event identifier.
+     * @param {any} [data.payload] - Payload data.
+     * @returns {Promise<void>} Resolves when the websocket event is dispatched.
+     */
+    async handleWebsocketEvent(data) {
+        const { channel, createdAt, eventId, payload } = data;
+        if (typeof channel !== "string")
+            throw new Error("No channel given");
+        await this.broadcastWebsocketEvent({ channel, createdAt, eventId, payload });
+    }
+    /**
+     * @param {object} data - Data payload.
+     * @param {Record<string, any>} [data.broadcastParams] - V2 broadcast filter params.
+     * @param {any} [data.body] - V2 broadcast body.
+     * @param {string} [data.channel] - Channel name.
+     * @param {string} [data.eventId] - Event identifier.
+     * @returns {void}
+     */
+    handleWebsocketV2Broadcast(data) {
+        const { body, broadcastParams, channel, eventId } = data;
+        if (typeof channel !== "string")
+            throw new Error("No channel given");
+        if (!this.configuration)
+            throw new Error("Configuration not initialized");
+        this.configuration._broadcastToChannelLocal(channel, broadcastParams || {}, body, { eventId });
+    }
+    /**
+     * @param {object} data - Data payload.
+     * @param {number} [data.requestId] - Debug request id.
+     * @returns {void}
+     */
+    handleDebugSnapshot(data) {
+        const { requestId } = data;
+        if (typeof requestId !== "number")
+            throw new Error("debugSnapshot requestId must be a number");
+        if (!this.configuration)
+            throw new Error("Configuration not initialized");
+        this.parentPort.postMessage({
+            command: "debugSnapshot",
+            requestId,
+            snapshot: this.configuration.getLocalDebugSnapshot()
+        });
+    }
+    /** @returns {Promise<void>} Resolves after worker shutdown has been requested. */
+    async handleShutdown() {
+        if (this.configuration?.closeDatabaseConnections) {
+            await this.configuration.closeDatabaseConnections();
+        }
+        this.parentPort.postMessage({ command: "shutdownComplete" });
+        process.exit(0);
+    }
     /**
      * @param {object} args - Options object.
      * @param {string} args.channel - Channel name.
@@ -173,24 +226,13 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
             }));
         }
         if (this.configuration) {
-            const configuration = this.configuration;
             // Isolate channel subscriber failures so a buggy in-process callback
             // cannot reject this command and crash the worker thread, but still
             // surface the error to the framework error events so bug reporters
             // can pick it up.
-            sendTasks.push(configuration.getWebsocketChannelSubscribers()
-                .dispatch({ channel, createdAt, eventId, payload })
-                .catch((error) => {
-                this.logger.error(() => [`Channel subscriber dispatch failed for ${channel}`, error]);
-                const errorPayload = {
-                    context: { channel, createdAt, eventId, source: "websocket-channel-subscribers" },
-                    error
-                };
-                configuration.getErrorEvents().emit("framework-error", errorPayload);
-                configuration.getErrorEvents().emit("all-error", { ...errorPayload, errorType: "framework-error" });
-            }));
+            sendTasks.push(dispatchChannelSubscribers({ channel, configuration: this.configuration, createdAt, eventId, logger: this.logger, payload }));
         }
         await Promise.all(sendTasks);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker-thread.js","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-thread.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Application from \"../../application.js\"\nimport Client from \"../client/index.js\"\nimport {digg} from \"diggerize\"\nimport errorLogger from \"../../error-logger.js\"\nimport Logger from \"../../logger.js\"\nimport toImportSpecifier from \"../../utils/to-import-specifier.js\"\nimport WebsocketEvents from \"../websocket-events.js\"\n\n/**\n * @param {Buffer | Uint8Array | string} chunk - Client input payload.\n * @returns {{length: number, preview: string}} - Chunk summary for logging.\n */\nfunction summarizeClientWriteChunk(chunk) {\n  const normalizedChunk = typeof chunk === \"string\" ? Buffer.from(chunk) : Buffer.from(chunk)\n  const preview = normalizedChunk.toString(\"latin1\", 0, Math.min(normalizedChunk.length, 160)).replaceAll(\"\\r\", \"\\\\r\").replaceAll(\"\\n\", \"\\\\n\")\n\n  return {length: normalizedChunk.length, preview}\n}\n\nexport default class VelociousHttpServerWorkerHandlerWorkerThread {\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"worker_threads\").parentPort} args.parentPort - Parent port.\n   * @param {{debug: boolean, directory: string, environment: string, workerCount: number}} args.workerData - Worker configuration details.\n   */\n  constructor({parentPort, workerData}) {\n    if (!parentPort) throw new Error(\"parentPort is required\")\n\n    const {workerCount} = workerData\n\n    /** @type {Record<number, Client>} */\n    this.clients = {}\n\n    this.logger = new Logger(this)\n    this.parentPort = parentPort\n    this.workerData = workerData\n    this.workerCount = workerCount\n\n    parentPort.on(\"message\", errorLogger(this.onCommand))\n\n    this.initialize().then(() => {\n      if (!this.application) throw new Error(\"Application not initialized\")\n\n      this.application.initialize().then(() => {\n        this.logger.debugLowLevel(() => `Worker ${workerCount} started`)\n        parentPort.postMessage({command: \"started\"})\n      })\n    })\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initialize() {\n    const {debug, directory, environment} = this.workerData\n    const configurationPath = `${directory}/src/config/configuration.js`\n    const configurationImport = await import(toImportSpecifier(configurationPath))\n\n    /** @type {import(\"../../configuration.js\").default} */\n    this.configuration = configurationImport.default\n\n    if (!this.configuration) throw new Error(`Configuration couldn't be loaded from: ${configurationPath}`)\n\n    const configuration = this.configuration\n\n    configuration.debug = debug === true\n    configuration.setEnvironment(environment)\n    configuration.setCurrent()\n    await this.logger.debug(() => [\"Worker thread configuration loaded\", {debug: configuration.debug, workerCount: this.workerCount}])\n    this.websocketEvents = new WebsocketEvents({parentPort: this.parentPort, workerCount: this.workerCount})\n    configuration.setWebsocketEvents(this.websocketEvents)\n\n    this.application = new Application({configuration, type: \"worker-handler\"})\n\n    if (!configuration.isInitialized()) {\n      await configuration.initialize({type: \"worker-handler\"})\n    }\n  }\n\n  /**\n   * @param {object} data - Data payload.\n   * @param {string} data.command - Command.\n   * @param {Buffer | Uint8Array | string} [data.chunk] - Chunk.\n   * @param {string} [data.remoteAddress] - Remote address.\n   * @param {number} [data.clientCount] - Client count.\n   * @param {string} [data.channel] - Channel name.\n   * @param {string} [data.createdAt] - Event creation time.\n   * @param {string} [data.eventId] - Event identifier.\n   * @param {number} [data.requestId] - Debug request id.\n   * @param {any} [data.payload] - Payload data.\n   * @param {Record<string, any>} [data.broadcastParams] - V2 broadcast filter params.\n   * @param {any} [data.body] - V2 broadcast body.\n   */\n  onCommand = async (data) => {\n    await this.logger.debugLowLevel(() => [`Worker ${this.workerCount} received command`, data])\n\n    const command = data.command\n\n    if (command == \"newClient\") {\n      if (!this.configuration) throw new Error(\"Configuration not initialized\")\n\n      const {clientCount, remoteAddress} = data\n\n      if (typeof clientCount !== \"number\") throw new Error(\"clientCount must be a number\")\n\n      const client = new Client({\n        clientCount,\n        configuration: this.configuration,\n        remoteAddress\n      })\n\n      client.events.on(\"output\", (output) => {\n        this.parentPort.postMessage({command: \"clientOutput\", clientCount, output})\n      })\n\n      client.events.on(\"close\", (output) => {\n        this.logger.debugLowLevel(() => \"Close received from client in worker - forwarding to worker parent\")\n        this.parentPort.postMessage({command: \"clientClose\", clientCount, output})\n      })\n\n      this.clients[clientCount] = client\n    } else if (command == \"clientWrite\") {\n      await this.logger.debugLowLevel(\"Looking up client\")\n\n      const {chunk, clientCount} = data\n      if (!chunk) throw new Error(\"No chunk given\")\n      const client = /** @type {Client | undefined} */ (digg(this.clients, clientCount))\n\n      if (!client) throw new Error(`Client not found for clientWrite: ${clientCount}`)\n\n      const clientChunk = typeof chunk === \"string\" ? Buffer.from(chunk) : Buffer.from(chunk)\n\n      await this.logger.debug(() => [\"Sending clientWrite to parser\", {clientCount, ...summarizeClientWriteChunk(clientChunk)}])\n\n      client.onWrite(clientChunk)\n    } else if (command == \"websocketEvent\") {\n      const {channel, createdAt, eventId, payload} = data\n\n      if (typeof channel !== \"string\") throw new Error(\"No channel given\")\n\n      await this.broadcastWebsocketEvent({channel, createdAt, eventId, payload})\n    } else if (command == \"websocketV2Broadcast\") {\n      const {body, broadcastParams, channel, eventId} = data\n\n      if (typeof channel !== \"string\") throw new Error(\"No channel given\")\n      if (!this.configuration) throw new Error(\"Configuration not initialized\")\n\n      this.configuration._broadcastToChannelLocal(channel, broadcastParams || {}, body, {eventId})\n    } else if (command == \"debugSnapshot\") {\n      const {requestId} = data\n\n      if (typeof requestId !== \"number\") throw new Error(\"debugSnapshot requestId must be a number\")\n      if (!this.configuration) throw new Error(\"Configuration not initialized\")\n\n      this.parentPort.postMessage({\n        command: \"debugSnapshot\",\n        requestId,\n        snapshot: this.configuration.getLocalDebugSnapshot()\n      })\n    } else if (command == \"shutdown\") {\n      if (this.configuration?.closeDatabaseConnections) {\n        await this.configuration.closeDatabaseConnections()\n      }\n\n      this.parentPort.postMessage({command: \"shutdownComplete\"})\n      process.exit(0)\n    } else {\n      throw new Error(`Unknown command: ${command}`)\n    }\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {string | undefined} args.createdAt - Event creation time.\n   * @param {string | undefined} args.eventId - Event identifier.\n   * @param {any} args.payload - Payload data.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async broadcastWebsocketEvent({channel, createdAt, eventId, payload}) {\n    const sendTasks = []\n\n    for (const clientKey of Object.keys(this.clients)) {\n      const client = this.clients[Number(clientKey)]\n      if (!client) continue\n      const session = client.websocketSession\n\n      if (!session) continue\n\n      sendTasks.push(session.sendEvent(channel, payload, {\n        createdAt,\n        eventId\n      }))\n    }\n\n    if (this.configuration) {\n      const configuration = this.configuration\n\n      // Isolate channel subscriber failures so a buggy in-process callback\n      // cannot reject this command and crash the worker thread, but still\n      // surface the error to the framework error events so bug reporters\n      // can pick it up.\n      sendTasks.push(\n        configuration.getWebsocketChannelSubscribers()\n          .dispatch({channel, createdAt, eventId, payload})\n          .catch((error) => {\n            this.logger.error(() => [`Channel subscriber dispatch failed for ${channel}`, error])\n\n            const errorPayload = {\n              context: {channel, createdAt, eventId, source: \"websocket-channel-subscribers\"},\n              error\n            }\n\n            configuration.getErrorEvents().emit(\"framework-error\", errorPayload)\n            configuration.getErrorEvents().emit(\"all-error\", {...errorPayload, errorType: \"framework-error\"})\n          })\n      )\n    }\n\n    await Promise.all(sendTasks)\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker-thread.js","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-thread.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Application from \"../../application.js\"\nimport Client from \"../client/index.js\"\nimport dispatchChannelSubscribers from \"./channel-subscriber-dispatch.js\"\nimport {digg} from \"diggerize\"\nimport errorLogger from \"../../error-logger.js\"\nimport Logger from \"../../logger.js\"\nimport toImportSpecifier from \"../../utils/to-import-specifier.js\"\nimport WebsocketEvents from \"../websocket-events.js\"\n\n/**\n * @param {Buffer | Uint8Array | string} chunk - Client input payload.\n * @returns {{length: number, preview: string}} - Chunk summary for logging.\n */\nfunction summarizeClientWriteChunk(chunk) {\n  const normalizedChunk = typeof chunk === \"string\" ? Buffer.from(chunk) : Buffer.from(chunk)\n  const preview = normalizedChunk.toString(\"latin1\", 0, Math.min(normalizedChunk.length, 160)).replaceAll(\"\\r\", \"\\\\r\").replaceAll(\"\\n\", \"\\\\n\")\n\n  return {length: normalizedChunk.length, preview}\n}\n\nexport default class VelociousHttpServerWorkerHandlerWorkerThread {\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"worker_threads\").parentPort} args.parentPort - Parent port.\n   * @param {{debug: boolean, directory: string, environment: string, workerCount: number}} args.workerData - Worker configuration details.\n   */\n  constructor({parentPort, workerData}) {\n    if (!parentPort) throw new Error(\"parentPort is required\")\n\n    const {workerCount} = workerData\n\n    /** @type {Record<number, Client>} */\n    this.clients = {}\n\n    this.logger = new Logger(this)\n    this.parentPort = parentPort\n    this.workerData = workerData\n    this.workerCount = workerCount\n\n    parentPort.on(\"message\", errorLogger(this.onCommand))\n\n    this.initialize().then(() => {\n      if (!this.application) throw new Error(\"Application not initialized\")\n\n      this.application.initialize().then(() => {\n        this.logger.debugLowLevel(() => `Worker ${workerCount} started`)\n        parentPort.postMessage({command: \"started\"})\n      })\n    })\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initialize() {\n    const {debug, directory, environment} = this.workerData\n    const configurationPath = `${directory}/src/config/configuration.js`\n    const configurationImport = await import(toImportSpecifier(configurationPath))\n\n    /** @type {import(\"../../configuration.js\").default} */\n    this.configuration = configurationImport.default\n\n    if (!this.configuration) throw new Error(`Configuration couldn't be loaded from: ${configurationPath}`)\n\n    const configuration = this.configuration\n\n    configuration.debug = debug === true\n    configuration.setEnvironment(environment)\n    configuration.setCurrent()\n    await this.logger.debug(() => [\"Worker thread configuration loaded\", {debug: configuration.debug, workerCount: this.workerCount}])\n    this.websocketEvents = new WebsocketEvents({parentPort: this.parentPort, workerCount: this.workerCount})\n    configuration.setWebsocketEvents(this.websocketEvents)\n\n    this.application = new Application({configuration, type: \"worker-handler\"})\n\n    if (!configuration.isInitialized()) {\n      await configuration.initialize({type: \"worker-handler\"})\n    }\n  }\n\n  /**\n   * @param {object} data - Data payload.\n   * @param {string} data.command - Command.\n   * @param {Buffer | Uint8Array | string} [data.chunk] - Chunk.\n   * @param {string} [data.remoteAddress] - Remote address.\n   * @param {number} [data.clientCount] - Client count.\n   * @param {string} [data.channel] - Channel name.\n   * @param {string} [data.createdAt] - Event creation time.\n   * @param {string} [data.eventId] - Event identifier.\n   * @param {number} [data.requestId] - Debug request id.\n   * @param {any} [data.payload] - Payload data.\n   * @param {Record<string, any>} [data.broadcastParams] - V2 broadcast filter params.\n   * @param {any} [data.body] - V2 broadcast body.\n   */\n  onCommand = async (data) => {\n    await this.logger.debugLowLevel(() => [`Worker ${this.workerCount} received command`, data])\n\n    const command = data.command\n\n    if (command == \"newClient\") {\n      this.handleNewClient(data)\n    } else if (command == \"clientWrite\") {\n      await this.handleClientWrite(data)\n    } else if (command == \"websocketEvent\") {\n      await this.handleWebsocketEvent(data)\n    } else if (command == \"websocketV2Broadcast\") {\n      this.handleWebsocketV2Broadcast(data)\n    } else if (command == \"debugSnapshot\") {\n      this.handleDebugSnapshot(data)\n    } else if (command == \"shutdown\") {\n      await this.handleShutdown()\n    } else {\n      throw new Error(`Unknown command: ${command}`)\n    }\n  }\n\n  /**\n   * @param {object} data - Data payload.\n   * @param {number} [data.clientCount] - Client count.\n   * @param {string} [data.remoteAddress] - Remote address.\n   * @returns {void}\n   */\n  handleNewClient(data) {\n    if (!this.configuration) throw new Error(\"Configuration not initialized\")\n\n    const {clientCount, remoteAddress} = data\n\n    if (typeof clientCount !== \"number\") throw new Error(\"clientCount must be a number\")\n\n    const client = new Client({\n      clientCount,\n      configuration: this.configuration,\n      remoteAddress\n    })\n\n    client.events.on(\"output\", (output) => {\n      this.parentPort.postMessage({command: \"clientOutput\", clientCount, output})\n    })\n\n    client.events.on(\"close\", (output) => {\n      this.logger.debugLowLevel(() => \"Close received from client in worker - forwarding to worker parent\")\n      this.parentPort.postMessage({command: \"clientClose\", clientCount, output})\n    })\n\n    this.clients[clientCount] = client\n  }\n\n  /**\n   * @param {object} data - Data payload.\n   * @param {Buffer | Uint8Array | string} [data.chunk] - Chunk.\n   * @param {number} [data.clientCount] - Client count.\n   * @returns {Promise<void>} Resolves when the client write is dispatched.\n   */\n  async handleClientWrite(data) {\n    await this.logger.debugLowLevel(\"Looking up client\")\n\n    const {chunk, clientCount} = data\n    if (!chunk) throw new Error(\"No chunk given\")\n    const client = /** @type {Client | undefined} */ (digg(this.clients, clientCount))\n\n    if (!client) throw new Error(`Client not found for clientWrite: ${clientCount}`)\n\n    const clientChunk = typeof chunk === \"string\" ? Buffer.from(chunk) : Buffer.from(chunk)\n\n    await this.logger.debug(() => [\"Sending clientWrite to parser\", {clientCount, ...summarizeClientWriteChunk(clientChunk)}])\n\n    client.onWrite(clientChunk)\n  }\n\n  /**\n   * @param {object} data - Data payload.\n   * @param {string} [data.channel] - Channel name.\n   * @param {string} [data.createdAt] - Event creation time.\n   * @param {string} [data.eventId] - Event identifier.\n   * @param {any} [data.payload] - Payload data.\n   * @returns {Promise<void>} Resolves when the websocket event is dispatched.\n   */\n  async handleWebsocketEvent(data) {\n    const {channel, createdAt, eventId, payload} = data\n\n    if (typeof channel !== \"string\") throw new Error(\"No channel given\")\n\n    await this.broadcastWebsocketEvent({channel, createdAt, eventId, payload})\n  }\n\n  /**\n   * @param {object} data - Data payload.\n   * @param {Record<string, any>} [data.broadcastParams] - V2 broadcast filter params.\n   * @param {any} [data.body] - V2 broadcast body.\n   * @param {string} [data.channel] - Channel name.\n   * @param {string} [data.eventId] - Event identifier.\n   * @returns {void}\n   */\n  handleWebsocketV2Broadcast(data) {\n    const {body, broadcastParams, channel, eventId} = data\n\n    if (typeof channel !== \"string\") throw new Error(\"No channel given\")\n    if (!this.configuration) throw new Error(\"Configuration not initialized\")\n\n    this.configuration._broadcastToChannelLocal(channel, broadcastParams || {}, body, {eventId})\n  }\n\n  /**\n   * @param {object} data - Data payload.\n   * @param {number} [data.requestId] - Debug request id.\n   * @returns {void}\n   */\n  handleDebugSnapshot(data) {\n    const {requestId} = data\n\n    if (typeof requestId !== \"number\") throw new Error(\"debugSnapshot requestId must be a number\")\n    if (!this.configuration) throw new Error(\"Configuration not initialized\")\n\n    this.parentPort.postMessage({\n      command: \"debugSnapshot\",\n      requestId,\n      snapshot: this.configuration.getLocalDebugSnapshot()\n    })\n  }\n\n  /** @returns {Promise<void>} Resolves after worker shutdown has been requested. */\n  async handleShutdown() {\n    if (this.configuration?.closeDatabaseConnections) {\n      await this.configuration.closeDatabaseConnections()\n    }\n\n    this.parentPort.postMessage({command: \"shutdownComplete\"})\n    process.exit(0)\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {string | undefined} args.createdAt - Event creation time.\n   * @param {string | undefined} args.eventId - Event identifier.\n   * @param {any} args.payload - Payload data.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async broadcastWebsocketEvent({channel, createdAt, eventId, payload}) {\n    const sendTasks = []\n\n    for (const clientKey of Object.keys(this.clients)) {\n      const client = this.clients[Number(clientKey)]\n      if (!client) continue\n      const session = client.websocketSession\n\n      if (!session) continue\n\n      sendTasks.push(session.sendEvent(channel, payload, {\n        createdAt,\n        eventId\n      }))\n    }\n\n    if (this.configuration) {\n      // Isolate channel subscriber failures so a buggy in-process callback\n      // cannot reject this command and crash the worker thread, but still\n      // surface the error to the framework error events so bug reporters\n      // can pick it up.\n      sendTasks.push(dispatchChannelSubscribers({channel, configuration: this.configuration, createdAt, eventId, logger: this.logger, payload}))\n    }\n\n    await Promise.all(sendTasks)\n  }\n}\n"]}