velocious 1.0.562 → 1.0.563

package/build/src/http-server/client-delivery-queue.d.ts

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

package/build/src/http-server/client-delivery-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-delivery-queue.d.ts","sourceRoot":"","sources":["../../../src/http-server/client-delivery-queue.js"],"names":[],"mappings":"AAEA;IACE;;;;;;;;;OASG;IACH,8FAPG;QAAqB,WAAW,EAAxB,MAAM;QACO,QAAQ,EAArB,MAAM;QACO,SAAS,EAAtB,MAAM;QACO,YAAY,EAAzB,MAAM;QACO,aAAa,EAA1B,MAAM;QACO,aAAa,EAA1B,MAAM;KAChB,EAIA;CACF;AAED;;;;;;GAMG;AAEH;IACE;;;;;;;OAOG;IACH,8DALG;QAAqB,WAAW,EAAxB,MAAM;QACO,QAAQ,EAArB,MAAM;QACO,SAAS,EAAtB,MAAM;QACkD,UAAU,EAAlE,CAAC,KAAK,EAAE,gCAAgC,KAAK,IAAI;KAC3D,EAaA;IAXC,oBAA8B;IAC9B,iBAAwB;IACxB,kBAA0B;IAC1B,oBANiB,gCAAgC,KAAK,IAAI,CAM9B;IAC5B,6BAA6B;IAC7B,OADW,YAAY,EAAE,CACV;IACf,uCAAuC;IACvC,YADW,YAAY,GAAG,SAAS,CACR;IAC3B,qBAAqB;IACrB,sBAAsB;IACtB,mBAAsB;IAGxB;;;;;;OAMG;IACH,uCAJG;QAAqB,UAAU,EAAvB,MAAM;QACoB,QAAQ,EAAlC,MAAM,OAAO,CAAC,IAAI,CAAC;KAC3B,GAAU,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAED;;;;OAIG;IACH,yBAHW,MAAM,OAAO,CAAC,IAAI,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;OAGG;IACH,WAFa,IAAI,CAchB;IAED;;;OAGG;IACH,YAFa;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAC,CAIzD;IAED;;;;OAIG;IACH,eAHW,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,GAC1B,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;OAGG;IACH,UAFa,IAAI,CAahB;IAED;;;;;OAKG;IACH,cAJW,YAAY,UACZ,KAAK,GACH,IAAI,CAYhB;CACF;;;;;gBAlJa,MAAM;;;;kBACN,OAAO;;;;cACP,MAAM,OAAO,CAAC,IAAI,CAAC;;;;YACnB,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI"}

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

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

package/build/src/http-server/server-client.d.ts

