velocious 1.0.171 → 1.0.173

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

@@ -3,6 +3,7 @@ import EventEmitter from "../../utils/event-emitter.js";
 import { Logger } from "../../logger.js";
 import RequestRunner from "./request-runner.js";
 import WebsocketRequest from "./websocket-request.js";
+import WebsocketChannel from "../websocket-channel.js";
 const WEBSOCKET_FINAL_FRAME = 0x80;
 const WEBSOCKET_OPCODE_TEXT = 0x1;
 const WEBSOCKET_OPCODE_CLOSE = 0x8;
@@ -11,15 +12,18 @@ const WEBSOCKET_OPCODE_PONG = 0xA;
 export default class VelociousHttpServerClientWebsocketSession {
     events = new EventEmitter();
     subscriptions = new Set();
+    channels = new Set();
     /**
      * @param {object} args - Options object.
      * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
      * @param {import("./index.js").default} args.client - Client instance.
+     * @param {import("./request.js").default | import("./websocket-request.js").default} [args.upgradeRequest] - Initial websocket upgrade request.
      */
-    constructor({ client, configuration }) {
+    constructor({ client, configuration, upgradeRequest }) {
         this.buffer = Buffer.alloc(0);
         this.client = client;
         this.configuration = configuration;
+        this.upgradeRequest = upgradeRequest;
         this.logger = new Logger(this);
     }
     /**
@@ -30,6 +34,7 @@ export default class VelociousHttpServerClientWebsocketSession {
         this.subscriptions.add(channel);
     }
     destroy() {
+        void this._teardownChannel();
         this.events.removeAllListeners();
     }
     /**
@@ -50,13 +55,41 @@ export default class VelociousHttpServerClientWebsocketSession {
     /**
      * @param {string} channel - Channel name.
      * @param {any} payload - Payload data.
-     * @returns {void} - No return value.
+     * @returns {Promise<void>} - Resolves when complete.
      */
-    sendEvent(channel, payload) {
+    async sendEvent(channel, payload) {
         if (!this.hasSubscription(channel))
             return;
         this._sendJson({ channel, payload, type: "event" });
     }
+    /**
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async initializeChannel() {
+        const resolver = this.configuration.getWebsocketChannelResolver?.();
+        if (!resolver)
+            return;
+        try {
+            const resolved = await resolver({
+                client: this.client,
+                configuration: this.configuration,
+                request: this.upgradeRequest,
+                websocketSession: this
+            });
+            if (!resolved)
+                return;
+            const channel = typeof resolved === "function"
+                ? new resolved({ client: this.client, configuration: this.configuration, request: this.upgradeRequest, websocketSession: this })
+                : resolved;
+            if (channel && !(channel instanceof WebsocketChannel)) {
+                throw new Error("Resolved websocket channel must extend WebsocketChannel");
+            }
+            await this._registerChannel(channel);
+        }
+        catch (error) {
+            this.logger.error(() => ["Failed to initialize websocket channel", error]);
+        }
+    }
     /**
      * @param {import("./index.js").default} client - Client instance.
      * @returns {void} - No return value.
@@ -71,11 +104,16 @@ export default class VelociousHttpServerClientWebsocketSession {
      */
     async _handleMessage(message) {
         if (message.type === "subscribe") {
-            const { channel } = message;
+            const { channel, params } = message;
             if (!channel)
                 throw new Error("channel is required for subscribe");
-            this.addSubscription(channel);
-            this._sendJson({ channel, type: "subscribed" });
+            const resolver = this.configuration.getWebsocketChannelResolver?.();
+            if (resolver) {
+                await this._handleChannelSubscription({ channel, params });
+            }
+            else {
+                await this.subscribeToChannel(channel, { acknowledge: true });
+            }
             return;
         }
         if (message.type && message.type !== "request") {
@@ -157,7 +195,7 @@ export default class VelociousHttpServerClientWebsocketSession {
                 continue;
             }
             if (opcode === WEBSOCKET_OPCODE_CLOSE) {
-                this.events.emit("close");
+                this._handleClose();
                 this.sendGoodbye(this.client);
                 continue;
             }
@@ -214,6 +252,77 @@ export default class VelociousHttpServerClientWebsocketSession {
         header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT;
         this.client.events.emit("output", Buffer.concat([header, payload]));
     }
+    /**
+     * @param {string} channel - Channel name.
+     * @param {{acknowledge?: boolean}} [options] - Subscribe options.
+     * @returns {Promise<boolean>} - Whether the subscription was added.
+     */
+    async subscribeToChannel(channel, { acknowledge = true } = {}) {
+        this.addSubscription(channel);
+        if (acknowledge) {
+            this._sendJson({ channel, type: "subscribed" });
+        }
+        return true;
+    }
+    _handleClose() {
+        void this._teardownChannel();
+        this.events.emit("close");
+    }
+    async _teardownChannel() {
+        for (const channel of this.channels) {
+            await this._teardownSingleChannel(channel);
+        }
+        this.channels.clear();
+    }
+    async _teardownSingleChannel(channel) {
+        try {
+            await channel?.unsubscribed?.();
+        }
+        catch (error) {
+            this.logger.error(() => ["Failed to teardown websocket channel", error]);
+        }
+    }
+    async _registerChannel(channel) {
+        if (!channel)
+            return;
+        this.channels.add(channel);
+        await channel?.subscribed?.();
+    }
+    async _handleChannelSubscription({ channel, params }) {
+        const resolver = this.configuration.getWebsocketChannelResolver?.();
+        if (!resolver)
+            return;
+        try {
+            const resolved = await resolver({
+                client: this.client,
+                configuration: this.configuration,
+                request: this.upgradeRequest,
+                subscription: { channel, params },
+                websocketSession: this
+            });
+            if (!resolved) {
+                this._sendJson({ channel, error: "Subscription rejected", type: "error" });
+                return;
+            }
+            const channelInstance = typeof resolved === "function"
+                ? new resolved({
+                    client: this.client,
+                    configuration: this.configuration,
+                    request: this.upgradeRequest,
+                    subscriptionParams: params,
+                    websocketSession: this
+                })
+                : resolved;
+            if (channelInstance && !(channelInstance instanceof WebsocketChannel)) {
+                throw new Error("Resolved websocket channel must extend WebsocketChannel");
+            }
+            await this._registerChannel(channelInstance);
+        }
+        catch (error) {
+            this.logger.warn(() => ["Websocket channel subscription failed", error]);
+            this._sendJson({ channel, error: "Subscription rejected", type: "error" });
+        }
+    }
     /**
      * @param {Buffer} payload - Payload data.
      * @param {Buffer} mask - Mask.
@@ -228,4 +337,4 @@ export default class VelociousHttpServerClientWebsocketSession {
         return result;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-session.js","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-session.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport EventEmitter from \"../../utils/event-emitter.js\"\nimport {Logger} from \"../../logger.js\"\nimport RequestRunner from \"./request-runner.js\"\nimport WebsocketRequest from \"./websocket-request.js\"\n\nconst WEBSOCKET_FINAL_FRAME = 0x80\nconst WEBSOCKET_OPCODE_TEXT = 0x1\nconst WEBSOCKET_OPCODE_CLOSE = 0x8\nconst WEBSOCKET_OPCODE_PING = 0x9\nconst WEBSOCKET_OPCODE_PONG = 0xA\n\nexport default class VelociousHttpServerClientWebsocketSession {\n  events = new EventEmitter()\n  subscriptions = new Set()\n\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"./index.js\").default} args.client - Client instance.\n   */\n  constructor({client, configuration}) {\n    this.buffer = Buffer.alloc(0)\n    this.client = client\n    this.configuration = configuration\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {void} - No return value.\n   */\n  addSubscription(channel) {\n    this.subscriptions.add(channel)\n  }\n\n  destroy() {\n    this.events.removeAllListeners()\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {boolean} - Whether it has subscription.\n   */\n  hasSubscription(channel) {\n    return this.subscriptions.has(channel)\n  }\n\n  /**\n   * @param {Buffer} data - Data payload.\n   * @returns {void} - No return value.\n   */\n  onData(data) {\n    this.buffer = Buffer.concat([this.buffer, data])\n    this._processBuffer()\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @param {any} payload - Payload data.\n   * @returns {void} - No return value.\n   */\n  sendEvent(channel, payload) {\n    if (!this.hasSubscription(channel)) return\n\n    this._sendJson({channel, payload, type: \"event\"})\n  }\n\n  /**\n   * @param {import(\"./index.js\").default} client - Client instance.\n   * @returns {void} - No return value.\n   */\n  sendGoodbye(client) {\n    const frame = Buffer.from([WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_CLOSE, 0x00])\n\n    client.events.emit(\"output\", frame)\n  }\n\n  /**\n   * @param {object} message - Message text.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _handleMessage(message) {\n    if (message.type === \"subscribe\") {\n      const {channel} = message\n\n      if (!channel) throw new Error(\"channel is required for subscribe\")\n\n      this.addSubscription(channel)\n      this._sendJson({channel, type: \"subscribed\"})\n\n      return\n    }\n\n    if (message.type && message.type !== \"request\") {\n      this._sendJson({error: `Unknown message type: ${message.type}`, type: \"error\"})\n      return\n    }\n\n    const {body, headers, id, method, path} = message\n\n    if (!method) throw new Error(\"method is required\")\n    if (!path) throw new Error(\"path is required\")\n\n    const request = new WebsocketRequest({\n      body,\n      headers,\n      method,\n      path,\n      remoteAddress: this.client.remoteAddress\n    })\n    const requestRunner = new RequestRunner({\n      configuration: this.configuration,\n      request\n    })\n\n    requestRunner.events.on(\"done\", () => {\n      const response = requestRunner.response\n      const body = response.getBody()\n      const headers = response.headers\n\n      this._sendJson({\n        body,\n        headers,\n        id,\n        statusCode: response.getStatusCode(),\n        statusMessage: response.getStatusMessage(),\n        type: \"response\"\n      })\n    })\n\n    await requestRunner.run()\n  }\n\n  /**\n   * @returns {void} - No return value.\n   */\n  _processBuffer() {\n    while (this.buffer.length >= 2) {\n      const firstByte = this.buffer[0]\n      const secondByte = this.buffer[1]\n      const isFinal = (firstByte & WEBSOCKET_FINAL_FRAME) === WEBSOCKET_FINAL_FRAME\n      const opcode = firstByte & 0x0F\n      const isMasked = (secondByte & 0x80) === 0x80\n      let payloadLength = secondByte & 0x7F\n      let offset = 2\n\n      if (payloadLength === 126) {\n        if (this.buffer.length < offset + 2) return\n        payloadLength = this.buffer.readUInt16BE(offset)\n        offset += 2\n      } else if (payloadLength === 127) {\n        if (this.buffer.length < offset + 8) return\n        const bigLength = this.buffer.readBigUInt64BE(offset)\n\n        payloadLength = Number(bigLength)\n        offset += 8\n      }\n\n      const maskLength = isMasked ? 4 : 0\n\n      if (this.buffer.length < offset + maskLength + payloadLength) return\n\n      /** @type {Buffer} */\n      let payload = this.buffer.slice(offset + maskLength, offset + maskLength + payloadLength)\n\n      if (isMasked) {\n        const mask = this.buffer.slice(offset, offset + maskLength)\n        payload = this._unmaskPayload(payload, mask)\n      }\n\n      this.buffer = this.buffer.slice(offset + maskLength + payloadLength)\n\n      if (!isFinal) {\n        this.logger.warn(\"Fragmented frames are not supported yet\")\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_PING) {\n        this._sendControlFrame(WEBSOCKET_OPCODE_PONG, payload)\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_CLOSE) {\n        this.events.emit(\"close\")\n        this.sendGoodbye(this.client)\n        continue\n      }\n\n      if (opcode !== WEBSOCKET_OPCODE_TEXT) {\n        this.logger.warn(`Unsupported websocket opcode: ${opcode}`)\n        continue\n      }\n\n      try {\n        const message = JSON.parse(payload.toString(\"utf-8\"))\n\n        this._handleMessage(message).catch((error) => {\n          this.logger.error(() => [\"Websocket message handler failed\", error])\n          this._sendJson({error: error.message, type: \"error\"})\n        })\n      } catch (error) {\n        this.logger.error(() => [\"Failed to parse websocket message\", error])\n        this._sendJson({error: \"Invalid websocket message\", type: \"error\"})\n      }\n    }\n  }\n\n  /**\n   * @param {number} opcode - Opcode.\n   * @param {Buffer} payload - Payload data.\n   * @returns {void} - No return value.\n   */\n  _sendControlFrame(opcode, payload) {\n    const header = Buffer.alloc(2)\n\n    header[0] = WEBSOCKET_FINAL_FRAME | opcode\n    header[1] = payload.length\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {object} body - Request body.\n   * @returns {void} - No return value.\n   */\n  _sendJson(body) {\n    const json = JSON.stringify(body)\n    const payload = Buffer.from(json, \"utf-8\")\n    let header\n\n    if (payload.length < 126) {\n      header = Buffer.alloc(2)\n      header[1] = payload.length\n    } else if (payload.length < 65536) {\n      header = Buffer.alloc(4)\n      header[1] = 126\n      header.writeUInt16BE(payload.length, 2)\n    } else {\n      header = Buffer.alloc(10)\n      header[1] = 127\n      header.writeBigUInt64BE(BigInt(payload.length), 2)\n    }\n\n    header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {Buffer} payload - Payload data.\n   * @param {Buffer} mask - Mask.\n   * @returns {Buffer} - The unmask payload.\n   */\n  _unmaskPayload(payload, mask) {\n    /** @type {Buffer} */\n    const result = Buffer.alloc(payload.length)\n\n    for (let i = 0; i < payload.length; i++) {\n      result[i] = payload[i] ^ mask[i % 4]\n    }\n\n    return result\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-session.js","sourceRoot":"","sources":["../../../../src/http-server/client/websocket-session.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport EventEmitter from \"../../utils/event-emitter.js\"\nimport {Logger} from \"../../logger.js\"\nimport RequestRunner from \"./request-runner.js\"\nimport WebsocketRequest from \"./websocket-request.js\"\nimport WebsocketChannel from \"../websocket-channel.js\"\n\nconst WEBSOCKET_FINAL_FRAME = 0x80\nconst WEBSOCKET_OPCODE_TEXT = 0x1\nconst WEBSOCKET_OPCODE_CLOSE = 0x8\nconst WEBSOCKET_OPCODE_PING = 0x9\nconst WEBSOCKET_OPCODE_PONG = 0xA\n\nexport default class VelociousHttpServerClientWebsocketSession {\n  events = new EventEmitter()\n  subscriptions = new Set()\n  channels = new Set()\n\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"./index.js\").default} args.client - Client instance.\n   * @param {import(\"./request.js\").default | import(\"./websocket-request.js\").default} [args.upgradeRequest] - Initial websocket upgrade request.\n   */\n  constructor({client, configuration, upgradeRequest}) {\n    this.buffer = Buffer.alloc(0)\n    this.client = client\n    this.configuration = configuration\n    this.upgradeRequest = upgradeRequest\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {void} - No return value.\n   */\n  addSubscription(channel) {\n    this.subscriptions.add(channel)\n  }\n\n  destroy() {\n    void this._teardownChannel()\n    this.events.removeAllListeners()\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @returns {boolean} - Whether it has subscription.\n   */\n  hasSubscription(channel) {\n    return this.subscriptions.has(channel)\n  }\n\n  /**\n   * @param {Buffer} data - Data payload.\n   * @returns {void} - No return value.\n   */\n  onData(data) {\n    this.buffer = Buffer.concat([this.buffer, data])\n    this._processBuffer()\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @param {any} payload - Payload data.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async sendEvent(channel, payload) {\n    if (!this.hasSubscription(channel)) return\n\n    this._sendJson({channel, payload, type: \"event\"})\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializeChannel() {\n    const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n    if (!resolver) return\n\n    try {\n      const resolved = await resolver({\n        client: this.client,\n        configuration: this.configuration,\n        request: this.upgradeRequest,\n        websocketSession: this\n      })\n\n      if (!resolved) return\n\n      const channel = typeof resolved === \"function\"\n        ? new resolved({client: this.client, configuration: this.configuration, request: this.upgradeRequest, websocketSession: this})\n        : resolved\n\n      if (channel && !(channel instanceof WebsocketChannel)) {\n        throw new Error(\"Resolved websocket channel must extend WebsocketChannel\")\n      }\n\n      await this._registerChannel(channel)\n    } catch (error) {\n      this.logger.error(() => [\"Failed to initialize websocket channel\", error])\n    }\n  }\n\n  /**\n   * @param {import(\"./index.js\").default} client - Client instance.\n   * @returns {void} - No return value.\n   */\n  sendGoodbye(client) {\n    const frame = Buffer.from([WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_CLOSE, 0x00])\n\n    client.events.emit(\"output\", frame)\n  }\n\n  /**\n   * @param {object} message - Message text.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _handleMessage(message) {\n    if (message.type === \"subscribe\") {\n      const {channel, params} = message\n\n      if (!channel) throw new Error(\"channel is required for subscribe\")\n      const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n      if (resolver) {\n        await this._handleChannelSubscription({channel, params})\n      } else {\n        await this.subscribeToChannel(channel, {acknowledge: true})\n      }\n\n      return\n    }\n\n    if (message.type && message.type !== \"request\") {\n      this._sendJson({error: `Unknown message type: ${message.type}`, type: \"error\"})\n      return\n    }\n\n    const {body, headers, id, method, path} = message\n\n    if (!method) throw new Error(\"method is required\")\n    if (!path) throw new Error(\"path is required\")\n\n    const request = new WebsocketRequest({\n      body,\n      headers,\n      method,\n      path,\n      remoteAddress: this.client.remoteAddress\n    })\n    const requestRunner = new RequestRunner({\n      configuration: this.configuration,\n      request\n    })\n\n    requestRunner.events.on(\"done\", () => {\n      const response = requestRunner.response\n      const body = response.getBody()\n      const headers = response.headers\n\n      this._sendJson({\n        body,\n        headers,\n        id,\n        statusCode: response.getStatusCode(),\n        statusMessage: response.getStatusMessage(),\n        type: \"response\"\n      })\n    })\n\n    await requestRunner.run()\n  }\n\n  /**\n   * @returns {void} - No return value.\n   */\n  _processBuffer() {\n    while (this.buffer.length >= 2) {\n      const firstByte = this.buffer[0]\n      const secondByte = this.buffer[1]\n      const isFinal = (firstByte & WEBSOCKET_FINAL_FRAME) === WEBSOCKET_FINAL_FRAME\n      const opcode = firstByte & 0x0F\n      const isMasked = (secondByte & 0x80) === 0x80\n      let payloadLength = secondByte & 0x7F\n      let offset = 2\n\n      if (payloadLength === 126) {\n        if (this.buffer.length < offset + 2) return\n        payloadLength = this.buffer.readUInt16BE(offset)\n        offset += 2\n      } else if (payloadLength === 127) {\n        if (this.buffer.length < offset + 8) return\n        const bigLength = this.buffer.readBigUInt64BE(offset)\n\n        payloadLength = Number(bigLength)\n        offset += 8\n      }\n\n      const maskLength = isMasked ? 4 : 0\n\n      if (this.buffer.length < offset + maskLength + payloadLength) return\n\n      /** @type {Buffer} */\n      let payload = this.buffer.slice(offset + maskLength, offset + maskLength + payloadLength)\n\n      if (isMasked) {\n        const mask = this.buffer.slice(offset, offset + maskLength)\n        payload = this._unmaskPayload(payload, mask)\n      }\n\n      this.buffer = this.buffer.slice(offset + maskLength + payloadLength)\n\n      if (!isFinal) {\n        this.logger.warn(\"Fragmented frames are not supported yet\")\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_PING) {\n        this._sendControlFrame(WEBSOCKET_OPCODE_PONG, payload)\n        continue\n      }\n\n      if (opcode === WEBSOCKET_OPCODE_CLOSE) {\n        this._handleClose()\n        this.sendGoodbye(this.client)\n        continue\n      }\n\n      if (opcode !== WEBSOCKET_OPCODE_TEXT) {\n        this.logger.warn(`Unsupported websocket opcode: ${opcode}`)\n        continue\n      }\n\n      try {\n        const message = JSON.parse(payload.toString(\"utf-8\"))\n\n        this._handleMessage(message).catch((error) => {\n          this.logger.error(() => [\"Websocket message handler failed\", error])\n          this._sendJson({error: error.message, type: \"error\"})\n        })\n      } catch (error) {\n        this.logger.error(() => [\"Failed to parse websocket message\", error])\n        this._sendJson({error: \"Invalid websocket message\", type: \"error\"})\n      }\n    }\n  }\n\n  /**\n   * @param {number} opcode - Opcode.\n   * @param {Buffer} payload - Payload data.\n   * @returns {void} - No return value.\n   */\n  _sendControlFrame(opcode, payload) {\n    const header = Buffer.alloc(2)\n\n    header[0] = WEBSOCKET_FINAL_FRAME | opcode\n    header[1] = payload.length\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {object} body - Request body.\n   * @returns {void} - No return value.\n   */\n  _sendJson(body) {\n    const json = JSON.stringify(body)\n    const payload = Buffer.from(json, \"utf-8\")\n    let header\n\n    if (payload.length < 126) {\n      header = Buffer.alloc(2)\n      header[1] = payload.length\n    } else if (payload.length < 65536) {\n      header = Buffer.alloc(4)\n      header[1] = 126\n      header.writeUInt16BE(payload.length, 2)\n    } else {\n      header = Buffer.alloc(10)\n      header[1] = 127\n      header.writeBigUInt64BE(BigInt(payload.length), 2)\n    }\n\n    header[0] = WEBSOCKET_FINAL_FRAME | WEBSOCKET_OPCODE_TEXT\n\n    this.client.events.emit(\"output\", Buffer.concat([header, payload]))\n  }\n\n  /**\n   * @param {string} channel - Channel name.\n   * @param {{acknowledge?: boolean}} [options] - Subscribe options.\n   * @returns {Promise<boolean>} - Whether the subscription was added.\n   */\n  async subscribeToChannel(channel, {acknowledge = true} = {}) {\n    this.addSubscription(channel)\n    if (acknowledge) {\n      this._sendJson({channel, type: \"subscribed\"})\n    }\n    return true\n  }\n\n  _handleClose() {\n    void this._teardownChannel()\n    this.events.emit(\"close\")\n  }\n\n  async _teardownChannel() {\n    for (const channel of this.channels) {\n      await this._teardownSingleChannel(channel)\n    }\n    this.channels.clear()\n  }\n\n  async _teardownSingleChannel(channel) {\n    try {\n      await channel?.unsubscribed?.()\n    } catch (error) {\n      this.logger.error(() => [\"Failed to teardown websocket channel\", error])\n    }\n  }\n\n  async _registerChannel(channel) {\n    if (!channel) return\n\n    this.channels.add(channel)\n    await channel?.subscribed?.()\n  }\n\n  async _handleChannelSubscription({channel, params}) {\n    const resolver = this.configuration.getWebsocketChannelResolver?.()\n\n    if (!resolver) return\n\n    try {\n      const resolved = await resolver({\n        client: this.client,\n        configuration: this.configuration,\n        request: this.upgradeRequest,\n        subscription: {channel, params},\n        websocketSession: this\n      })\n\n      if (!resolved) {\n        this._sendJson({channel, error: \"Subscription rejected\", type: \"error\"})\n        return\n      }\n\n      const channelInstance = typeof resolved === \"function\"\n        ? new resolved({\n          client: this.client,\n          configuration: this.configuration,\n          request: this.upgradeRequest,\n          subscriptionParams: params,\n          websocketSession: this\n        })\n        : resolved\n\n      if (channelInstance && !(channelInstance instanceof WebsocketChannel)) {\n        throw new Error(\"Resolved websocket channel must extend WebsocketChannel\")\n      }\n\n      await this._registerChannel(channelInstance)\n    } catch (error) {\n      this.logger.warn(() => [\"Websocket channel subscription failed\", error])\n      this._sendJson({channel, error: \"Subscription rejected\", type: \"error\"})\n    }\n  }\n\n  /**\n   * @param {Buffer} payload - Payload data.\n   * @param {Buffer} mask - Mask.\n   * @returns {Buffer} - The unmask payload.\n   */\n  _unmaskPayload(payload, mask) {\n    /** @type {Buffer} */\n    const result = Buffer.alloc(payload.length)\n\n    for (let i = 0; i < payload.length; i++) {\n      result[i] = payload[i] ^ mask[i % 4]\n    }\n\n    return result\n  }\n}\n"]}

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

@@ -0,0 +1,48 @@
+export default class VelociousHttpServerWebsocketChannel {
+    /**
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {import("./client/request.js").default | import("./client/websocket-request.js").default | undefined} args.request - Request instance.
+     * @param {import("./client/index.js").default} args.client - Client instance.
+     * @param {import("./client/websocket-session.js").default} args.websocketSession - Websocket session.
+     * @param {Record<string, unknown>} [args.subscriptionParams] - Params from subscribe message.
+     */
+    constructor({ configuration, request, client, websocketSession, subscriptionParams }: {
+        configuration: import("../configuration.js").default;
+        request: import("./client/request.js").default | import("./client/websocket-request.js").default | undefined;
+        client: import("./client/index.js").default;
+        websocketSession: import("./client/websocket-session.js").default;
+        subscriptionParams?: Record<string, unknown>;
+    });
+    configuration: import("../configuration.js").default;
+    request: import("./client/websocket-request.js").default | import("./client/request.js").default;
+    client: import("./client/index.js").default;
+    websocketSession: import("./client/websocket-session.js").default;
+    subscriptionParams: Record<string, unknown>;
+    _params: Record<string, unknown>;
+    /**
+     * @returns {Record<string, unknown>} - Params for the websocket connection.
+     */
+    params(): Record<string, unknown>;
+    /**
+     * Called when the channel is created for a websocket connection.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    subscribed(): Promise<void>;
+    /**
+     * Called when the websocket disconnects.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    unsubscribed(): Promise<void>;
+    /**
+     * Subscribe this connection to a broadcast channel.
+     * @param {string} channel - Channel name.
+     * @returns {Promise<boolean>} - Whether the subscription succeeded.
+     */
+    streamFrom(channel: string): Promise<boolean>;
+    /**
+     * @returns {Record<string, unknown>} - Parsed params.
+     */
+    _buildParams(): Record<string, unknown>;
+}
+//# sourceMappingURL=websocket-channel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-channel.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-channel.js"],"names":[],"mappings":"AAEA;IACE;;;;;;;OAOG;IACH,sFANG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACqE,OAAO,EAAjH,OAAO,qBAAqB,EAAE,OAAO,GAAG,OAAO,+BAA+B,EAAE,OAAO,GAAG,SAAS;QACzD,MAAM,EAAhD,OAAO,mBAAmB,EAAE,OAAO;QACmB,gBAAgB,EAAtE,OAAO,+BAA+B,EAAE,OAAO;QAChB,kBAAkB,GAAjD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;KACjC,EAQA;IANC,qDAAkC;IAClC,iGAAsB;IACtB,4CAAoB;IACpB,kEAAwC;IACxC,4CAA4C;IAC5C,iCAAkC;IAGpC;;OAEG;IACH,UAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEJ;IAEhC;;;OAGG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAEL;IAErB;;;OAGG;IACH,gBAFa,OAAO,CAAC,IAAI,CAAC,CAEH;IAEvB;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;OAEG;IACH,gBAFa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgCnC;CACF"}

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

@@ -0,0 +1,69 @@
+// @ts-check
+export default class VelociousHttpServerWebsocketChannel {
+    /**
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {import("./client/request.js").default | import("./client/websocket-request.js").default | undefined} args.request - Request instance.
+     * @param {import("./client/index.js").default} args.client - Client instance.
+     * @param {import("./client/websocket-session.js").default} args.websocketSession - Websocket session.
+     * @param {Record<string, unknown>} [args.subscriptionParams] - Params from subscribe message.
+     */
+    constructor({ configuration, request, client, websocketSession, subscriptionParams }) {
+        this.configuration = configuration;
+        this.request = request;
+        this.client = client;
+        this.websocketSession = websocketSession;
+        this.subscriptionParams = subscriptionParams;
+        this._params = this._buildParams();
+    }
+    /**
+     * @returns {Record<string, unknown>} - Params for the websocket connection.
+     */
+    params() { return this._params; }
+    /**
+     * Called when the channel is created for a websocket connection.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async subscribed() { }
+    /**
+     * Called when the websocket disconnects.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async unsubscribed() { }
+    /**
+     * Subscribe this connection to a broadcast channel.
+     * @param {string} channel - Channel name.
+     * @returns {Promise<boolean>} - Whether the subscription succeeded.
+     */
+    async streamFrom(channel) {
+        return await this.websocketSession.subscribeToChannel(channel, { acknowledge: true });
+    }
+    /**
+     * @returns {Record<string, unknown>} - Parsed params.
+     */
+    _buildParams() {
+        /** @type {Record<string, unknown>} */
+        const params = {};
+        if (this.request?.params) {
+            const requestParams = this.request.params();
+            if (requestParams && typeof requestParams === "object") {
+                Object.assign(params, requestParams);
+            }
+        }
+        const pathValue = this.request?.path?.();
+        const query = pathValue?.split("?")[1];
+        if (query) {
+            const searchParams = new URLSearchParams(query);
+            for (const [key, value] of searchParams.entries()) {
+                if (params[key] === undefined) {
+                    params[key] = value;
+                }
+            }
+        }
+        if (this.subscriptionParams && typeof this.subscriptionParams === "object") {
+            Object.assign(params, this.subscriptionParams);
+        }
+        return params;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -51,12 +51,12 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
      * @param {object} args - Options object.
      * @param {string} args.channel - Channel name.
      * @param {any} args.payload - Payload data.
-     * @returns {void} - No return value.
+     * @returns {Promise<void>} - Resolves when complete.
      */
     broadcastWebsocketEvent({ channel, payload }: {
         channel: string;
         payload: any;
-    }): void;
+    }): Promise<void>;
 }
 import Client from "../client/index.js";
 import { Logger } from "../../logger.js";

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

@@ -1 +1 @@
-{"version":3,"file":"worker-thread.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-thread.js"],"names":[],"mappings":"AASA;IACE;;;;OAIG;IACH,wCAHG;QAAkD,UAAU,EAApD,oCAAmC;QACiC,UAAU,EAA9E;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAA;SAAC;KACvE,EAwBA;IAlBC,qCAAqC;IACrC,SADW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAChB;IAEjB,eAA8B;IAC9B,iDAA4B;IAC5B;mBAZqB,MAAM;qBAAe,MAAM;qBAAe,MAAM;MAYzC;IAC5B,oBAA8B;IAchC;;OAEG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAfC,uDAAuD;IACvD,eADW,OAAO,wBAAwB,EAAE,OAAO,CACH;IAMhD,iCAAwG;IAGxG,yBAA+F;IAOjG;;;;;;;;OAQG;IACH,YAAmB,MAPhB;QAAqB,OAAO,EAApB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACQ,aAAa,GAA3B,MAAM;QACQ,WAAW,GAAzB,MAAM;QACQ,OAAO,GAArB,MAAM;QACK,OAAO,GAAlB,GAAG;KAES,mBAyCtB;IAED;;;;;OAKG;IACH,8CAJG;QAAqB,OAAO,EAApB,MAAM;QACI,OAAO,EAAjB,GAAG;KACX,GAAU,IAAI,CAQhB;CACF;mBA/HkB,oBAAoB;uBAGlB,iBAAiB;4BACV,wBAAwB;wBAL5B,sBAAsB"}
+{"version":3,"file":"worker-thread.d.ts","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-thread.js"],"names":[],"mappings":"AASA;IACE;;;;OAIG;IACH,wCAHG;QAAkD,UAAU,EAApD,oCAAmC;QACiC,UAAU,EAA9E;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAA;SAAC;KACvE,EAwBA;IAlBC,qCAAqC;IACrC,SADW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAChB;IAEjB,eAA8B;IAC9B,iDAA4B;IAC5B;mBAZqB,MAAM;qBAAe,MAAM;qBAAe,MAAM;MAYzC;IAC5B,oBAA8B;IAchC;;OAEG;IACH,cAFa,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAfC,uDAAuD;IACvD,eADW,OAAO,wBAAwB,EAAE,OAAO,CACH;IAMhD,iCAAwG;IAGxG,yBAA+F;IAOjG;;;;;;;;OAQG;IACH,YAAmB,MAPhB;QAAqB,OAAO,EAApB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACQ,aAAa,GAA3B,MAAM;QACQ,WAAW,GAAzB,MAAM;QACQ,OAAO,GAArB,MAAM;QACK,OAAO,GAAlB,GAAG;KAES,mBAyCtB;IAED;;;;;OAKG;IACH,8CAJG;QAAqB,OAAO,EAApB,MAAM;QACI,OAAO,EAAjB,GAAG;KACX,GAAU,OAAO,CAAC,IAAI,CAAC,CAezB;CACF;mBAtIkB,oBAAoB;uBAGlB,iBAAiB;4BACV,wBAAwB;wBAL5B,sBAAsB"}

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

@@ -90,7 +90,7 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
         }
         else if (command == "websocketEvent") {
             const { channel, payload } = data;
-            this.broadcastWebsocketEvent({ channel, payload });
+            await this.broadcastWebsocketEvent({ channel, payload });
         }
         else {
             throw new Error(`Unknown command: ${command}`);
@@ -100,13 +100,18 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
      * @param {object} args - Options object.
      * @param {string} args.channel - Channel name.
      * @param {any} args.payload - Payload data.
-     * @returns {void} - No return value.
+     * @returns {Promise<void>} - Resolves when complete.
      */
-    broadcastWebsocketEvent({ channel, payload }) {
+    async broadcastWebsocketEvent({ channel, payload }) {
+        const sendTasks = [];
         for (const clientKey of Object.keys(this.clients)) {
             const client = this.clients[clientKey];
-            client.websocketSession?.sendEvent(channel, payload);
+            const session = client.websocketSession;
+            if (!session)
+                continue;
+            sendTasks.push(session.sendEvent(channel, payload));
         }
+        await Promise.all(sendTasks);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker-thread.js","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-thread.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Application from \"../../application.js\"\nimport Client from \"../client/index.js\"\nimport {digg} from \"diggerize\"\nimport errorLogger from \"../../error-logger.js\"\nimport {Logger} from \"../../logger.js\"\nimport WebsocketEvents from \"../websocket-events.js\"\n\nexport default class VelociousHttpServerWorkerHandlerWorkerThread {\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"worker_threads\").parentPort} args.parentPort - Parent port.\n   * @param {{directory: string, environment: string, workerCount: number}} args.workerData - Worker configuration details.\n   */\n  constructor({parentPort, workerData}) {\n    if (!parentPort) throw new Error(\"parentPort is required\")\n\n    const {workerCount} = workerData\n\n    /** @type {Record<number, Client>} */\n    this.clients = {}\n\n    this.logger = new Logger(this)\n    this.parentPort = parentPort\n    this.workerData = workerData\n    this.workerCount = workerCount\n\n    parentPort.on(\"message\", errorLogger(this.onCommand))\n\n    this.initialize().then(() => {\n      if (!this.application) throw new Error(\"Application not initialized\")\n\n      this.application.initialize().then(() => {\n        this.logger.debugLowLevel(() => `Worker ${workerCount} started`)\n        parentPort.postMessage({command: \"started\"})\n      })\n    })\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initialize() {\n    const {directory, environment} = this.workerData\n    const configurationPath = `${directory}/src/config/configuration.js`\n    const configurationImport = await import(configurationPath)\n\n    /** @type {import(\"../../configuration.js\").default} */\n    this.configuration = configurationImport.default\n\n    if (!this.configuration) throw new Error(`Configuration couldn't be loaded from: ${configurationPath}`)\n\n    this.configuration.setEnvironment(environment)\n    this.configuration.setCurrent()\n    this.websocketEvents = new WebsocketEvents({parentPort: this.parentPort, workerCount: this.workerCount})\n    this.configuration.setWebsocketEvents(this.websocketEvents)\n\n    this.application = new Application({configuration: this.configuration, type: \"worker-handler\"})\n\n    if (this.configuration.isInitialized()) {\n      await this.configuration.initialize({type: \"worker-handler\"})\n    }\n  }\n\n  /**\n   * @param {object} data - Data payload.\n   * @param {string} data.command - Command.\n   * @param {string} [data.chunk] - Chunk.\n   * @param {string} [data.remoteAddress] - Remote address.\n   * @param {number} [data.clientCount] - Client count.\n   * @param {string} [data.channel] - Channel name.\n   * @param {any} [data.payload] - Payload data.\n   */\n  onCommand = async (data) => {\n    await this.logger.debugLowLevel(() => [`Worker ${this.workerCount} received command`, data])\n\n    const command = data.command\n\n    if (command == \"newClient\") {\n      if (!this.configuration) throw new Error(\"Configuration not initialized\")\n\n      const {clientCount, remoteAddress} = data\n      const client = new Client({\n        clientCount,\n        configuration: this.configuration,\n        remoteAddress\n      })\n\n      client.events.on(\"output\", (output) => {\n        this.parentPort.postMessage({command: \"clientOutput\", clientCount, output})\n      })\n\n      client.events.on(\"close\", (output) => {\n        this.logger.info(\"Close received from client in worker - forwarding to worker parent\")\n        this.parentPort.postMessage({command: \"clientClose\", clientCount, output})\n      })\n\n      this.clients[clientCount] = client\n    } else if (command == \"clientWrite\") {\n      await this.logger.debugLowLevel(\"Looking up client\")\n\n      const {chunk, clientCount} = data\n      const client = digg(this.clients, clientCount)\n\n      await this.logger.debugLowLevel(`Sending to client ${clientCount}`)\n\n      client.onWrite(chunk)\n    } else if (command == \"websocketEvent\") {\n      const {channel, payload} = data\n\n      this.broadcastWebsocketEvent({channel, payload})\n    } else {\n      throw new Error(`Unknown command: ${command}`)\n    }\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {any} args.payload - Payload data.\n   * @returns {void} - No return value.\n   */\n  broadcastWebsocketEvent({channel, payload}) {\n    for (const clientKey of Object.keys(this.clients)) {\n      const client = this.clients[clientKey]\n\n      client.websocketSession?.sendEvent(channel, payload)\n    }\n  }\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker-thread.js","sourceRoot":"","sources":["../../../../src/http-server/worker-handler/worker-thread.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Application from \"../../application.js\"\nimport Client from \"../client/index.js\"\nimport {digg} from \"diggerize\"\nimport errorLogger from \"../../error-logger.js\"\nimport {Logger} from \"../../logger.js\"\nimport WebsocketEvents from \"../websocket-events.js\"\n\nexport default class VelociousHttpServerWorkerHandlerWorkerThread {\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"worker_threads\").parentPort} args.parentPort - Parent port.\n   * @param {{directory: string, environment: string, workerCount: number}} args.workerData - Worker configuration details.\n   */\n  constructor({parentPort, workerData}) {\n    if (!parentPort) throw new Error(\"parentPort is required\")\n\n    const {workerCount} = workerData\n\n    /** @type {Record<number, Client>} */\n    this.clients = {}\n\n    this.logger = new Logger(this)\n    this.parentPort = parentPort\n    this.workerData = workerData\n    this.workerCount = workerCount\n\n    parentPort.on(\"message\", errorLogger(this.onCommand))\n\n    this.initialize().then(() => {\n      if (!this.application) throw new Error(\"Application not initialized\")\n\n      this.application.initialize().then(() => {\n        this.logger.debugLowLevel(() => `Worker ${workerCount} started`)\n        parentPort.postMessage({command: \"started\"})\n      })\n    })\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initialize() {\n    const {directory, environment} = this.workerData\n    const configurationPath = `${directory}/src/config/configuration.js`\n    const configurationImport = await import(configurationPath)\n\n    /** @type {import(\"../../configuration.js\").default} */\n    this.configuration = configurationImport.default\n\n    if (!this.configuration) throw new Error(`Configuration couldn't be loaded from: ${configurationPath}`)\n\n    this.configuration.setEnvironment(environment)\n    this.configuration.setCurrent()\n    this.websocketEvents = new WebsocketEvents({parentPort: this.parentPort, workerCount: this.workerCount})\n    this.configuration.setWebsocketEvents(this.websocketEvents)\n\n    this.application = new Application({configuration: this.configuration, type: \"worker-handler\"})\n\n    if (this.configuration.isInitialized()) {\n      await this.configuration.initialize({type: \"worker-handler\"})\n    }\n  }\n\n  /**\n   * @param {object} data - Data payload.\n   * @param {string} data.command - Command.\n   * @param {string} [data.chunk] - Chunk.\n   * @param {string} [data.remoteAddress] - Remote address.\n   * @param {number} [data.clientCount] - Client count.\n   * @param {string} [data.channel] - Channel name.\n   * @param {any} [data.payload] - Payload data.\n   */\n  onCommand = async (data) => {\n    await this.logger.debugLowLevel(() => [`Worker ${this.workerCount} received command`, data])\n\n    const command = data.command\n\n    if (command == \"newClient\") {\n      if (!this.configuration) throw new Error(\"Configuration not initialized\")\n\n      const {clientCount, remoteAddress} = data\n      const client = new Client({\n        clientCount,\n        configuration: this.configuration,\n        remoteAddress\n      })\n\n      client.events.on(\"output\", (output) => {\n        this.parentPort.postMessage({command: \"clientOutput\", clientCount, output})\n      })\n\n      client.events.on(\"close\", (output) => {\n        this.logger.info(\"Close received from client in worker - forwarding to worker parent\")\n        this.parentPort.postMessage({command: \"clientClose\", clientCount, output})\n      })\n\n      this.clients[clientCount] = client\n    } else if (command == \"clientWrite\") {\n      await this.logger.debugLowLevel(\"Looking up client\")\n\n      const {chunk, clientCount} = data\n      const client = digg(this.clients, clientCount)\n\n      await this.logger.debugLowLevel(`Sending to client ${clientCount}`)\n\n      client.onWrite(chunk)\n    } else if (command == \"websocketEvent\") {\n      const {channel, payload} = data\n\n      await this.broadcastWebsocketEvent({channel, payload})\n    } else {\n      throw new Error(`Unknown command: ${command}`)\n    }\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.channel - Channel name.\n   * @param {any} args.payload - Payload data.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async broadcastWebsocketEvent({channel, payload}) {\n    const sendTasks = []\n\n    for (const clientKey of Object.keys(this.clients)) {\n      const client = this.clients[clientKey]\n      const session = client.websocketSession\n\n      if (!session) continue\n\n      sendTasks.push(session.sendEvent(channel, payload))\n    }\n\n    await Promise.all(sendTasks)\n  }\n}\n"]}

package/build/src/testing/test-files-finder.d.ts

@@ -30,11 +30,15 @@ export default class TestFilesFinder {
     fileArgs: string[];
     /** @type {string[]} */
     explicitFiles: string[];
+    /** @type {Record<string, number[]>} */
+    lineFiltersByFile: Record<string, number[]>;
     _argsPrepared: boolean;
     /**
      * @returns {Promise<string[]>} - Resolves with the test files.
      */
     findTestFiles(): Promise<string[]>;
+    /** @returns {Record<string, number[]>} - Line filters by file. */
+    getLineFiltersByFile(): Record<string, number[]>;
     /**
      * @returns {number} - The ing promises length.
      */
@@ -69,6 +73,20 @@ export default class TestFilesFinder {
      * @returns {Promise<void>} - Resolves when test args are prepared.
      */
     prepareArgs(): Promise<void>;
+    /**
+     * @param {string} filePath - File path.
+     * @param {number} line - Line number.
+     * @returns {void} - No return value.
+     */
+    addLineFilter(filePath: string, line: number): void;
+    /**
+     * @param {string} testArg - Test arg.
+     * @returns {{cleanArg: string, line?: number}} - Cleaned arg and line.
+     */
+    splitLineArg(testArg: string): {
+        cleanArg: string;
+        line?: number;
+    };
     /**
      * @param {string} localPath - Local path.
      * @returns {string} - Normalized local path with trailing slash.

package/build/src/testing/test-files-finder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-files-finder.d.ts","sourceRoot":"","sources":["../../../src/testing/test-files-finder.js"],"names":[],"mappings":"AAUA;IACE,+BAA+C;IAE/C;;;;;OAKG;IACH,kEAJG;QAAqB,SAAS,EAAtB,MAAM;QACU,WAAW,GAA3B,MAAM,EAAE;QACO,WAAW,EAA1B,MAAM,EAAE;KAClB,EA0CA;IAtCC,kBAAwC;IACxC,eAA8B;IAG5B,sBAAkE;IASpE,qBAAqB;IACrB,sBAA8B;IAE9B,uBAAuB;IACvB,YADW,MAAM,EAAE,CACC;IAEpB,4CAA4C;IAC5C,iBADW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CACf;IAEzB,uBAAuB;IACvB,UADW,MAAM,EAAE,CACuD;IAE1E,uBAAuB;IACvB,eADW,MAAM,EAAE,CACI;IAEvB,uBAAuB;IACvB,oBADW,MAAM,EAAE,CACS;IAE5B,uBAAuB;IACvB,UADW,MAAM,EAAE,CACD;IAElB,uBAAuB;IACvB,eADW,MAAM,EAAE,CACI;IAEvB,uBAA0B;IAG5B;;OAEG;IACH,iBAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CA2B7B;IAED;;OAEG;IACH,yBAFa,MAAM,CAEwD;IAE3E,wCAIC;IAED;;OAEG;IACH,mCAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;OAGG;IACH,2BAHW,MAAa,OAAO,CAAC,IAAI,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;OAIG;IACH,iCAJW,MAAM,aACN,MAAM,GACJ,OAAO,CA2BnB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,eAFa,OAAO,CAAC,IAAI,CAAC,CAqDzB;IAED;;;OAGG;IACH,+BAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,sBAHW,MAAM,GACJ,MAAM,CAKlB;CACF;uBAjRoB,cAAc"}
+{"version":3,"file":"test-files-finder.d.ts","sourceRoot":"","sources":["../../../src/testing/test-files-finder.js"],"names":[],"mappings":"AAUA;IACE,+BAA+C;IAE/C;;;;;OAKG;IACH,kEAJG;QAAqB,SAAS,EAAtB,MAAM;QACU,WAAW,GAA3B,MAAM,EAAE;QACO,WAAW,EAA1B,MAAM,EAAE;KAClB,EA6CA;IAzCC,kBAAwC;IACxC,eAA8B;IAG5B,sBAAkE;IASpE,qBAAqB;IACrB,sBAA8B;IAE9B,uBAAuB;IACvB,YADW,MAAM,EAAE,CACC;IAEpB,4CAA4C;IAC5C,iBADW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CACf;IAEzB,uBAAuB;IACvB,UADW,MAAM,EAAE,CACuD;IAE1E,uBAAuB;IACvB,eADW,MAAM,EAAE,CACI;IAEvB,uBAAuB;IACvB,oBADW,MAAM,EAAE,CACS;IAE5B,uBAAuB;IACvB,UADW,MAAM,EAAE,CACD;IAElB,uBAAuB;IACvB,eADW,MAAM,EAAE,CACI;IAEvB,uCAAuC;IACvC,mBADW,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CACR;IAE3B,uBAA0B;IAG5B;;OAEG;IACH,iBAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CA2B7B;IAED,kEAAkE;IAClE,wBADc,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CACkB;IAExD;;OAEG;IACH,yBAFa,MAAM,CAEwD;IAE3E,wCAIC;IAED;;OAEG;IACH,mCAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;OAGG;IACH,2BAHW,MAAa,OAAO,CAAC,IAAI,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;OAIG;IACH,iCAJW,MAAM,aACN,MAAM,GACJ,OAAO,CA2BnB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,eAFa,OAAO,CAAC,IAAI,CAAC,CA8DzB;IAED;;;;OAIG;IACH,wBAJW,MAAM,QACN,MAAM,GACJ,IAAI,CAYhB;IAED;;;OAGG;IACH,sBAHW,MAAM,GACJ;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,CAgB7C;IAED;;;OAGG;IACH,+BAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,sBAHW,MAAM,GACJ,MAAM,CAKlB;CACF;uBArUoB,cAAc"}