velocious 1.0.514 → 1.0.516

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

@@ -76,6 +76,19 @@ export default class ServerClient {
      * @returns {Promise<void>} - Resolves when complete.
      */
     send(data: string | Uint8Array): Promise<void>;
+    /**
+     * Streams a file to the socket while respecting socket write backpressure.
+     * @param {string} filePath - File path.
+     * @param {boolean} [sendBody] - Whether to read and send the file body.
+     * @returns {Promise<"completed" | "aborted">} - Transfer result.
+     */
+    sendFile(filePath: string, sendBody?: boolean): Promise<"completed" | "aborted">;
+    /**
+     * Writes one file chunk and waits for both write acceptance and drain when required.
+     * @param {Buffer | Uint8Array} chunk - File chunk.
+     * @returns {Promise<boolean>} - Whether the chunk was accepted before the socket aborted.
+     */
+    writeFileChunk(chunk: Buffer | Uint8Array): Promise<boolean>;
     /**
      * Runs set worker.
      * @param {import("worker_threads").Worker} newWorker - New worker.

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":"AAmBA;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;;;;OAIG;IACH,qBAHW,OAAO,gBAAgB,EAAE,MAAM,GAC7B,IAAI,CAIhB;IADC,yDAAuB;CAE1B;mBApNkB,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,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"}

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

@@ -1,5 +1,6 @@
 // @ts-check
 import EventEmitter from "../utils/event-emitter.js";
+import { createReadStream } from "node:fs";
 import Logger from "../logger.js";
 /**
  * Runs summarize socket chunk.
@@ -177,6 +178,98 @@ export default class ServerClient {
             });
         });
     }
+    /**
+     * Streams a file to the socket while respecting socket write backpressure.
+     * @param {string} filePath - File path.
+     * @param {boolean} [sendBody] - Whether to read and send the file body.
+     * @returns {Promise<"completed" | "aborted">} - Transfer result.
+     */
+    async sendFile(filePath, sendBody = true) {
+        if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false)
+            return "aborted";
+        if (!sendBody)
+            return "completed";
+        const readStream = createReadStream(filePath);
+        let aborted = false;
+        const abort = () => {
+            aborted = true;
+            readStream.destroy();
+        };
+        this.socket.once("close", abort);
+        this.socket.once("error", abort);
+        try {
+            for await (const chunk of readStream) {
+                if (aborted || !await this.writeFileChunk(chunk))
+                    return "aborted";
+            }
+            return aborted ? "aborted" : "completed";
+        }
+        catch (error) {
+            this.logger.error(() => [`Socket ${this.clientCount} file response failed`, filePath, error]);
+            if (!this.socket.destroyed)
+                this.socket.destroy();
+            return "aborted";
+        }
+        finally {
+            this.socket.off("close", abort);
+            this.socket.off("error", abort);
+            readStream.destroy();
+        }
+    }
+    /**
+     * Writes one file chunk and waits for both write acceptance and drain when required.
+     * @param {Buffer | Uint8Array} chunk - File chunk.
+     * @returns {Promise<boolean>} - Whether the chunk was accepted before the socket aborted.
+     */
+    writeFileChunk(chunk) {
+        return new Promise((resolve) => {
+            let callbackCompleted = false;
+            let drained = false;
+            let settled = false;
+            const cleanup = () => {
+                this.socket.off("close", onAbort);
+                this.socket.off("error", onAbort);
+                this.socket.off("drain", onDrain);
+            };
+            const finish = (/** @type {boolean} */ result) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(result);
+            };
+            const finishIfReady = () => {
+                if (callbackCompleted && drained)
+                    finish(true);
+            };
+            const onAbort = () => finish(false);
+            const onDrain = () => {
+                drained = true;
+                finishIfReady();
+            };
+            this.socket.once("close", onAbort);
+            this.socket.once("error", onAbort);
+            this.socket.once("drain", onDrain);
+            try {
+                const accepted = this.socket.write(chunk, (error) => {
+                    if (error) {
+                        finish(false);
+                        return;
+                    }
+                    callbackCompleted = true;
+                    finishIfReady();
+                });
+                drained = accepted;
+                if (accepted)
+                    this.socket.off("drain", onDrain);
+                finishIfReady();
+            }
+            catch (error) {
+                this.logger.error(() => [`Socket ${this.clientCount} file write failed`, error]);
+                finish(false);
+            }
+        });
+    }
     /**
      * Runs set worker.
      * @param {import("worker_threads").Worker} newWorker - New worker.
@@ -186,4 +279,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 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   * 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":"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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"]}

package/build/src/http-server/websocket-channel.d.ts

@@ -17,7 +17,7 @@
 export default class VelociousWebsocketChannel {
     /**
      * Runs constructor.
-     * @param {object} args
+     * @param {object} args - Session, channel parameters, and client subscription identifier.
      * @param {string} args.subscriptionId - Client-assigned id, unique within the session.
      * @param {WebsocketParams} args.params - Subscribe params.
      * @param {import("./client/websocket-session.js").default} args.session - Owning session.
@@ -35,20 +35,20 @@ export default class VelociousWebsocketChannel {
      * Subscribe-time auth. Default is `false` (deny). Channel authors
      * MUST override to allow subscriptions. Returning a Promise defers
      * the `channel-subscribed` confirmation until it resolves.
-     * @returns {boolean | Promise<boolean>}
+     * @returns {boolean | Promise<boolean>} - Whether the subscription is authorized.
      */
     canSubscribe(): boolean | Promise<boolean>;
     /**
      * Optional — called once after `canSubscribe` resolves truthy and
      * before `channel-subscribed` is sent to the client. Use for
      * initial snapshot delivery.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after subscription setup.
      */
     subscribed(): void | Promise<void>;
     /**
      * Optional — called once when the subscription ends. Fires on
      * client-initiated `channel-unsubscribe` or on session teardown.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after subscription teardown.
      */
     unsubscribed(): void | Promise<void>;
     /**
@@ -56,13 +56,13 @@ export default class VelociousWebsocketChannel {
      * moved into the paused/grace registry. Either `onResume` fires
      * on successful client reconnect, or `unsubscribed()` fires when
      * the grace window expires.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after disconnect handling.
      */
     onDisconnect(): void | Promise<void>;
     /**
      * Called after a client reconnect + `session-resume` rebinds this
      * subscription to a new socket.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after resume handling.
      */
     onResume(): void | Promise<void>;
     /**
@@ -70,7 +70,7 @@ export default class VelociousWebsocketChannel {
      * sign-in / locale change). Override to react to session-level
      * metadata updates.
      * @param {WebsocketParams} _metadata - Updated metadata.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after metadata-change handling.
      */
     onMetadataChanged(_metadata: WebsocketParams): void | Promise<void>;
     /**
@@ -92,9 +92,9 @@ export default class VelociousWebsocketChannel {
      * Delivers a matched broadcast to this subscriber. Subclasses can
      * override when the outbound body must be tailored to subscription
      * params before sending.
-     * @param {WebsocketJsonValue} body
+     * @param {WebsocketJsonValue} body - Broadcast payload offered to this subscription.
      * @param {{eventId?: string}} [meta] - Optional event metadata.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after broadcast delivery.
      */
     deliverBroadcast(body: WebsocketJsonValue, meta?: {
         eventId?: string;
@@ -103,7 +103,7 @@ export default class VelociousWebsocketChannel {
      * Sends a `channel-message` frame to THIS subscriber only.
      * When `meta.eventId` is provided, the client receives it so it
      * can track its checkpoint for `lastEventId` replay on reconnect.
-     * @param {WebsocketJsonValue} body
+     * @param {WebsocketJsonValue} body - Channel payload to send to the subscribed client.
      * @param {{eventId?: string}} [meta] - Optional event metadata.
      * @returns {void}
      */
@@ -112,7 +112,8 @@ export default class VelociousWebsocketChannel {
     }): void;
     /**
      * Runs is closed.
-     * @returns {boolean} */
+     * @returns {boolean} - Whether the channel is closed.
+     */
     isClosed(): boolean;
 }
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"websocket-channel.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-channel.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;;;GAGG;AAEH;;;;;;;GAOG;AACH;IACE;;;;;;OAMG;IACH,iDAJG;QAAqB,cAAc,EAA3B,MAAM;QACgB,MAAM,EAA5B,eAAe;QACuC,OAAO,EAA7D,OAAO,+BAA+B,EAAE,OAAO;KACzD,EAMA;IAJC,uBAAoC;IACpC,wBAA0B;IAC1B,yDAAsB;IACtB,iBAAoB;IAGtB;;;;;OAKG;IACH,gBAFa,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAER;IAE/B;;;;;OAKG;IACH,cAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAElB;IAEf;;;;OAIG;IACH,gBAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;IAEjB;;;;;;OAMG;IACH,gBAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;IAEjB;;;;OAIG;IACH,YAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpB;IAEb;;;;;;OAMG;IACH,6BAHW,eAAe,GACb,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEF;IAE/B;;;;;;;OAOG;IACH,2BAHc,kBAAkB,EAAA,GACnB,OAAO,CAEsB;IAE1C;;;;OAIG;IACH,iBAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAED;IAE7B;;;;;;;OAOG;IACH,uBAJW,kBAAkB,SAClB;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,GAChB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhC;IAED;;;;;;;OAOG;IACH,kBAJW,kBAAkB,SAClB;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,GAChB,IAAI,CAahB;IAED;;4BAEwB;IACxB,YADa,OAAO,CACc;CACnC;;;;iCApIY,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM;;;;8BAIzC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC"}
+{"version":3,"file":"websocket-channel.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-channel.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;;;GAGG;AAEH;;;;;;;GAOG;AACH;IACE;;;;;;OAMG;IACH,iDAJG;QAAqB,cAAc,EAA3B,MAAM;QACgB,MAAM,EAA5B,eAAe;QACuC,OAAO,EAA7D,OAAO,+BAA+B,EAAE,OAAO;KACzD,EAMA;IAJC,uBAAoC;IACpC,wBAA0B;IAC1B,yDAAsB;IACtB,iBAAoB;IAGtB;;;;;OAKG;IACH,gBAFa,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAER;IAE/B;;;;;OAKG;IACH,cAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAElB;IAEf;;;;OAIG;IACH,gBAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;IAEjB;;;;;;OAMG;IACH,gBAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;IAEjB;;;;OAIG;IACH,YAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpB;IAEb;;;;;;OAMG;IACH,6BAHW,eAAe,GACb,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEF;IAE/B;;;;;;;OAOG;IACH,2BAHc,kBAAkB,EAAA,GACnB,OAAO,CAEsB;IAE1C;;;;OAIG;IACH,iBAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAED;IAE7B;;;;;;;OAOG;IACH,uBAJW,kBAAkB,SAClB;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,GAChB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhC;IAED;;;;;;;OAOG;IACH,kBAJW,kBAAkB,SAClB;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,GAChB,IAAI,CAahB;IAED;;;OAGG;IACH,YAFa,OAAO,CAEc;CACnC;;;;iCArIY,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM;;;;8BAIzC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC"}