@@ -28,6 +28,12 @@ export default class ServerClient {
      * @returns {Promise<void>} - Resolves when complete.
      */
     end(): Promise<void>;
+    /**
+     * Immediately destroys the socket and all transport-owned write buffers.
+     * @param {Error} error - Destruction reason.
+     * @returns {void}
+     */
+    destroy(error: Error): void;
     /**
      * On socket data.
      * @param {Buffer} chunk - Chunk.

package/build/src/http-server/server-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"AAoBA;IAGE;;;;;;OAMG;IACH,oDAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACV,MAAM,EAAjC,OAAO,KAAK,EAAE,MAAM;QACP,WAAW,EAAxB,MAAM;KAChB,EAiBA;IAzBD,mEAA2B;IAYzB,qDAAkC;IAClC,eAA8B;IAC9B,kCAAoB;IACpB,oBAA8B;IAC9B,kCAAyC;IACzC,sBAAyB;IAU3B;;;OAGG;IACH,UAFa,IAAI,CAUhB;IAED;;;OAGG;IACH,OAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;;OAIG;IACH,eAAgB,OAHL,MAGU,KAFR,IAAI,CAahB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,qBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAGD;;;;OAIG;IACH,gBAAiB,OAHN,KAGW,KAFT,IAAI,CAWhB;IAED;;;OAGG;IACH,aAFa,IAAI,CAOhB;IAED;;;;OAIG;IACH,WAHW,MAAM,GAAG,UAAU,GACjB,OAAO,CAAC,IAAI,CAAC,CAqCzB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,aACN,OAAO,GACL,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAgC5C;IAED;;;;OAIG;IACH,sBAHW,MAAM,GAAG,UAAU,GACjB,OAAO,CAAC,OAAO,CAAC,CAoD5B;IAED;;;;OAIG;IACH,qBAHW,OAAO,gBAAgB,EAAE,MAAM,GAC7B,IAAI,CAIhB;IADC,yDAAuB;CAE1B;mBAnTkB,cAAc"}
+{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"AAoBA;IAGE;;;;;;OAMG;IACH,oDAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACV,MAAM,EAAjC,OAAO,KAAK,EAAE,MAAM;QACP,WAAW,EAAxB,MAAM;KAChB,EAiBA;IAzBD,mEAA2B;IAYzB,qDAAkC;IAClC,eAA8B;IAC9B,kCAAoB;IACpB,oBAA8B;IAC9B,kCAAyC;IACzC,sBAAyB;IAU3B;;;OAGG;IACH,UAFa,IAAI,CAUhB;IAED;;;OAGG;IACH,OAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;;OAIG;IACH,eAHW,KAAK,GACH,IAAI,CAIhB;IAED;;;;OAIG;IACH,eAAgB,OAHL,MAGU,KAFR,IAAI,CAahB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,qBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAGD;;;;OAIG;IACH,gBAAiB,OAHN,KAGW,KAFT,IAAI,CAWhB;IAED;;;OAGG;IACH,aAFa,IAAI,CAOhB;IAED;;;;OAIG;IACH,WAHW,MAAM,GAAG,UAAU,GACjB,OAAO,CAAC,IAAI,CAAC,CAqCzB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,aACN,OAAO,GACL,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAgC5C;IAED;;;;OAIG;IACH,sBAHW,MAAM,GAAG,UAAU,GACjB,OAAO,CAAC,OAAO,CAAC,CAoD5B;IAED;;;;OAIG;IACH,qBAHW,OAAO,gBAAgB,EAAE,MAAM,GAC7B,IAAI,CAIhB;IADC,yDAAuB;CAE1B;mBA5TkB,cAAc"}

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

@@ -66,6 +66,15 @@ export default class ServerClient {
             this.socket.end();
         });
     }
+    /**
+     * Immediately destroys the socket and all transport-owned write buffers.
+     * @param {Error} error - Destruction reason.
+     * @returns {void}
+     */
+    destroy(error) {
+        if (!this.socket.destroyed)
+            this.socket.destroy(error);
+    }
     /**
      * On socket data.
      * @param {Buffer} chunk - Chunk.
@@ -279,4 +288,4 @@ export default class ServerClient {
         this.worker = newWorker;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-client.js","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport {createReadStream} from \"node:fs\"\nimport Logger from \"../logger.js\"\n\n/**\n * Runs summarize socket chunk.\n * @param {Buffer} chunk - Incoming socket data.\n * @returns {object} - Chunk debug metadata.\n */\nfunction summarizeSocketChunk(chunk) {\n  const preview = chunk.toString(\"latin1\", 0, Math.min(chunk.length, 160)).replaceAll(\"\\r\", \"\\\\r\").replaceAll(\"\\n\", \"\\\\n\")\n\n  return {\n    length: chunk.length,\n    preview\n  }\n}\n\nexport default class ServerClient {\n  events = new EventEmitter()\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"net\").Socket} args.socket - Socket instance.\n   * @param {number} args.clientCount - Client count.\n   */\n  constructor({configuration, socket, clientCount}) {\n    if (!configuration) throw new Error(\"No configuration given\")\n\n    this.configuration = configuration\n    this.logger = new Logger(this)\n    this.socket = socket\n    this.clientCount = clientCount\n    this.remoteAddress = socket.remoteAddress\n    this.closeEmitted = false\n\n    socket.on(\"end\", this.onSocketEnd)\n    socket.on(\"error\", this.onSocketError)\n    socket.on(\"close\", this.onSocketClose)\n    socket.on(\"timeout\", this.onSocketTimeout)\n    socket.on(\"drain\", this.onSocketDrain)\n    socket.on(\"finish\", this.onSocketFinish)\n  }\n\n  /**\n   * Runs listen.\n   * @returns {void} - No return value.\n   */\n  listen() {\n    this.logger.debug(() => [\"Socket listen\", {\n      clientCount: this.clientCount,\n      remoteAddress: this.socket.remoteAddress,\n      remoteFamily: this.socket.remoteFamily,\n      remotePort: this.socket.remotePort\n    }])\n    this.socket.on(\"data\", this.onSocketData)\n  }\n\n  /**\n   * Runs end.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  end() {\n    return new Promise((resolve) => {\n      if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) {\n        resolve(undefined)\n        return\n      }\n\n      this.socket.once(\"close\", () => resolve(undefined))\n      this.socket.end()\n    })\n  }\n\n  /**\n   * On socket data.\n   * @param {Buffer} chunk - Chunk.\n   * @returns {void} - No return value.\n   */\n  onSocketData = (chunk) => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount}: ${chunk}`)\n    this.logger.debug(() => [\"Socket data received\", {clientCount: this.clientCount, ...summarizeSocketChunk(chunk)}])\n\n    if (!this.worker) throw new Error(\"No worker\")\n\n    this.worker.postMessage({\n      command: \"clientWrite\",\n      chunk,\n      clientCount: this.clientCount\n    })\n  }\n\n  /**\n   * On socket end.\n   * @returns {void} - No return value.\n   */\n  onSocketEnd = () => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount} end`)\n    this.emitClose()\n  }\n\n  /**\n   * On socket close.\n   * @returns {void} - No return value.\n   */\n  onSocketClose = () => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount} close`)\n    this.emitClose()\n  }\n\n  /**\n   * On socket timeout.\n   * @returns {void} - No return value.\n   */\n  onSocketTimeout = () => {\n    this.logger.debug(() => [\"Socket timeout\", {clientCount: this.clientCount}])\n  }\n\n  /**\n   * On socket drain.\n   * @returns {void} - No return value.\n   */\n  onSocketDrain = () => {\n    this.logger.debug(() => [\"Socket drain\", {clientCount: this.clientCount}])\n  }\n\n  /**\n   * On socket finish.\n   * @returns {void} - No return value.\n   */\n  onSocketFinish = () => {\n    this.logger.debug(() => [\"Socket finish\", {clientCount: this.clientCount}])\n  }\n\n\n  /**\n   * On socket error.\n   * @param {Error} error - Socket error.\n   * @returns {void} - No return value.\n   */\n  onSocketError = (error) => {\n    const errorCode = /** @type {{code?: string}} */ (error).code\n\n    this.logger.error(() => [`Socket ${this.clientCount} error`, errorCode || error.message])\n    this.emitClose()\n\n    if (!this.socket.destroyed) {\n      this.socket.destroy(error)\n    }\n  }\n\n  /**\n   * Runs emit close.\n   * @returns {void} - No return value.\n   */\n  emitClose() {\n    if (this.closeEmitted) return\n\n    this.closeEmitted = true\n    this.events.emit(\"close\", this)\n  }\n\n  /**\n   * Runs send.\n   * @param {string | Uint8Array} data - Data payload.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async send(data) {\n    return new Promise((resolve) => {\n      this.logger.debugLowLevel(() => `Send ${data}`)\n      if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) {\n        this.logger.debugLowLevel(() => \"Skipping send because socket is closed\")\n        resolve()\n        return\n      }\n\n      let done = false\n\n      const finish = () => {\n        if (done) return\n\n        done = true\n        this.socket.off(\"error\", onWriteError)\n        resolve()\n      }\n      const onWriteError = (/** @type {Error} */ error) => {\n        const errorCode = /** @type {{code?: string}} */ (error).code\n\n        this.logger.error(() => [`Socket ${this.clientCount} write error`, errorCode || error.message])\n        finish()\n      }\n\n      this.socket.once(\"error\", onWriteError)\n      this.socket.write(data, (error) => {\n        if (error) {\n          onWriteError(error)\n          return\n        }\n\n        finish()\n      })\n    })\n  }\n\n  /**\n   * Streams a file to the socket while respecting socket write backpressure.\n   * @param {string} filePath - File path.\n   * @param {boolean} [sendBody] - Whether to read and send the file body.\n   * @returns {Promise<\"completed\" | \"aborted\">} - Transfer result.\n   */\n  async sendFile(filePath, sendBody = true) {\n    if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) return \"aborted\"\n    if (!sendBody) return \"completed\"\n\n    const readStream = createReadStream(filePath)\n    let aborted = false\n    const abort = () => {\n      aborted = true\n      readStream.destroy()\n    }\n\n    this.socket.once(\"close\", abort)\n    this.socket.once(\"error\", abort)\n\n    try {\n      for await (const chunk of readStream) {\n        if (aborted || !await this.writeFileChunk(chunk)) return \"aborted\"\n      }\n\n      return aborted ? \"aborted\" : \"completed\"\n    } catch (error) {\n      this.logger.error(() => [`Socket ${this.clientCount} file response failed`, filePath, error])\n      if (!this.socket.destroyed) this.socket.destroy()\n\n      return \"aborted\"\n    } finally {\n      this.socket.off(\"close\", abort)\n      this.socket.off(\"error\", abort)\n      readStream.destroy()\n    }\n  }\n\n  /**\n   * Writes one file chunk and waits for both write acceptance and drain when required.\n   * @param {Buffer | Uint8Array} chunk - File chunk.\n   * @returns {Promise<boolean>} - Whether the chunk was accepted before the socket aborted.\n   */\n  writeFileChunk(chunk) {\n    return new Promise((resolve) => {\n      let callbackCompleted = false\n      let drained = false\n      let settled = false\n\n      const cleanup = () => {\n        this.socket.off(\"close\", onAbort)\n        this.socket.off(\"error\", onAbort)\n        this.socket.off(\"drain\", onDrain)\n      }\n      const finish = (/** @type {boolean} */ result) => {\n        if (settled) return\n\n        settled = true\n        cleanup()\n        resolve(result)\n      }\n      const finishIfReady = () => {\n        if (callbackCompleted && drained) finish(true)\n      }\n      const onAbort = () => finish(false)\n      const onDrain = () => {\n        drained = true\n        finishIfReady()\n      }\n\n      this.socket.once(\"close\", onAbort)\n      this.socket.once(\"error\", onAbort)\n      this.socket.once(\"drain\", onDrain)\n\n      try {\n        const accepted = this.socket.write(chunk, (error) => {\n          if (error) {\n            finish(false)\n            return\n          }\n\n          callbackCompleted = true\n          finishIfReady()\n        })\n\n        drained = accepted\n        if (accepted) this.socket.off(\"drain\", onDrain)\n        finishIfReady()\n      } catch (error) {\n        this.logger.error(() => [`Socket ${this.clientCount} file write failed`, error])\n        finish(false)\n      }\n    })\n  }\n\n  /**\n   * Runs set worker.\n   * @param {import(\"worker_threads\").Worker} newWorker - New worker.\n   * @returns {void} - No return value.\n   */\n  setWorker(newWorker) {\n    this.worker = newWorker\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-client.js","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,YAAY,MAAM,2BAA2B,CAAA;AACpD,OAAO,EAAC,gBAAgB,EAAC,MAAM,SAAS,CAAA;AACxC,OAAO,MAAM,MAAM,cAAc,CAAA;AAEjC;;;;GAIG;AACH,SAAS,oBAAoB,CAAC,KAAK;IACjC,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAExH,OAAO;QACL,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,OAAO;KACR,CAAA;AACH,CAAC;AAED,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,MAAM,GAAG,IAAI,YAAY,EAAE,CAAA;IAE3B;;;;;;OAMG;IACH,YAAY,EAAC,aAAa,EAAE,MAAM,EAAE,WAAW,EAAC;QAC9C,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAA;QAE7D,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAA;QAC9B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;QAC9B,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAA;QACzC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAA;QAEzB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,CAAA;QAClC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAA;QACtC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAA;QACtC,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,CAAA;QAC1C,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAA;QACtC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,CAAA;IAC1C,CAAC;IAED;;;OAGG;IACH,MAAM;QACJ,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,eAAe,EAAE;gBACxC,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa;gBACxC,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY;gBACtC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;aACnC,CAAC,CAAC,CAAA;QACH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,CAAA;IAC3C,CAAC;IAED;;;OAGG;IACH,GAAG;QACD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7B,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;gBACzF,OAAO,CAAC,SAAS,CAAC,CAAA;gBAClB,OAAM;YACR,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAA;YACnD,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAA;QACnB,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,KAAK;QACX,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS;YAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IACxD,CAAC;IAED;;;;OAIG;IACH,YAAY,GAAG,CAAC,KAAK,EAAE,EAAE;QACvB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,UAAU,IAAI,CAAC,WAAW,KAAK,KAAK,EAAE,CAAC,CAAA;QACvE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,sBAAsB,EAAE,EAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,GAAG,oBAAoB,CAAC,KAAK,CAAC,EAAC,CAAC,CAAC,CAAA;QAElH,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,WAAW,CAAC,CAAA;QAE9C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;YACtB,OAAO,EAAE,aAAa;YACtB,KAAK;YACL,WAAW,EAAE,IAAI,CAAC,WAAW;SAC9B,CAAC,CAAA;IACJ,CAAC,CAAA;IAED;;;OAGG;IACH,WAAW,GAAG,GAAG,EAAE;QACjB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,UAAU,IAAI,CAAC,WAAW,MAAM,CAAC,CAAA;QACjE,IAAI,CAAC,SAAS,EAAE,CAAA;IAClB,CAAC,CAAA;IAED;;;OAGG;IACH,aAAa,GAAG,GAAG,EAAE;QACnB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,UAAU,IAAI,CAAC,WAAW,QAAQ,CAAC,CAAA;QACnE,IAAI,CAAC,SAAS,EAAE,CAAA;IAClB,CAAC,CAAA;IAED;;;OAGG;IACH,eAAe,GAAG,GAAG,EAAE;QACrB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,gBAAgB,EAAE,EAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAC,CAAC,CAAC,CAAA;IAC9E,CAAC,CAAA;IAED;;;OAGG;IACH,aAAa,GAAG,GAAG,EAAE;QACnB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,cAAc,EAAE,EAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAC,CAAC,CAAC,CAAA;IAC5E,CAAC,CAAA;IAED;;;OAGG;IACH,cAAc,GAAG,GAAG,EAAE;QACpB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,eAAe,EAAE,EAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAC,CAAC,CAAC,CAAA;IAC7E,CAAC,CAAA;IAGD;;;;OAIG;IACH,aAAa,GAAG,CAAC,KAAK,EAAE,EAAE;QACxB,MAAM,SAAS,GAAG,8BAA8B,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAA;QAE7D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC,WAAW,QAAQ,EAAE,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAA;QACzF,IAAI,CAAC,SAAS,EAAE,CAAA;QAEhB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;YAC3B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC5B,CAAC;IACH,CAAC,CAAA;IAED;;;OAGG;IACH,SAAS;QACP,IAAI,IAAI,CAAC,YAAY;YAAE,OAAM;QAE7B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAA;QACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;IACjC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI,CAAC,IAAI;QACb,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAA;YAC/C,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;gBACzF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,wCAAwC,CAAC,CAAA;gBACzE,OAAO,EAAE,CAAA;gBACT,OAAM;YACR,CAAC;YAED,IAAI,IAAI,GAAG,KAAK,CAAA;YAEhB,MAAM,MAAM,GAAG,GAAG,EAAE;gBAClB,IAAI,IAAI;oBAAE,OAAM;gBAEhB,IAAI,GAAG,IAAI,CAAA;gBACX,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,YAAY,CAAC,CAAA;gBACtC,OAAO,EAAE,CAAA;YACX,CAAC,CAAA;YACD,MAAM,YAAY,GAAG,CAAC,oBAAoB,CAAC,KAAK,EAAE,EAAE;gBAClD,MAAM,SAAS,GAAG,8BAA8B,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAA;gBAE7D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC,WAAW,cAAc,EAAE,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAA;gBAC/F,MAAM,EAAE,CAAA;YACV,CAAC,CAAA;YAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,CAAA;YACvC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE;gBAChC,IAAI,KAAK,EAAE,CAAC;oBACV,YAAY,CAAC,KAAK,CAAC,CAAA;oBACnB,OAAM;gBACR,CAAC;gBAED,MAAM,EAAE,CAAA;YACV,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;QACtC,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,KAAK;YAAE,OAAO,SAAS,CAAA;QAC1G,IAAI,CAAC,QAAQ;YAAE,OAAO,WAAW,CAAA;QAEjC,MAAM,UAAU,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAA;QAC7C,IAAI,OAAO,GAAG,KAAK,CAAA;QACnB,MAAM,KAAK,GAAG,GAAG,EAAE;YACjB,OAAO,GAAG,IAAI,CAAA;YACd,UAAU,CAAC,OAAO,EAAE,CAAA;QACtB,CAAC,CAAA;QAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QAChC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QAEhC,IAAI,CAAC;YACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;gBACrC,IAAI,OAAO,IAAI,CAAC,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;oBAAE,OAAO,SAAS,CAAA;YACpE,CAAC;YAED,OAAO,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAA;QAC1C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC,WAAW,uBAAuB,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAA;YAC7F,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS;gBAAE,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAA;YAEjD,OAAO,SAAS,CAAA;QAClB,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;YAC/B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;YAC/B,UAAU,CAAC,OAAO,EAAE,CAAA;QACtB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,KAAK;QAClB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7B,IAAI,iBAAiB,GAAG,KAAK,CAAA;YAC7B,IAAI,OAAO,GAAG,KAAK,CAAA;YACnB,IAAI,OAAO,GAAG,KAAK,CAAA;YAEnB,MAAM,OAAO,GAAG,GAAG,EAAE;gBACnB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;gBACjC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;gBACjC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;YACnC,CAAC,CAAA;YACD,MAAM,MAAM,GAAG,CAAC,sBAAsB,CAAC,MAAM,EAAE,EAAE;gBAC/C,IAAI,OAAO;oBAAE,OAAM;gBAEnB,OAAO,GAAG,IAAI,CAAA;gBACd,OAAO,EAAE,CAAA;gBACT,OAAO,CAAC,MAAM,CAAC,CAAA;YACjB,CAAC,CAAA;YACD,MAAM,aAAa,GAAG,GAAG,EAAE;gBACzB,IAAI,iBAAiB,IAAI,OAAO;oBAAE,MAAM,CAAC,IAAI,CAAC,CAAA;YAChD,CAAC,CAAA;YACD,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YACnC,MAAM,OAAO,GAAG,GAAG,EAAE;gBACnB,OAAO,GAAG,IAAI,CAAA;gBACd,aAAa,EAAE,CAAA;YACjB,CAAC,CAAA;YAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;YAClC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;YAClC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;YAElC,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;oBAClD,IAAI,KAAK,EAAE,CAAC;wBACV,MAAM,CAAC,KAAK,CAAC,CAAA;wBACb,OAAM;oBACR,CAAC;oBAED,iBAAiB,GAAG,IAAI,CAAA;oBACxB,aAAa,EAAE,CAAA;gBACjB,CAAC,CAAC,CAAA;gBAEF,OAAO,GAAG,QAAQ,CAAA;gBAClB,IAAI,QAAQ;oBAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;gBAC/C,aAAa,EAAE,CAAA;YACjB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC,WAAW,oBAAoB,EAAE,KAAK,CAAC,CAAC,CAAA;gBAChF,MAAM,CAAC,KAAK,CAAC,CAAA;YACf,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,SAAS;QACjB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAA;IACzB,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport {createReadStream} from \"node:fs\"\nimport Logger from \"../logger.js\"\n\n/**\n * Runs summarize socket chunk.\n * @param {Buffer} chunk - Incoming socket data.\n * @returns {object} - Chunk debug metadata.\n */\nfunction summarizeSocketChunk(chunk) {\n  const preview = chunk.toString(\"latin1\", 0, Math.min(chunk.length, 160)).replaceAll(\"\\r\", \"\\\\r\").replaceAll(\"\\n\", \"\\\\n\")\n\n  return {\n    length: chunk.length,\n    preview\n  }\n}\n\nexport default class ServerClient {\n  events = new EventEmitter()\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"net\").Socket} args.socket - Socket instance.\n   * @param {number} args.clientCount - Client count.\n   */\n  constructor({configuration, socket, clientCount}) {\n    if (!configuration) throw new Error(\"No configuration given\")\n\n    this.configuration = configuration\n    this.logger = new Logger(this)\n    this.socket = socket\n    this.clientCount = clientCount\n    this.remoteAddress = socket.remoteAddress\n    this.closeEmitted = false\n\n    socket.on(\"end\", this.onSocketEnd)\n    socket.on(\"error\", this.onSocketError)\n    socket.on(\"close\", this.onSocketClose)\n    socket.on(\"timeout\", this.onSocketTimeout)\n    socket.on(\"drain\", this.onSocketDrain)\n    socket.on(\"finish\", this.onSocketFinish)\n  }\n\n  /**\n   * Runs listen.\n   * @returns {void} - No return value.\n   */\n  listen() {\n    this.logger.debug(() => [\"Socket listen\", {\n      clientCount: this.clientCount,\n      remoteAddress: this.socket.remoteAddress,\n      remoteFamily: this.socket.remoteFamily,\n      remotePort: this.socket.remotePort\n    }])\n    this.socket.on(\"data\", this.onSocketData)\n  }\n\n  /**\n   * Runs end.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  end() {\n    return new Promise((resolve) => {\n      if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) {\n        resolve(undefined)\n        return\n      }\n\n      this.socket.once(\"close\", () => resolve(undefined))\n      this.socket.end()\n    })\n  }\n\n  /**\n   * Immediately destroys the socket and all transport-owned write buffers.\n   * @param {Error} error - Destruction reason.\n   * @returns {void}\n   */\n  destroy(error) {\n    if (!this.socket.destroyed) this.socket.destroy(error)\n  }\n\n  /**\n   * On socket data.\n   * @param {Buffer} chunk - Chunk.\n   * @returns {void} - No return value.\n   */\n  onSocketData = (chunk) => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount}: ${chunk}`)\n    this.logger.debug(() => [\"Socket data received\", {clientCount: this.clientCount, ...summarizeSocketChunk(chunk)}])\n\n    if (!this.worker) throw new Error(\"No worker\")\n\n    this.worker.postMessage({\n      command: \"clientWrite\",\n      chunk,\n      clientCount: this.clientCount\n    })\n  }\n\n  /**\n   * On socket end.\n   * @returns {void} - No return value.\n   */\n  onSocketEnd = () => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount} end`)\n    this.emitClose()\n  }\n\n  /**\n   * On socket close.\n   * @returns {void} - No return value.\n   */\n  onSocketClose = () => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount} close`)\n    this.emitClose()\n  }\n\n  /**\n   * On socket timeout.\n   * @returns {void} - No return value.\n   */\n  onSocketTimeout = () => {\n    this.logger.debug(() => [\"Socket timeout\", {clientCount: this.clientCount}])\n  }\n\n  /**\n   * On socket drain.\n   * @returns {void} - No return value.\n   */\n  onSocketDrain = () => {\n    this.logger.debug(() => [\"Socket drain\", {clientCount: this.clientCount}])\n  }\n\n  /**\n   * On socket finish.\n   * @returns {void} - No return value.\n   */\n  onSocketFinish = () => {\n    this.logger.debug(() => [\"Socket finish\", {clientCount: this.clientCount}])\n  }\n\n\n  /**\n   * On socket error.\n   * @param {Error} error - Socket error.\n   * @returns {void} - No return value.\n   */\n  onSocketError = (error) => {\n    const errorCode = /** @type {{code?: string}} */ (error).code\n\n    this.logger.error(() => [`Socket ${this.clientCount} error`, errorCode || error.message])\n    this.emitClose()\n\n    if (!this.socket.destroyed) {\n      this.socket.destroy(error)\n    }\n  }\n\n  /**\n   * Runs emit close.\n   * @returns {void} - No return value.\n   */\n  emitClose() {\n    if (this.closeEmitted) return\n\n    this.closeEmitted = true\n    this.events.emit(\"close\", this)\n  }\n\n  /**\n   * Runs send.\n   * @param {string | Uint8Array} data - Data payload.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async send(data) {\n    return new Promise((resolve) => {\n      this.logger.debugLowLevel(() => `Send ${data}`)\n      if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) {\n        this.logger.debugLowLevel(() => \"Skipping send because socket is closed\")\n        resolve()\n        return\n      }\n\n      let done = false\n\n      const finish = () => {\n        if (done) return\n\n        done = true\n        this.socket.off(\"error\", onWriteError)\n        resolve()\n      }\n      const onWriteError = (/** @type {Error} */ error) => {\n        const errorCode = /** @type {{code?: string}} */ (error).code\n\n        this.logger.error(() => [`Socket ${this.clientCount} write error`, errorCode || error.message])\n        finish()\n      }\n\n      this.socket.once(\"error\", onWriteError)\n      this.socket.write(data, (error) => {\n        if (error) {\n          onWriteError(error)\n          return\n        }\n\n        finish()\n      })\n    })\n  }\n\n  /**\n   * Streams a file to the socket while respecting socket write backpressure.\n   * @param {string} filePath - File path.\n   * @param {boolean} [sendBody] - Whether to read and send the file body.\n   * @returns {Promise<\"completed\" | \"aborted\">} - Transfer result.\n   */\n  async sendFile(filePath, sendBody = true) {\n    if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) return \"aborted\"\n    if (!sendBody) return \"completed\"\n\n    const readStream = createReadStream(filePath)\n    let aborted = false\n    const abort = () => {\n      aborted = true\n      readStream.destroy()\n    }\n\n    this.socket.once(\"close\", abort)\n    this.socket.once(\"error\", abort)\n\n    try {\n      for await (const chunk of readStream) {\n        if (aborted || !await this.writeFileChunk(chunk)) return \"aborted\"\n      }\n\n      return aborted ? \"aborted\" : \"completed\"\n    } catch (error) {\n      this.logger.error(() => [`Socket ${this.clientCount} file response failed`, filePath, error])\n      if (!this.socket.destroyed) this.socket.destroy()\n\n      return \"aborted\"\n    } finally {\n      this.socket.off(\"close\", abort)\n      this.socket.off(\"error\", abort)\n      readStream.destroy()\n    }\n  }\n\n  /**\n   * Writes one file chunk and waits for both write acceptance and drain when required.\n   * @param {Buffer | Uint8Array} chunk - File chunk.\n   * @returns {Promise<boolean>} - Whether the chunk was accepted before the socket aborted.\n   */\n  writeFileChunk(chunk) {\n    return new Promise((resolve) => {\n      let callbackCompleted = false\n      let drained = false\n      let settled = false\n\n      const cleanup = () => {\n        this.socket.off(\"close\", onAbort)\n        this.socket.off(\"error\", onAbort)\n        this.socket.off(\"drain\", onDrain)\n      }\n      const finish = (/** @type {boolean} */ result) => {\n        if (settled) return\n\n        settled = true\n        cleanup()\n        resolve(result)\n      }\n      const finishIfReady = () => {\n        if (callbackCompleted && drained) finish(true)\n      }\n      const onAbort = () => finish(false)\n      const onDrain = () => {\n        drained = true\n        finishIfReady()\n      }\n\n      this.socket.once(\"close\", onAbort)\n      this.socket.once(\"error\", onAbort)\n      this.socket.once(\"drain\", onDrain)\n\n      try {\n        const accepted = this.socket.write(chunk, (error) => {\n          if (error) {\n            finish(false)\n            return\n          }\n\n          callbackCompleted = true\n          finishIfReady()\n        })\n\n        drained = accepted\n        if (accepted) this.socket.off(\"drain\", onDrain)\n        finishIfReady()\n      } catch (error) {\n        this.logger.error(() => [`Socket ${this.clientCount} file write failed`, error])\n        finish(false)\n      }\n    })\n  }\n\n  /**\n   * Runs set worker.\n   * @param {import(\"worker_threads\").Worker} newWorker - New worker.\n   * @returns {void} - No return value.\n   */\n  setWorker(newWorker) {\n    this.worker = newWorker\n  }\n}\n"]}

package/build/src/http-server/websocket-events-host.d.ts

@@ -3,6 +3,10 @@ export class VelociousHttpServerWebsocketEventsHost {
      * Narrows the runtime value to the documented type.
      * @type {Set<import("./worker-handler/index.js").default>} */
     handlers: Set<import("./worker-handler/index.js").default>;
+    /**
+     * Broadcast handlers grouped by the configuration that owns them.
+     * @type {Map<import("../configuration.js").default, Set<import("./worker-handler/index.js").default>>} */
+    broadcastHandlersByConfiguration: Map<import("../configuration.js").default, Set<import("./worker-handler/index.js").default>>;
     publishQueue: Promise<void>;
     /**
      * Returns a promise that resolves when all pending publish/broadcast
@@ -34,30 +38,35 @@ 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 }: {
         channel: string;
         broadcastParams: Record<string, unknown>;
         body: unknown;
+        configuration: import("../configuration.js").default;
     }): void;
     /**
      * 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: () => Promise<void>, errorMessage: string): void;
+    _queuePublish(callback: () => Promise<void>, errorMessage: string, originatingConfiguration?: import("../configuration.js").default): void;
     /**
      * Runs persist v2 event if needed.
      * @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.
      */
-    _persistV2EventIfNeeded({ body, channel }: {
+    _persistV2EventIfNeeded({ body, channel, configuration }: {
         body: unknown;
         channel: string;
+        configuration: import("../configuration.js").default;
     }): Promise<{
         createdAt: string;
         id: string;
@@ -81,11 +90,13 @@ 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.
      */
-    _persistChannelEventIfNeeded({ channel, payload }: {
+    _persistChannelEventIfNeeded({ channel, payload, configuration }: {
         channel: string;
         payload: unknown;
+        configuration?: import("../configuration.js").default | undefined;
     }): Promise<{
         createdAt: string;
         id: string;

package/build/src/http-server/websocket-events-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-events-host.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-events-host.js"],"names":[],"mappings":"AAIA;IAEI;;kEAE8D;IAC9D,UADU,GAAG,CAAC,OAAO,2BAA2B,EAAE,OAAO,CAAC,CACjC;IACzB,4BAAqC;IAGvC;;;;;;;OAOG;IACH,0BAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,kBAHW,OAAO,2BAA2B,EAAE,OAAO,GACzC,MAAM,IAAI,CAMtB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,GAAG,MAAM,eACf,OAAC,GACC,IAAI,CAqBhB;IAED;;;;;;;;;OASG;IACH,gDALG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;KACT,GAAU,IAAI,CAoBhB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,OAAO,CAAC,IAAI,CAAC,gBACnB,MAAM,GACJ,IAAI,CAkBhB;IAED;;;;;;OAMG;IACH,2CAJG;QAAgB,IAAI,EAAZ,OAAC;QACY,OAAO,EAApB,MAAM;KACd,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAI3D;IAED;;;;;;OAMG;IACH,4CAJG;QAAqB,OAAO,EAApB,MAAM;QACE,OAAO,EAAf,OAAC;KACT,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAI3D;IAED;;;;;;OAMG;IACH,mDAJG;QAAqB,OAAO,EAApB,MAAM;QACE,OAAO,EAAf,OAAC;KACT,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAkB3D;CACF;;AAED,0EAAwE"}
+{"version":3,"file":"websocket-events-host.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-events-host.js"],"names":[],"mappings":"AAIA;IAEI;;kEAE8D;IAC9D,UADU,GAAG,CAAC,OAAO,2BAA2B,EAAE,OAAO,CAAC,CACjC;IACzB;;8GAE0G;IAC1G,kCADU,GAAG,CAAC,OAAO,qBAAqB,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,2BAA2B,EAAE,OAAO,CAAC,CAAC,CACrD;IACjD,4BAAqC;IAGvC;;;;;;;OAOG;IACH,0BAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,kBAHW,OAAO,2BAA2B,EAAE,OAAO,GACzC,MAAM,IAAI,CAqBtB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,GAAG,MAAM,eACf,OAAC,GACC,IAAI,CAqBhB;IAED;;;;;;;;;;OAUG;IACH,+DANG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;QAC2C,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC7C,GAAU,IAAI,CA0BhB;IAED;;;;;;OAMG;IACH,wBALW,MAAM,OAAO,CAAC,IAAI,CAAC,gBACnB,MAAM,6BACN,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAkBhB;IAED;;;;;;;OAOG;IACH,0DALG;QAAgB,IAAI,EAAZ,OAAC;QACY,OAAO,EAApB,MAAM;QACsC,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC7C,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAI3D;IAED;;;;;;OAMG;IACH,4CAJG;QAAqB,OAAO,EAApB,MAAM;QACE,OAAO,EAAf,OAAC;KACT,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAI3D;IAED;;;;;;;OAOG;IACH,kEALG;QAAqB,OAAO,EAApB,MAAM;QACE,OAAO,EAAf,OAAC;QAC4C,aAAa;KAClE,GAAU,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAmB3D;CACF;;AAED,0EAAwE"}