velocious 1.0.562 → 1.0.564

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

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

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

@@ -25,8 +25,8 @@ export default class VelociousHttpServerWorker {
     _debugSnapshotRequests: Map<number, {
         resolve: (snapshot: Record<string, unknown>) => void;
     }>;
-    /** @type {Map<number, Promise<void>>} */
-    _clientDeliveryQueues: Map<number, Promise<void>>;
+    /** @type {Map<number, ClientDeliveryQueue>} */
+    _clientDeliveryQueues: Map<number, ClientDeliveryQueue>;
     start(): Promise<any>;
     onStartCallback: ((value: any) => void) | null | undefined;
     _spawnWorker(): Promise<void>;
@@ -70,6 +70,7 @@ export default class VelociousHttpServerWorker {
      * @param {string} [data.filePath] - File path.
      * @param {boolean} [data.sendBody] - Whether to send the file body.
      * @param {number} [data.transferId] - File transfer id.
+     * @param {boolean} [data.websocketFrame] - Whether output is a completed WebSocket frame.
      * @param {string} [data.channel] - Channel name.
      * @param {number} [data.requestId] - Debug request id.
      * @param {Record<string, ?>} [data.snapshot] - Worker debug snapshot.
@@ -85,6 +86,7 @@ export default class VelociousHttpServerWorker {
         filePath?: string | undefined;
         sendBody?: boolean | undefined;
         transferId?: number | undefined;
+        websocketFrame?: boolean | undefined;
         channel?: string | undefined;
         requestId?: number | undefined;
         snapshot?: Record<string, any> | undefined;
@@ -94,11 +96,35 @@ export default class VelociousHttpServerWorker {
     }) => void;
     /**
      * Preserves socket output ordering for one client.
-     * @param {number} clientCount - Client count.
+     * @param {import("../server-client.js").default} client - Client instance.
+     * @param {string | Uint8Array} output - Complete output buffer.
+     * @returns {Promise<void>} - Queued delivery.
+     */
+    enqueueClientFrame(client: import("../server-client.js").default, output: string | Uint8Array): Promise<void>;
+    /**
+     * Preserves ordering for a delivery that retains no complete output frame.
+     * @param {import("../server-client.js").default} client - Client instance.
      * @param {() => Promise<void>} delivery - Delivery operation.
      * @returns {Promise<void>} - Queued delivery.
      */
-    enqueueClientDelivery(clientCount: number, delivery: () => Promise<void>): Promise<void>;
+    enqueueClientControl(client: import("../server-client.js").default, delivery: () => Promise<void>): Promise<void>;
+    /**
+     * Gets or creates one client's delivery queue.
+     * @param {import("../server-client.js").default} client - Client instance.
+     * @returns {ClientDeliveryQueue} - Client-owned delivery queue.
+     */
+    _deliveryQueueFor(client: import("../server-client.js").default): ClientDeliveryQueue;
+    /**
+     * Reports a per-client outbound queue overflow.
+     * @param {object} args - Overflow details.
+     * @param {number} args.clientCount - Affected client.
+     * @param {Error} args.error - Overflow error.
+     * @returns {void}
+     */
+    _reportOutboundQueueOverflow({ clientCount, error }: {
+        clientCount: number;
+        error: Error;
+    }): void;
     /**
      * Runs get debug snapshot.
      * @returns {Promise<Record<string, ?>>} - Worker-local debug snapshot.
@@ -142,6 +168,11 @@ export default class VelociousHttpServerWorker {
         eventId?: string | undefined;
         createdAt?: string | undefined;
     }): void;
+    /**
+     * Gets this worker's isolated V2 broadcast target.
+     * @returns {VelociousHttpServerWorker} - This worker handler.
+     */
+    websocketV2BroadcastDispatchKey(): VelociousHttpServerWorker;
     /**
      * Runs register with events host.
      * @returns {void} */
@@ -153,5 +184,6 @@ export default class VelociousHttpServerWorker {
     unregisterFromEventsHostIfNeeded(): void;
 }
 import Logger from "../../logger.js";
+import ClientDeliveryQueue from "../client-delivery-queue.js";
 import { Worker } from "worker_threads";
 //# sourceMappingURL=index.d.ts.map

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

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