package/build/src/http-server/websocket-channel.js

@@ -18,7 +18,7 @@
 export default class VelociousWebsocketChannel {
     /**
      * Runs constructor.
-     * @param {object} args
+     * @param {object} args - Session, channel parameters, and client subscription identifier.
      * @param {string} args.subscriptionId - Client-assigned id, unique within the session.
      * @param {WebsocketParams} args.params - Subscribe params.
      * @param {import("./client/websocket-session.js").default} args.session - Owning session.
@@ -33,20 +33,20 @@ export default class VelociousWebsocketChannel {
      * Subscribe-time auth. Default is `false` (deny). Channel authors
      * MUST override to allow subscriptions. Returning a Promise defers
      * the `channel-subscribed` confirmation until it resolves.
-     * @returns {boolean | Promise<boolean>}
+     * @returns {boolean | Promise<boolean>} - Whether the subscription is authorized.
      */
     canSubscribe() { return false; }
     /**
      * Optional — called once after `canSubscribe` resolves truthy and
      * before `channel-subscribed` is sent to the client. Use for
      * initial snapshot delivery.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after subscription setup.
      */
     subscribed() { }
     /**
      * Optional — called once when the subscription ends. Fires on
      * client-initiated `channel-unsubscribe` or on session teardown.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after subscription teardown.
      */
     unsubscribed() { }
     /**
@@ -54,13 +54,13 @@ export default class VelociousWebsocketChannel {
      * moved into the paused/grace registry. Either `onResume` fires
      * on successful client reconnect, or `unsubscribed()` fires when
      * the grace window expires.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after disconnect handling.
      */
     onDisconnect() { }
     /**
      * Called after a client reconnect + `session-resume` rebinds this
      * subscription to a new socket.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after resume handling.
      */
     onResume() { }
     /**
@@ -68,7 +68,7 @@ export default class VelociousWebsocketChannel {
      * sign-in / locale change). Override to react to session-level
      * metadata updates.
      * @param {WebsocketParams} _metadata - Updated metadata.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after metadata-change handling.
      */
     onMetadataChanged(_metadata) { }
     /**
@@ -90,9 +90,9 @@ export default class VelociousWebsocketChannel {
      * Delivers a matched broadcast to this subscriber. Subclasses can
      * override when the outbound body must be tailored to subscription
      * params before sending.
-     * @param {WebsocketJsonValue} body
+     * @param {WebsocketJsonValue} body - Broadcast payload offered to this subscription.
      * @param {{eventId?: string}} [meta] - Optional event metadata.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after broadcast delivery.
      */
     deliverBroadcast(body, meta) {
         this.sendMessage(body, meta);
@@ -101,7 +101,7 @@ export default class VelociousWebsocketChannel {
      * Sends a `channel-message` frame to THIS subscriber only.
      * When `meta.eventId` is provided, the client receives it so it
      * can track its checkpoint for `lastEventId` replay on reconnect.
-     * @param {WebsocketJsonValue} body
+     * @param {WebsocketJsonValue} body - Channel payload to send to the subscribed client.
      * @param {{eventId?: string}} [meta] - Optional event metadata.
      * @returns {void}
      */
@@ -118,7 +118,8 @@ export default class VelociousWebsocketChannel {
     }
     /**
      * Runs is closed.
-     * @returns {boolean} */
+     * @returns {boolean} - Whether the channel is closed.
+     */
     isClosed() { return this._closed; }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vic29ja2V0LWNoYW5uZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaHR0cC1zZXJ2ZXIvd2Vic29ja2V0LWNoYW5uZWwuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaOzs7R0FHRztBQUNIOzs7R0FHRztBQUVIOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsT0FBTyxPQUFPLHlCQUF5QjtJQUM1Qzs7Ozs7O09BTUc7SUFDSCxZQUFZLEVBQUMsY0FBYyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUM7UUFDM0MsSUFBSSxDQUFDLGNBQWMsR0FBRyxjQUFjLENBQUE7UUFDcEMsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLElBQUksRUFBRSxDQUFBO1FBQzFCLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFBO1FBQ3RCLElBQUksQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFBO0lBQ3RCLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILFlBQVksS0FBSyxPQUFPLEtBQUssQ0FBQSxDQUFDLENBQUM7SUFFL0I7Ozs7O09BS0c7SUFDSCxVQUFVLEtBQUksQ0FBQztJQUVmOzs7O09BSUc7SUFDSCxZQUFZLEtBQUksQ0FBQztJQUVqQjs7Ozs7O09BTUc7SUFDSCxZQUFZLEtBQUksQ0FBQztJQUVqQjs7OztPQUlHO0lBQ0gsUUFBUSxLQUFJLENBQUM7SUFFYjs7Ozs7O09BTUc7SUFDSCxpQkFBaUIsQ0FBQyxTQUFTLElBQUcsQ0FBQztJQUUvQjs7Ozs7OztPQU9HO0lBQ0gsT0FBTyxDQUFDLEdBQUcsY0FBYyxJQUFJLE9BQU8sSUFBSSxDQUFBLENBQUMsQ0FBQztJQUUxQzs7OztPQUlHO0lBQ0gsYUFBYSxLQUFLLE9BQU8sRUFBRSxDQUFBLENBQUMsQ0FBQztJQUU3Qjs7Ozs7OztPQU9HO0lBQ0gsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLElBQUk7UUFDekIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUE7SUFDOUIsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSCxXQUFXLENBQUMsSUFBSSxFQUFFLElBQUk7UUFDcEIsSUFBSSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDakIsTUFBTSxJQUFJLEtBQUssQ0FBQyw2Q0FBNkMsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDLENBQUE7UUFDckYsQ0FBQztRQUVELElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDO1lBQ3BCLElBQUksRUFBRSxpQkFBaUI7WUFDdkIsY0FBYyxFQUFFLElBQUksQ0FBQyxjQUFjO1lBQ25DLElBQUk7WUFDSixHQUFHLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU8sRUFBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7U0FDbEQsQ0FBQyxDQUFBO0lBQ0osQ0FBQztJQUVEOzs0QkFFd0I7SUFDeEIsUUFBUSxLQUFLLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQSxDQUFDLENBQUM7Q0FDbkMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcblxuLyoqXG4gKiBXZWJzb2NrZXRKc29uVmFsdWUgdHlwZS5cbiAqIEB0eXBlZGVmIHtudWxsIHwgYm9vbGVhbiB8IG51bWJlciB8IHN0cmluZyB8IG9iamVjdH0gV2Vic29ja2V0SnNvblZhbHVlXG4gKi9cbi8qKlxuICogV2Vic29ja2V0UGFyYW1zIHR5cGUuXG4gKiBAdHlwZWRlZiB7UmVjb3JkPHN0cmluZywgV2Vic29ja2V0SnNvblZhbHVlPn0gV2Vic29ja2V0UGFyYW1zXG4gKi9cblxuLyoqXG4gKiBCYXNlIGNsYXNzIGZvciBhcHAtZGVmaW5lZCAxOk4gcHViL3N1YiBjaGFubmVscy5cbiAqXG4gKiBTdWJjbGFzc2VzIG92ZXJyaWRlOlxuICogIC0gYGNhblN1YnNjcmliZSgpYCDigJQgc3Vic2NyaWJlLXRpbWUgYXV0aCAoZGVmYXVsdCBgZmFsc2VgKS5cbiAqICAtIGBzdWJzY3JpYmVkKClgIC8gYHVuc3Vic2NyaWJlZCgpYCDigJQgb3B0aW9uYWwgbGlmZWN5Y2xlIGhvb2tzLlxuICogIC0gYG1hdGNoZXMoYnJvYWRjYXN0UGFyYW1zKWAg4oCUIGJyb2FkY2FzdCByb3V0aW5nIGZpbHRlci5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgVmVsb2Npb3VzV2Vic29ja2V0Q2hhbm5lbCB7XG4gIC8qKlxuICAgKiBSdW5zIGNvbnN0cnVjdG9yLlxuICAgKiBAcGFyYW0ge29iamVjdH0gYXJnc1xuICAgKiBAcGFyYW0ge3N0cmluZ30gYXJncy5zdWJzY3JpcHRpb25JZCAtIENsaWVudC1hc3NpZ25lZCBpZCwgdW5pcXVlIHdpdGhpbiB0aGUgc2Vzc2lvbi5cbiAgICogQHBhcmFtIHtXZWJzb2NrZXRQYXJhbXN9IGFyZ3MucGFyYW1zIC0gU3Vic2NyaWJlIHBhcmFtcy5cbiAgICogQHBhcmFtIHtpbXBvcnQoXCIuL2NsaWVudC93ZWJzb2NrZXQtc2Vzc2lvbi5qc1wiKS5kZWZhdWx0fSBhcmdzLnNlc3Npb24gLSBPd25pbmcgc2Vzc2lvbi5cbiAgICovXG4gIGNvbnN0cnVjdG9yKHtzdWJzY3JpcHRpb25JZCwgcGFyYW1zLCBzZXNzaW9ufSkge1xuICAgIHRoaXMuc3Vic2NyaXB0aW9uSWQgPSBzdWJzY3JpcHRpb25JZFxuICAgIHRoaXMucGFyYW1zID0gcGFyYW1zIHx8IHt9XG4gICAgdGhpcy5zZXNzaW9uID0gc2Vzc2lvblxuICAgIHRoaXMuX2Nsb3NlZCA9IGZhbHNlXG4gIH1cblxuICAvKipcbiAgICogU3Vic2NyaWJlLXRpbWUgYXV0aC4gRGVmYXVsdCBpcyBgZmFsc2VgIChkZW55KS4gQ2hhbm5lbCBhdXRob3JzXG4gICAqIE1VU1Qgb3ZlcnJpZGUgdG8gYWxsb3cgc3Vic2NyaXB0aW9ucy4gUmV0dXJuaW5nIGEgUHJvbWlzZSBkZWZlcnNcbiAgICogdGhlIGBjaGFubmVsLXN1YnNjcmliZWRgIGNvbmZpcm1hdGlvbiB1bnRpbCBpdCByZXNvbHZlcy5cbiAgICogQHJldHVybnMge2Jvb2xlYW4gfCBQcm9taXNlPGJvb2xlYW4+fVxuICAgKi9cbiAgY2FuU3Vic2NyaWJlKCkgeyByZXR1cm4gZmFsc2UgfVxuXG4gIC8qKlxuICAgKiBPcHRpb25hbCDigJQgY2FsbGVkIG9uY2UgYWZ0ZXIgYGNhblN1YnNjcmliZWAgcmVzb2x2ZXMgdHJ1dGh5IGFuZFxuICAgKiBiZWZvcmUgYGNoYW5uZWwtc3Vic2NyaWJlZGAgaXMgc2VudCB0byB0aGUgY2xpZW50LiBVc2UgZm9yXG4gICAqIGluaXRpYWwgc25hcHNob3QgZGVsaXZlcnkuXG4gICAqIEByZXR1cm5zIHt2b2lkIHwgUHJvbWlzZTx2b2lkPn1cbiAgICovXG4gIHN1YnNjcmliZWQoKSB7fVxuXG4gIC8qKlxuICAgKiBPcHRpb25hbCDigJQgY2FsbGVkIG9uY2Ugd2hlbiB0aGUgc3Vic2NyaXB0aW9uIGVuZHMuIEZpcmVzIG9uXG4gICAqIGNsaWVudC1pbml0aWF0ZWQgYGNoYW5uZWwtdW5zdWJzY3JpYmVgIG9yIG9uIHNlc3Npb24gdGVhcmRvd24uXG4gICAqIEByZXR1cm5zIHt2b2lkIHwgUHJvbWlzZTx2b2lkPn1cbiAgICovXG4gIHVuc3Vic2NyaWJlZCgpIHt9XG5cbiAgLyoqXG4gICAqIENhbGxlZCB3aGVuIHRoZSB1bmRlcmx5aW5nIHNvY2tldCBkcm9wcyBhbmQgdGhlIHNlc3Npb24gaXNcbiAgICogbW92ZWQgaW50byB0aGUgcGF1c2VkL2dyYWNlIHJlZ2lzdHJ5LiBFaXRoZXIgYG9uUmVzdW1lYCBmaXJlc1xuICAgKiBvbiBzdWNjZXNzZnVsIGNsaWVudCByZWNvbm5lY3QsIG9yIGB1bnN1YnNjcmliZWQoKWAgZmlyZXMgd2hlblxuICAgKiB0aGUgZ3JhY2Ugd2luZG93IGV4cGlyZXMuXG4gICAqIEByZXR1cm5zIHt2b2lkIHwgUHJvbWlzZTx2b2lkPn1cbiAgICovXG4gIG9uRGlzY29ubmVjdCgpIHt9XG5cbiAgLyoqXG4gICAqIENhbGxlZCBhZnRlciBhIGNsaWVudCByZWNvbm5lY3QgKyBgc2Vzc2lvbi1yZXN1bWVgIHJlYmluZHMgdGhpc1xuICAgKiBzdWJzY3JpcHRpb24gdG8gYSBuZXcgc29ja2V0LlxuICAgKiBAcmV0dXJucyB7dm9pZCB8IFByb21pc2U8dm9pZD59XG4gICAqL1xuICBvblJlc3VtZSgpIHt9XG5cbiAgLyoqXG4gICAqIENhbGxlZCB3aGVuIHRoZSBjbGllbnQgc2VuZHMgdXBkYXRlZCBtZXRhZGF0YSAoZS5nLiBhZnRlclxuICAgKiBzaWduLWluIC8gbG9jYWxlIGNoYW5nZSkuIE92ZXJyaWRlIHRvIHJlYWN0IHRvIHNlc3Npb24tbGV2ZWxcbiAgICogbWV0YWRhdGEgdXBkYXRlcy5cbiAgICogQHBhcmFtIHtXZWJzb2NrZXRQYXJhbXN9IF9tZXRhZGF0YSAtIFVwZGF0ZWQgbWV0YWRhdGEuXG4gICAqIEByZXR1cm5zIHt2b2lkIHwgUHJvbWlzZTx2b2lkPn1cbiAgICovXG4gIG9uTWV0YWRhdGFDaGFuZ2VkKF9tZXRhZGF0YSkge31cblxuICAvKipcbiAgICogQnJvYWRjYXN0IHJvdXRpbmcgZmlsdGVyLiBDYWxsZWQgYnkgYGJyb2FkY2FzdFRvQ2hhbm5lbGAgZm9yXG4gICAqIGVhY2ggbGl2ZSBzdWJzY3JpcHRpb24g4oCUIHJldHVybmluZyB0cnVlIGRlbGl2ZXJzIHRoZSBib2R5IHZpYVxuICAgKiBgc2VuZE1lc3NhZ2VgLiBEZWZhdWx0IG1hdGNoZXMgYWxsIGJyb2FkY2FzdHMgcmVnYXJkbGVzcyBvZlxuICAgKiBwYXJhbXM7IG92ZXJyaWRlIGZvciBwZXItc3Vic2NyaWJlciBmaWx0ZXJpbmcuXG4gICAqIEBwYXJhbSB7Li4uV2Vic29ja2V0SnNvblZhbHVlfSBfYnJvYWRjYXN0QXJncyAtIFBhcmFtcyBmb3J3YXJkZWQgZnJvbSBgYnJvYWRjYXN0VG9DaGFubmVsYCAoaWdub3JlZCBieSBkZWZhdWx0KS5cbiAgICogQHJldHVybnMge2Jvb2xlYW59IC0gVHJ1ZSB0byBkZWxpdmVyIHRoZSBicm9hZGNhc3QgdG8gdGhpcyBzdWJzY3JpYmVyLlxuICAgKi9cbiAgbWF0Y2hlcyguLi5fYnJvYWRjYXN0QXJncykgeyByZXR1cm4gdHJ1ZSB9XG5cbiAgLyoqXG4gICAqIFJldHVybnMgc2FuaXRpemVkIGRpYWdub3N0aWNzIGZvciBkZWJ1ZyBzbmFwc2hvdHMuXG4gICAqIFN1YmNsYXNzZXMgY2FuIG92ZXJyaWRlIHRvIGV4cG9zZSBub24tc2Vuc2l0aXZlIHJvdXRpbmcgZGV0YWlscy5cbiAgICogQHJldHVybnMge1JlY29yZDxzdHJpbmcsID8+fSBEZWJ1Zy1zYWZlIHN1YnNjcmlwdGlvbiBkZXRhaWxzLlxuICAgKi9cbiAgZGVidWdTbmFwc2hvdCgpIHsgcmV0dXJuIHt9IH1cblxuICAvKipcbiAgICogRGVsaXZlcnMgYSBtYXRjaGVkIGJyb2FkY2FzdCB0byB0aGlzIHN1YnNjcmliZXIuIFN1YmNsYXNzZXMgY2FuXG4gICAqIG92ZXJyaWRlIHdoZW4gdGhlIG91dGJvdW5kIGJvZHkgbXVzdCBiZSB0YWlsb3JlZCB0byBzdWJzY3JpcHRpb25cbiAgICogcGFyYW1zIGJlZm9yZSBzZW5kaW5nLlxuICAgKiBAcGFyYW0ge1dlYnNvY2tldEpzb25WYWx1ZX0gYm9keVxuICAgKiBAcGFyYW0ge3tldmVudElkPzogc3RyaW5nfX0gW21ldGFdIC0gT3B0aW9uYWwgZXZlbnQgbWV0YWRhdGEuXG4gICAqIEByZXR1cm5zIHt2b2lkIHwgUHJvbWlzZTx2b2lkPn1cbiAgICovXG4gIGRlbGl2ZXJCcm9hZGNhc3QoYm9keSwgbWV0YSkge1xuICAgIHRoaXMuc2VuZE1lc3NhZ2UoYm9keSwgbWV0YSlcbiAgfVxuXG4gIC8qKlxuICAgKiBTZW5kcyBhIGBjaGFubmVsLW1lc3NhZ2VgIGZyYW1lIHRvIFRISVMgc3Vic2NyaWJlciBvbmx5LlxuICAgKiBXaGVuIGBtZXRhLmV2ZW50SWRgIGlzIHByb3ZpZGVkLCB0aGUgY2xpZW50IHJlY2VpdmVzIGl0IHNvIGl0XG4gICAqIGNhbiB0cmFjayBpdHMgY2hlY2twb2ludCBmb3IgYGxhc3RFdmVudElkYCByZXBsYXkgb24gcmVjb25uZWN0LlxuICAgKiBAcGFyYW0ge1dlYnNvY2tldEpzb25WYWx1ZX0gYm9keVxuICAgKiBAcGFyYW0ge3tldmVudElkPzogc3RyaW5nfX0gW21ldGFdIC0gT3B0aW9uYWwgZXZlbnQgbWV0YWRhdGEuXG4gICAqIEByZXR1cm5zIHt2b2lkfVxuICAgKi9cbiAgc2VuZE1lc3NhZ2UoYm9keSwgbWV0YSkge1xuICAgIGlmICh0aGlzLl9jbG9zZWQpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihgQ2Fubm90IHNlbmRNZXNzYWdlIG9uIGNsb3NlZCBzdWJzY3JpcHRpb24gJHt0aGlzLnN1YnNjcmlwdGlvbklkfWApXG4gICAgfVxuXG4gICAgdGhpcy5zZXNzaW9uLnNlbmRKc29uKHtcbiAgICAgIHR5cGU6IFwiY2hhbm5lbC1tZXNzYWdlXCIsXG4gICAgICBzdWJzY3JpcHRpb25JZDogdGhpcy5zdWJzY3JpcHRpb25JZCxcbiAgICAgIGJvZHksXG4gICAgICAuLi4obWV0YT8uZXZlbnRJZCA/IHtldmVudElkOiBtZXRhLmV2ZW50SWR9IDoge30pXG4gICAgfSlcbiAgfVxuXG4gIC8qKlxuICAgKiBSdW5zIGlzIGNsb3NlZC5cbiAgICogQHJldHVybnMge2Jvb2xlYW59ICovXG4gIGlzQ2xvc2VkKCkgeyByZXR1cm4gdGhpcy5fY2xvc2VkIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-channel.js","sourceRoot":"","sources":["../../../src/http-server/websocket-channel.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;;GAGG;AACH;;;GAGG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,OAAO,yBAAyB;IAC5C;;;;;;OAMG;IACH,YAAY,EAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAC;QAC3C,IAAI,CAAC,cAAc,GAAG,cAAc,CAAA;QACpC,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAA;QAC1B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAA;IACtB,CAAC;IAED;;;;;OAKG;IACH,YAAY,KAAK,OAAO,KAAK,CAAA,CAAC,CAAC;IAE/B;;;;;OAKG;IACH,UAAU,KAAI,CAAC;IAEf;;;;OAIG;IACH,YAAY,KAAI,CAAC;IAEjB;;;;;;OAMG;IACH,YAAY,KAAI,CAAC;IAEjB;;;;OAIG;IACH,QAAQ,KAAI,CAAC;IAEb;;;;;;OAMG;IACH,iBAAiB,CAAC,SAAS,IAAG,CAAC;IAE/B;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,cAAc,IAAI,OAAO,IAAI,CAAA,CAAC,CAAC;IAE1C;;;;OAIG;IACH,aAAa,KAAK,OAAO,EAAE,CAAA,CAAC,CAAC;IAE7B;;;;;;;OAOG;IACH,gBAAgB,CAAC,IAAI,EAAE,IAAI;QACzB,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;IAC9B,CAAC;IAED;;;;;;;OAOG;IACH,WAAW,CAAC,IAAI,EAAE,IAAI;QACpB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,6CAA6C,IAAI,CAAC,cAAc,EAAE,CAAC,CAAA;QACrF,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;YACpB,IAAI,EAAE,iBAAiB;YACvB,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,IAAI;YACJ,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC;SAClD,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,QAAQ,KAAK,OAAO,IAAI,CAAC,OAAO,CAAA,CAAC,CAAC;CACnC","sourcesContent":["// @ts-check\n\n/**\n * WebsocketJsonValue type.\n * @typedef {null | boolean | number | string | object} WebsocketJsonValue\n */\n/**\n * WebsocketParams type.\n * @typedef {Record<string, WebsocketJsonValue>} WebsocketParams\n */\n\n/**\n * Base class for app-defined 1:N pub/sub channels.\n *\n * Subclasses override:\n *  - `canSubscribe()` — subscribe-time auth (default `false`).\n *  - `subscribed()` / `unsubscribed()` — optional lifecycle hooks.\n *  - `matches(broadcastParams)` — broadcast routing filter.\n */\nexport default class VelociousWebsocketChannel {\n  /**\n   * Runs constructor.\n   * @param {object} args - Session, channel parameters, and client subscription identifier.\n   * @param {string} args.subscriptionId - Client-assigned id, unique within the session.\n   * @param {WebsocketParams} args.params - Subscribe params.\n   * @param {import(\"./client/websocket-session.js\").default} args.session - Owning session.\n   */\n  constructor({subscriptionId, params, session}) {\n    this.subscriptionId = subscriptionId\n    this.params = params || {}\n    this.session = session\n    this._closed = false\n  }\n\n  /**\n   * Subscribe-time auth. Default is `false` (deny). Channel authors\n   * MUST override to allow subscriptions. Returning a Promise defers\n   * the `channel-subscribed` confirmation until it resolves.\n   * @returns {boolean | Promise<boolean>} - Whether the subscription is authorized.\n   */\n  canSubscribe() { return false }\n\n  /**\n   * Optional — called once after `canSubscribe` resolves truthy and\n   * before `channel-subscribed` is sent to the client. Use for\n   * initial snapshot delivery.\n   * @returns {void | Promise<void>} - Completes after subscription setup.\n   */\n  subscribed() {}\n\n  /**\n   * Optional — called once when the subscription ends. Fires on\n   * client-initiated `channel-unsubscribe` or on session teardown.\n   * @returns {void | Promise<void>} - Completes after subscription teardown.\n   */\n  unsubscribed() {}\n\n  /**\n   * Called when the underlying socket drops and the session is\n   * moved into the paused/grace registry. Either `onResume` fires\n   * on successful client reconnect, or `unsubscribed()` fires when\n   * the grace window expires.\n   * @returns {void | Promise<void>} - Completes after disconnect handling.\n   */\n  onDisconnect() {}\n\n  /**\n   * Called after a client reconnect + `session-resume` rebinds this\n   * subscription to a new socket.\n   * @returns {void | Promise<void>} - Completes after resume handling.\n   */\n  onResume() {}\n\n  /**\n   * Called when the client sends updated metadata (e.g. after\n   * sign-in / locale change). Override to react to session-level\n   * metadata updates.\n   * @param {WebsocketParams} _metadata - Updated metadata.\n   * @returns {void | Promise<void>} - Completes after metadata-change handling.\n   */\n  onMetadataChanged(_metadata) {}\n\n  /**\n   * Broadcast routing filter. Called by `broadcastToChannel` for\n   * each live subscription — returning true delivers the body via\n   * `sendMessage`. Default matches all broadcasts regardless of\n   * params; override for per-subscriber filtering.\n   * @param {...WebsocketJsonValue} _broadcastArgs - Params forwarded from `broadcastToChannel` (ignored by default).\n   * @returns {boolean} - True to deliver the broadcast to this subscriber.\n   */\n  matches(..._broadcastArgs) { return true }\n\n  /**\n   * Returns sanitized diagnostics for debug snapshots.\n   * Subclasses can override to expose non-sensitive routing details.\n   * @returns {Record<string, ?>} Debug-safe subscription details.\n   */\n  debugSnapshot() { return {} }\n\n  /**\n   * Delivers a matched broadcast to this subscriber. Subclasses can\n   * override when the outbound body must be tailored to subscription\n   * params before sending.\n   * @param {WebsocketJsonValue} body - Broadcast payload offered to this subscription.\n   * @param {{eventId?: string}} [meta] - Optional event metadata.\n   * @returns {void | Promise<void>} - Completes after broadcast delivery.\n   */\n  deliverBroadcast(body, meta) {\n    this.sendMessage(body, meta)\n  }\n\n  /**\n   * Sends a `channel-message` frame to THIS subscriber only.\n   * When `meta.eventId` is provided, the client receives it so it\n   * can track its checkpoint for `lastEventId` replay on reconnect.\n   * @param {WebsocketJsonValue} body - Channel payload to send to the subscribed client.\n   * @param {{eventId?: string}} [meta] - Optional event metadata.\n   * @returns {void}\n   */\n  sendMessage(body, meta) {\n    if (this._closed) {\n      throw new Error(`Cannot sendMessage on closed subscription ${this.subscriptionId}`)\n    }\n\n    this.session.sendJson({\n      type: \"channel-message\",\n      subscriptionId: this.subscriptionId,\n      body,\n      ...(meta?.eventId ? {eventId: meta.eventId} : {})\n    })\n  }\n\n  /**\n   * Runs is closed.\n   * @returns {boolean} - Whether the channel is closed.\n   */\n  isClosed() { return this._closed }\n}\n"]}

package/build/src/http-server/websocket-connection.d.ts

@@ -10,7 +10,7 @@
 export default class VelociousWebsocketConnection {
     /**
      * Runs constructor.
-     * @param {object} args
+     * @param {object} args - Owning session, connection parameters, and client identifier.
      * @param {string} args.connectionId - Client-assigned id, unique within the session.
      * @param {Record<string, ?>} args.params - Opaque params from the `connection-open` message.
      * @param {import("./client/websocket-session.js").default} args.session - Owning session.
@@ -28,15 +28,15 @@ export default class VelociousWebsocketConnection {
      * Called once after the session registers this connection and before
      * any `onMessage` fires. Returning a Promise defers the first
      * `connection-opened` message to the client until it resolves.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after connection setup.
      */
     onConnect(): void | Promise<void>;
     /**
      * Called for each `connection-message` the client sends to this
      * specific connection. Messages arriving before `onConnect` has
      * resolved are queued and delivered in order once it finishes.
-     * @param {?} body
-     * @returns {void | Promise<void>}
+     * @param {?} body - Client-sent payload for this connection.
+     * @returns {void | Promise<void>} - Completes after message handling.
      */
     onMessage(body: unknown): void | Promise<void>;
     /**
@@ -45,13 +45,13 @@ export default class VelociousWebsocketConnection {
      * itself survives; either `onResume` fires on a successful
      * client reconnect, or `onClose("grace_expired")` fires when the
      * grace window expires.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after disconnect handling.
      */
     onDisconnect(): void | Promise<void>;
     /**
      * Called after a client reconnect + `session-resume` rebinds this
      * connection to a new socket.
-     * @returns {void | Promise<void>}
+     * @returns {void | Promise<void>} - Completes after resume handling.
      */
     onResume(): void | Promise<void>;
     /**
@@ -60,27 +60,28 @@ export default class VelociousWebsocketConnection {
      * (server-initiated `close()`), `session_destroyed` (socket dropped
      * and nothing to resume; grace path did not apply), `grace_expired`
      * (paused session's grace window ran out without resume), `error`.
-     * @param {"client_close" | "server_close" | "session_destroyed" | "grace_expired" | "error"} reason
-     * @returns {void | Promise<void>}
+     * @param {"client_close" | "server_close" | "session_destroyed" | "grace_expired" | "error"} reason - Lifecycle reason for permanent connection teardown.
+     * @returns {void | Promise<void>} - Completes after close handling.
      */
     onClose(reason: "client_close" | "server_close" | "session_destroyed" | "grace_expired" | "error"): void | Promise<void>;
     /**
      * Sends a `connection-message` frame to the client side of this
      * connection. Throws if the connection has already been closed.
-     * @param {?} body
+     * @param {?} body - Connection payload to send to the client.
      * @returns {void}
      */
     sendMessage(body: unknown): void;
     /**
      * Closes this connection from the server side. Fires `onClose`
      * locally and notifies the client with `{type: "connection-closed"}`.
-     * @param {"server_close" | "error"} [reason]
+     * @param {"server_close" | "error"} [reason] - Reason reported to the close hook and client.
      * @returns {Promise<void>}
      */
     close(reason?: "server_close" | "error"): Promise<void>;
     /**
      * Runs is closed.
-     * @returns {boolean} */
+     * @returns {boolean} - Whether the connection is closed.
+     */
     isClosed(): boolean;
 }
 //# sourceMappingURL=websocket-connection.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"websocket-connection.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-connection.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IACE;;;;;;OAMG;IACH,+CAJG;QAAqB,YAAY,EAAzB,MAAM;QACkB,MAAM,EAA9B,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACqC,OAAO,EAA7D,OAAO,+BAA+B,EAAE,OAAO;KACzD,EAMA;IAJC,qBAAgC;IAChC,4BAA0B;IAC1B,yDAAsB;IACtB,iBAAoB;IAGtB;;;;;OAKG;IACH,aAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnB;IAEd;;;;;;OAMG;IACH,gBAHW,OAAC,GACC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEJ;IAE7B;;;;;;;OAOG;IACH,gBAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;IAEjB;;;;OAIG;IACH,YAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpB;IAEb;;;;;;;;OAQG;IACH,gBAHW,cAAc,GAAG,cAAc,GAAG,mBAAmB,GAAG,eAAe,GAAG,OAAO,GAC/E,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEF;IAE/B;;;;;OAKG;IACH,kBAHW,OAAC,GACC,IAAI,CAYhB;IAED;;;;;OAKG;IACH,eAHW,cAAc,GAAG,OAAO,GACtB,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;4BAEwB;IACxB,YADa,OAAO,CAGnB;CACF"}
+{"version":3,"file":"websocket-connection.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-connection.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IACE;;;;;;OAMG;IACH,+CAJG;QAAqB,YAAY,EAAzB,MAAM;QACkB,MAAM,EAA9B,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACqC,OAAO,EAA7D,OAAO,+BAA+B,EAAE,OAAO;KACzD,EAMA;IAJC,qBAAgC;IAChC,4BAA0B;IAC1B,yDAAsB;IACtB,iBAAoB;IAGtB;;;;;OAKG;IACH,aAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnB;IAEd;;;;;;OAMG;IACH,gBAHW,OAAC,GACC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEJ;IAE7B;;;;;;;OAOG;IACH,gBAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;IAEjB;;;;OAIG;IACH,YAFa,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpB;IAEb;;;;;;;;OAQG;IACH,gBAHW,cAAc,GAAG,cAAc,GAAG,mBAAmB,GAAG,eAAe,GAAG,OAAO,GAC/E,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAEF;IAE/B;;;;;OAKG;IACH,kBAHW,OAAC,GACC,IAAI,CAYhB;IAED;;;;;OAKG;IACH,eAHW,cAAc,GAAG,OAAO,GACtB,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;CACF"}