velocious 1.0.419 → 1.0.421

package/build/src/environment-handlers/node/cli/commands/server.js

@@ -65,25 +65,57 @@ export function waitForApplicationWithSignalShutdown({ application, processObjec
         application.wait().then(() => finish()).catch((error) => finish(error));
     });
 }
+/**
+ * @template T
+ * @param {...(T | undefined)} values - Candidate values in priority order.
+ * @returns {T | undefined} - First configured value.
+ */
+function firstConfiguredValue(...values) {
+    return values.find((value) => value !== undefined);
+}
+/**
+ * @param {string | number | boolean | undefined} workersArg - Worker count argument.
+ * @returns {number | undefined} - Normalized worker count.
+ */
+function httpServerWorkersFromArg(workersArg) {
+    if (workersArg === undefined)
+        return undefined;
+    if (typeof workersArg === "boolean")
+        throw new Error("--workers must be a positive integer");
+    const workers = Number(workersArg);
+    if (!Number.isInteger(workers) || workers < 1)
+        throw new Error("--workers must be a positive integer");
+    return workers;
+}
+/**
+ * @param {Record<string, string | number | boolean | undefined>} parsedProcessArgs - Parsed CLI args.
+ * @param {import("../../../../configuration-types.js").HttpServerConfiguration} [defaults] - Default HTTP server config.
+ * @returns {{host: string, port: number, workers?: number}} - HTTP server config.
+ */
+export function httpServerConfigFromParsedArgs(parsedProcessArgs = {}, defaults = {}) {
+    const host = String(firstConfiguredValue(parsedProcessArgs.h, parsedProcessArgs.host, defaults.host, "127.0.0.1"));
+    const port = Number(firstConfiguredValue(parsedProcessArgs.p, parsedProcessArgs.port, defaults.port, 3006));
+    const workers = httpServerWorkersFromArg(firstConfiguredValue(parsedProcessArgs.workers, defaults.workers));
+    if (workers === undefined)
+        return { host, port };
+    return { host, port, workers };
+}
 export default class VelociousCliCommandsServer extends BaseCommand {
     /** @returns {Promise<void>} - Starts the HTTP server and waits until it stops. */
     async execute() {
         const parsedProcessArgs = this.args?.parsedProcessArgs || {};
-        const host = String(parsedProcessArgs.h || parsedProcessArgs.host || "127.0.0.1");
-        const port = Number(parsedProcessArgs.p || parsedProcessArgs.port || 3006);
+        const configuration = this.getConfiguration();
+        const httpServer = httpServerConfigFromParsedArgs(parsedProcessArgs, configuration.httpServer);
         const application = new Application({
-            configuration: this.getConfiguration(),
-            httpServer: {
-                host,
-                port
-            },
+            configuration,
+            httpServer,
             type: "server"
         });
-        const environment = this.getConfiguration().getEnvironment();
+        const environment = configuration.getEnvironment();
         await application.initialize();
         await application.startHttpServer();
-        console.log(`Started Velocious HTTP server on ${host}:${port} in ${environment} environment`);
+        console.log(`Started Velocious HTTP server on ${httpServer.host}:${httpServer.port} in ${environment} environment`);
         await waitForApplicationWithSignalShutdown({ application });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../../../../src/environment-handlers/node/cli/commands/server.js"],"names":[],"mappings":"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","sourcesContent":["import Application from \"../../../../application.js\"\nimport BaseCommand from \"../../../../cli/base-command.js\"\n\n/**\n * @typedef {object} SignalProcess\n * @property {(event: \"SIGINT\" | \"SIGTERM\", listener: () => void) => SignalProcess} once - Register one signal listener.\n * @property {(event: \"SIGINT\" | \"SIGTERM\", listener: () => void) => SignalProcess} removeListener - Remove one signal listener.\n */\n\n/**\n * @typedef {object} SignalShutdownApplication\n * @property {() => Promise<void>} stop - Stop the application gracefully.\n * @property {() => Promise<void>} wait - Wait until the application closes.\n */\n\n/**\n * Waits for the HTTP application to close, stopping it gracefully when the\n * process receives SIGINT or SIGTERM.\n * @param {object} args - Wait options.\n * @param {SignalShutdownApplication} args.application - Running application.\n * @param {SignalProcess} [args.processObject] - Process-like signal emitter.\n * @returns {Promise<void>} - Resolves when the application has stopped.\n */\nexport function waitForApplicationWithSignalShutdown({application, processObject = process}) {\n  return new Promise((resolve, reject) => {\n    let finished = false\n    let stopping = false\n\n    /** @returns {void} - Remove installed signal handlers. */\n    const cleanup = () => {\n      processObject.removeListener(\"SIGINT\", onSignal)\n      processObject.removeListener(\"SIGTERM\", onSignal)\n    }\n\n    /**\n     * Completes the wait promise once.\n     * @param {unknown} [error] - Optional rejection reason.\n     * @returns {void}\n     */\n    const finish = (error) => {\n      if (finished) return\n\n      finished = true\n      cleanup()\n\n      if (error) {\n        reject(error)\n      } else {\n        resolve(undefined)\n      }\n    }\n\n    /** @returns {Promise<void>} - Stops the application once. */\n    const stopApplication = async () => {\n      if (stopping || finished) return\n\n      stopping = true\n\n      try {\n        await application.stop()\n      } catch (error) {\n        finish(error)\n      }\n    }\n\n    /** @returns {void} - Handles one shutdown signal. */\n    const onSignal = () => {\n      void stopApplication()\n    }\n\n    processObject.once(\"SIGINT\", onSignal)\n    processObject.once(\"SIGTERM\", onSignal)\n\n    application.wait().then(() => finish()).catch((error) => finish(error))\n  })\n}\n\n/**\n * @template T\n * @param {...(T | undefined)} values - Candidate values in priority order.\n * @returns {T | undefined} - First configured value.\n */\nfunction firstConfiguredValue(...values) {\n  return values.find((value) => value !== undefined)\n}\n\n/**\n * @param {string | number | boolean | undefined} workersArg - Worker count argument.\n * @returns {number | undefined} - Normalized worker count.\n */\nfunction httpServerWorkersFromArg(workersArg) {\n  if (workersArg === undefined) return undefined\n  if (typeof workersArg === \"boolean\") throw new Error(\"--workers must be a positive integer\")\n\n  const workers = Number(workersArg)\n\n  if (!Number.isInteger(workers) || workers < 1) throw new Error(\"--workers must be a positive integer\")\n\n  return workers\n}\n\n/**\n * @param {Record<string, string | number | boolean | undefined>} parsedProcessArgs - Parsed CLI args.\n * @param {import(\"../../../../configuration-types.js\").HttpServerConfiguration} [defaults] - Default HTTP server config.\n * @returns {{host: string, port: number, workers?: number}} - HTTP server config.\n */\nexport function httpServerConfigFromParsedArgs(parsedProcessArgs = {}, defaults = {}) {\n  const host = String(firstConfiguredValue(parsedProcessArgs.h, parsedProcessArgs.host, defaults.host, \"127.0.0.1\"))\n  const port = Number(firstConfiguredValue(parsedProcessArgs.p, parsedProcessArgs.port, defaults.port, 3006))\n  const workers = httpServerWorkersFromArg(firstConfiguredValue(parsedProcessArgs.workers, defaults.workers))\n\n  if (workers === undefined) return {host, port}\n  return {host, port, workers}\n}\n\nexport default class VelociousCliCommandsServer extends BaseCommand{\n  /** @returns {Promise<void>} - Starts the HTTP server and waits until it stops. */\n  async execute() {\n    const parsedProcessArgs = this.args?.parsedProcessArgs || {}\n    const configuration = this.getConfiguration()\n    const httpServer = httpServerConfigFromParsedArgs(parsedProcessArgs, configuration.httpServer)\n    const application = new Application({\n      configuration,\n      httpServer,\n      type: \"server\"\n    })\n    const environment = configuration.getEnvironment()\n\n    await application.initialize()\n    await application.startHttpServer()\n    console.log(`Started Velocious HTTP server on ${httpServer.host}:${httpServer.port} in ${environment} environment`)\n    await waitForApplicationWithSignalShutdown({application})\n  }\n}\n"]}

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

@@ -1,5 +1,3 @@
-/** @typedef {{start: () => Promise<void>, stop: () => Promise<void>}} DevelopmentReloaderLike */
-/** @typedef {function({configuration: import("../configuration.js").default, workerCount: number}) : (WorkerHandler | InProcessHandler)} WorkerHandlerFactory */
 export default class VelociousHttpServer {
     /**
      * @param {object} args - Options object.
@@ -8,15 +6,17 @@ export default class VelociousHttpServer {
      * @param {boolean} [args.inProcess] - Run HTTP handlers in the main thread instead of worker threads.
      * @param {number} [args.port] - Port.
      * @param {number} [args.maxWorkers] - Max workers.
+     * @param {number} [args.workers] - Worker handlers to start.
      * @param {function({configuration: import("../configuration.js").default, onReload: function({changedPath: string}) : Promise<void>}) : {start: () => Promise<void>, stop: () => Promise<void>}} [args.developmentReloaderFactory] - Development reloader factory.
      * @param {WorkerHandlerFactory} [args.workerHandlerFactory] - Worker handler factory.
      */
-    constructor({ configuration, developmentReloaderFactory, host, inProcess, maxWorkers, port, workerHandlerFactory }: {
+    constructor({ configuration, developmentReloaderFactory, host, inProcess, maxWorkers, port, workerHandlerFactory, workers }: {
         configuration: import("../configuration.js").default;
         host?: string | undefined;
         inProcess?: boolean | undefined;
         port?: number | undefined;
         maxWorkers?: number | undefined;
+        workers?: number | undefined;
         developmentReloaderFactory?: ((arg0: {
             configuration: import("../configuration.js").default;
             onReload: (arg0: {
@@ -44,6 +44,9 @@ export default class VelociousHttpServer {
     workerCount: number;
     /** @type {Array<WorkerHandler | InProcessHandler>} */
     workerHandlers: Array<WorkerHandler | InProcessHandler>;
+    nextWorkerHandlerIndex: number;
+    /** @type {Map<string, WorkerHandler | InProcessHandler>} */
+    stickyWorkerHandlers: Map<string, WorkerHandler | InProcessHandler>;
     configuration: import("../configuration.js").default;
     developmentReloaderFactory: ((arg0: {
         configuration: import("../configuration.js").default;
@@ -58,7 +61,7 @@ export default class VelociousHttpServer {
     logger: Logger;
     host: string;
     port: number;
-    maxWorkers: number;
+    workers: number;
     /** @returns {Promise<void>} - Resolves when complete.  */
     start(): Promise<void>;
     /** @returns {{developmentReloader: DevelopmentReloader | DevelopmentReloaderLike | undefined, netServer: import("net").Server | undefined, workerHandlers: Array<WorkerHandler | InProcessHandler>}} - Startup state. */
@@ -75,7 +78,7 @@ export default class VelociousHttpServer {
     /** @returns {Promise<void>} - Resolves when complete.  */
     _netServerListen(): Promise<void>;
     /** @returns {Promise<void>} - Resolves when complete.  */
-    _ensureAtLeastOneWorker(): Promise<void>;
+    _ensureWorkers(): Promise<void>;
     /** @returns {boolean} - Whether active.  */
     isActive(): boolean;
     /** @returns {Promise<void>} - Resolves when complete.  */
@@ -107,10 +110,20 @@ export default class VelociousHttpServer {
     onClientClose: (client: ServerClient) => void;
     /** @returns {Promise<void>} - Resolves when complete.  */
     spawnWorker(): Promise<void>;
+    /** @returns {Promise<Array<WorkerHandler | InProcessHandler>>} - Started worker handlers. */
+    _buildWorkerHandlers(): Promise<Array<WorkerHandler | InProcessHandler>>;
     /** @returns {Promise<WorkerHandler | InProcessHandler>} - Started worker handler. */
     _buildWorkerHandler(): Promise<WorkerHandler | InProcessHandler>;
-    /** @returns {WorkerHandler | InProcessHandler} - The worker handler to use. */
-    workerHandlerToUse(): WorkerHandler | InProcessHandler;
+    /**
+     * @param {object} [args] - Options object.
+     * @param {string} [args.stickyKey] - Stable key that must keep routing to the same worker.
+     * @returns {WorkerHandler | InProcessHandler} - The worker handler to use.
+     */
+    workerHandlerToUse({ stickyKey }?: {
+        stickyKey?: string | undefined;
+    }): WorkerHandler | InProcessHandler;
+    /** @returns {WorkerHandler | InProcessHandler} - The next round-robin worker handler. */
+    _nextRoundRobinWorkerHandler(): WorkerHandler | InProcessHandler;
     /** @returns {boolean} - Whether development worker hot reload should run. */
     shouldUseDevelopmentHotReload(): boolean;
     /** @returns {Promise<void>} - Resolves when watcher setup finishes. */

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/http-server/index.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/http-server/index.js"],"names":[],"mappings":"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"}

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

@@ -9,6 +9,19 @@ import ServerClient from "./server-client.js";
 import WorkerHandler from "./worker-handler/index.js";
 /** @typedef {{start: () => Promise<void>, stop: () => Promise<void>}} DevelopmentReloaderLike */
 /** @typedef {function({configuration: import("../configuration.js").default, workerCount: number}) : (WorkerHandler | InProcessHandler)} WorkerHandlerFactory */
+/**
+ * @param {object} args - Options object.
+ * @param {number} [args.maxWorkers] - Backward-compatible worker count alias.
+ * @param {number} [args.workers] - Configured worker count.
+ * @returns {number} - Normalized worker count.
+ */
+function normalizeWorkerCount({ maxWorkers, workers }) {
+    const workerCount = workers ?? maxWorkers ?? 1;
+    if (!Number.isInteger(workerCount) || workerCount < 1) {
+        throw new Error("HTTP server workers must be a positive integer");
+    }
+    return workerCount;
+}
 export default class VelociousHttpServer {
     clientCount = 0;
     _starting = false;
@@ -26,6 +39,9 @@ export default class VelociousHttpServer {
     workerCount = 0;
     /** @type {Array<WorkerHandler | InProcessHandler>} */
     workerHandlers = [];
+    nextWorkerHandlerIndex = 0;
+    /** @type {Map<string, WorkerHandler | InProcessHandler>} */
+    stickyWorkerHandlers = new Map();
     /**
      * @param {object} args - Options object.
      * @param {import("../configuration.js").default} args.configuration - Configuration instance.
@@ -33,10 +49,11 @@ export default class VelociousHttpServer {
      * @param {boolean} [args.inProcess] - Run HTTP handlers in the main thread instead of worker threads.
      * @param {number} [args.port] - Port.
      * @param {number} [args.maxWorkers] - Max workers.
+     * @param {number} [args.workers] - Worker handlers to start.
      * @param {function({configuration: import("../configuration.js").default, onReload: function({changedPath: string}) : Promise<void>}) : {start: () => Promise<void>, stop: () => Promise<void>}} [args.developmentReloaderFactory] - Development reloader factory.
      * @param {WorkerHandlerFactory} [args.workerHandlerFactory] - Worker handler factory.
      */
-    constructor({ configuration, developmentReloaderFactory, host, inProcess, maxWorkers, port, workerHandlerFactory }) {
+    constructor({ configuration, developmentReloaderFactory, host, inProcess, maxWorkers, port, workerHandlerFactory, workers }) {
         this.configuration = configuration;
         this.developmentReloaderFactory = developmentReloaderFactory;
         this.workerHandlerFactory = workerHandlerFactory;
@@ -44,7 +61,7 @@ export default class VelociousHttpServer {
         this.logger = new Logger(this);
         this.host = host ?? "0.0.0.0";
         this.port = port ?? 3006;
-        this.maxWorkers = maxWorkers ?? 16;
+        this.workers = normalizeWorkerCount({ maxWorkers, workers });
     }
     /** @returns {Promise<void>} - Resolves when complete.  */
     async start() {
@@ -55,7 +72,7 @@ export default class VelociousHttpServer {
         this._starting = true;
         const startupState = this._captureStartupState();
         try {
-            await this._ensureAtLeastOneWorker();
+            await this._ensureWorkers();
             await this._startDevelopmentReloader();
             /** @type {import("net").Server} */
             const netServer = new Net.Server();
@@ -99,6 +116,7 @@ export default class VelociousHttpServer {
         this.developmentReloader = startupState.developmentReloader;
         this.netServer = startupState.netServer;
         this.workerHandlers = startupState.workerHandlers;
+        this.stickyWorkerHandlers.clear();
     }
     /** @returns {Promise<void>} - Resolves when complete.  */
     _netServerListen() {
@@ -124,8 +142,8 @@ export default class VelociousHttpServer {
         });
     }
     /** @returns {Promise<void>} - Resolves when complete.  */
-    async _ensureAtLeastOneWorker() {
-        if (this.workerHandlers.length == 0) {
+    async _ensureWorkers() {
+        while (this.workerHandlers.length < this.workers) {
             await this.spawnWorker();
         }
     }
@@ -184,6 +202,7 @@ export default class VelociousHttpServer {
         const stopTasks = this.workerHandlers.map((handler) => handler.stop());
         await Promise.all(stopTasks);
         this.workerHandlers = [];
+        this.stickyWorkerHandlers.clear();
     }
     /** @returns {void} - No return value.  */
     onClose = () => {
@@ -212,7 +231,9 @@ export default class VelociousHttpServer {
             }]);
         this.clientCount++;
         try {
-            const workerHandler = this.workerHandlerToUse();
+            // Paused WebSocket sessions are worker-local, so reconnects from
+            // the same client address must return to the same worker.
+            const workerHandler = this.workerHandlerToUse({ stickyKey: socket.remoteAddress });
             const client = new ServerClient({
                 clientCount,
                 configuration: this.configuration,
@@ -246,6 +267,15 @@ export default class VelociousHttpServer {
         const workerHandler = await this._buildWorkerHandler();
         this.workerHandlers.push(workerHandler);
     }
+    /** @returns {Promise<Array<WorkerHandler | InProcessHandler>>} - Started worker handlers. */
+    async _buildWorkerHandlers() {
+        /** @type {Array<WorkerHandler | InProcessHandler>} */
+        const workerHandlers = [];
+        for (let index = 0; index < this.workers; index += 1) {
+            workerHandlers.push(await this._buildWorkerHandler());
+        }
+        return workerHandlers;
+    }
     /** @returns {Promise<WorkerHandler | InProcessHandler>} - Started worker handler. */
     async _buildWorkerHandler() {
         const workerCount = this.workerCount;
@@ -260,14 +290,32 @@ export default class VelociousHttpServer {
         await workerHandler.start();
         return workerHandler;
     }
-    /** @returns {WorkerHandler | InProcessHandler} - The worker handler to use. */
-    workerHandlerToUse() {
+    /**
+     * @param {object} [args] - Options object.
+     * @param {string} [args.stickyKey] - Stable key that must keep routing to the same worker.
+     * @returns {WorkerHandler | InProcessHandler} - The worker handler to use.
+     */
+    workerHandlerToUse({ stickyKey } = {}) {
+        if (stickyKey) {
+            const stickyWorkerHandler = this.stickyWorkerHandlers.get(stickyKey);
+            if (stickyWorkerHandler && this.workerHandlers.includes(stickyWorkerHandler)) {
+                return stickyWorkerHandler;
+            }
+            const workerHandler = this._nextRoundRobinWorkerHandler();
+            this.stickyWorkerHandlers.set(stickyKey, workerHandler);
+            return workerHandler;
+        }
+        return this._nextRoundRobinWorkerHandler();
+    }
+    /** @returns {WorkerHandler | InProcessHandler} - The next round-robin worker handler. */
+    _nextRoundRobinWorkerHandler() {
         this.logger.debug(`Worker handlers length: ${this.workerHandlers.length}`);
-        const randomWorkerNumber = Math.floor(Math.random() * this.workerHandlers.length);
-        const workerHandler = this.workerHandlers[randomWorkerNumber];
+        const workerHandlerIndex = this.nextWorkerHandlerIndex % this.workerHandlers.length;
+        const workerHandler = this.workerHandlers[workerHandlerIndex];
         if (!workerHandler) {
-            throw new Error(`No workerHandler by that number: ${randomWorkerNumber}`);
+            throw new Error(`No workerHandler by that number: ${workerHandlerIndex}`);
         }
+        this.nextWorkerHandlerIndex += 1;
         return workerHandler;
     }
     /** @returns {boolean} - Whether development worker hot reload should run. */
@@ -304,8 +352,10 @@ export default class VelociousHttpServer {
             do {
                 this._reloadWorkersForDevelopmentQueued = false;
                 const oldWorkerHandlers = [...this.workerHandlers];
-                const newWorkerHandler = await this._buildWorkerHandler();
-                this.workerHandlers = [newWorkerHandler];
+                const newWorkerHandlers = await this._buildWorkerHandlers();
+                this.workerHandlers = newWorkerHandlers;
+                this.nextWorkerHandlerIndex = 0;
+                this.stickyWorkerHandlers.clear();
                 await Promise.all(oldWorkerHandlers.map((workerHandler) => workerHandler.stop()));
             } while (this._reloadWorkersForDevelopmentQueued && !this._stopping);
         }
@@ -314,4 +364,4 @@ export default class VelociousHttpServer {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/http-server/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\nimport DevelopmentReloader from \"./development-reloader.js\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport InProcessHandler from \"./worker-handler/in-process.js\"\nimport Logger from \"../logger.js\"\nimport Net from \"net\"\nimport ServerClient from \"./server-client.js\"\nimport WorkerHandler from \"./worker-handler/index.js\"\n\n/** @typedef {{start: () => Promise<void>, stop: () => Promise<void>}} DevelopmentReloaderLike */\n/** @typedef {function({configuration: import(\"../configuration.js\").default, workerCount: number}) : (WorkerHandler | InProcessHandler)} WorkerHandlerFactory */\n\nexport default class VelociousHttpServer {\n  clientCount = 0\n  _starting = false\n\n  /** @type {DevelopmentReloader | DevelopmentReloaderLike | undefined} */\n  developmentReloader\n\n  /** @type {import(\"net\").Server | undefined} */\n  netServer\n\n  /** @type {WorkerHandlerFactory | undefined} */\n  workerHandlerFactory\n\n  /** @type {Record<string, ServerClient>}  */\n  clients = {}\n\n  /** @type {Set<import(\"net\").Socket>} */\n  _activeSockets = new Set()\n\n  events = new EventEmitter()\n  workerCount = 0\n\n  /** @type {Array<WorkerHandler | InProcessHandler>} */\n  workerHandlers = []\n\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} [args.host] - Host.\n   * @param {boolean} [args.inProcess] - Run HTTP handlers in the main thread instead of worker threads.\n   * @param {number} [args.port] - Port.\n   * @param {number} [args.maxWorkers] - Max workers.\n   * @param {function({configuration: import(\"../configuration.js\").default, onReload: function({changedPath: string}) : Promise<void>}) : {start: () => Promise<void>, stop: () => Promise<void>}} [args.developmentReloaderFactory] - Development reloader factory.\n   * @param {WorkerHandlerFactory} [args.workerHandlerFactory] - Worker handler factory.\n   */\n  constructor({configuration, developmentReloaderFactory, host, inProcess, maxWorkers, port, workerHandlerFactory}) {\n    this.configuration = configuration\n    this.developmentReloaderFactory = developmentReloaderFactory\n    this.workerHandlerFactory = workerHandlerFactory\n    this.inProcess = inProcess || false\n    this.logger = new Logger(this)\n    this.host = host ?? \"0.0.0.0\"\n    this.port = port ?? 3006\n    this.maxWorkers = maxWorkers ?? 16\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async start() {\n    if (this._starting) throw new Error(\"Velocious HTTP server is already starting\")\n    if (this.isActive()) throw new Error(\"Velocious HTTP server is already running\")\n\n    this._starting = true\n    const startupState = this._captureStartupState()\n\n    try {\n      await this._ensureAtLeastOneWorker()\n      await this._startDevelopmentReloader()\n      /** @type {import(\"net\").Server} */\n      const netServer = new Net.Server()\n      this.netServer = netServer\n      netServer.on(\"close\", this.onClose)\n      netServer.on(\"connection\", this.onConnection)\n      netServer.on(\"error\", this.onServerError)\n      await this._netServerListen()\n    } catch (error) {\n      await this._stopStartupResources(startupState)\n      throw error\n    } finally {\n      this._starting = false\n    }\n  }\n\n  /** @returns {{developmentReloader: DevelopmentReloader | DevelopmentReloaderLike | undefined, netServer: import(\"net\").Server | undefined, workerHandlers: Array<WorkerHandler | InProcessHandler>}} - Startup state. */\n  _captureStartupState() {\n    return {\n      developmentReloader: this.developmentReloader,\n      netServer: this.netServer,\n      workerHandlers: [...this.workerHandlers]\n    }\n  }\n\n  /**\n   * @param {ReturnType<VelociousHttpServer[\"_captureStartupState\"]>} startupState - State captured before startup.\n   * @returns {Promise<void>} - Resolves when cleanup is complete.\n   */\n  async _stopStartupResources(startupState) {\n    /** @type {import(\"net\").Server | undefined} */\n    const startupNetServer = this.netServer\n\n    if (this.developmentReloader && this.developmentReloader !== startupState.developmentReloader) {\n      await this.developmentReloader.stop()\n    }\n\n    if (startupNetServer && startupNetServer !== startupState.netServer) {\n      await this.stopServer(startupNetServer)\n    }\n\n    const startupWorkerHandlers = this.workerHandlers.filter((workerHandler) => !startupState.workerHandlers.includes(workerHandler))\n\n    await Promise.all(startupWorkerHandlers.map((handler) => handler.stop()))\n\n    this.developmentReloader = startupState.developmentReloader\n    this.netServer = startupState.netServer\n    this.workerHandlers = startupState.workerHandlers\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  _netServerListen() {\n    return new Promise((resolve, reject) => {\n      if (!this.netServer) throw new Error(\"No netServer\")\n\n      /** @param {Error} error - Listen error. */\n      const onListenError = (error) => {\n        this.netServer?.off(\"error\", onListenError)\n        reject(error)\n      }\n\n      try {\n        this.netServer.once(\"error\", onListenError)\n        this.netServer.listen(this.port, this.host, () => {\n          this.netServer?.off(\"error\", onListenError)\n          this.logger.debug(`Velocious listening on ${this.host}:${this.port}`)\n          resolve(undefined)\n        })\n      } catch (error) {\n        reject(error)\n      }\n    })\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async _ensureAtLeastOneWorker() {\n    if (this.workerHandlers.length == 0) {\n      await this.spawnWorker()\n    }\n  }\n\n  /** @returns {boolean} - Whether active.  */\n  isActive() {\n    if (this.netServer) {\n      return this.netServer.listening\n    }\n\n    return false\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async stopClients() {\n    const promises = []\n\n    for (const clientCount in this.clients) {\n      const client = this.clients[clientCount]\n\n      promises.push(client.end())\n    }\n\n    await Promise.all(promises)\n  }\n\n  /**\n   * @param {import(\"net\").Server | undefined} [netServer] - Server to stop.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  stopServer(netServer = this.netServer) {\n    return new Promise((resolve, reject) => {\n      if (!netServer || !netServer.listening) {\n        resolve(undefined)\n        return\n      }\n\n      if (netServer === this.netServer) {\n        // Force-close lingering sockets (e.g. WebSocket upgrade\n        // connections mid-close-handshake) so the port is released\n        // immediately instead of waiting for graceful drain.\n        for (const socket of this._activeSockets) {\n          socket.destroy()\n        }\n\n        this._activeSockets.clear()\n      }\n\n      netServer.close((error) => {\n        if (error) {\n          reject(error)\n        } else {\n          resolve(undefined)\n        }\n      })\n    })\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async stop() {\n    this._stopping = true\n    await this.developmentReloader?.stop()\n    this.developmentReloader = undefined\n    await this.stopClients()\n    await this.stopServer()\n\n    const stopTasks = this.workerHandlers.map((handler) => handler.stop())\n    await Promise.all(stopTasks)\n    this.workerHandlers = []\n  }\n\n  /** @returns {void} - No return value.  */\n  onClose = () => {\n    this.events.emit(\"close\")\n  }\n\n  /**\n   * @param {Error} error - Server socket error.\n   * @returns {void} - No return value.\n   */\n  onServerError = (error) => {\n    this.logger.error(`Velocious HTTP server socket error on ${this.host}:${this.port}`, error)\n  }\n\n  /**\n   * @param {import(\"net\").Socket} socket - Socket instance.\n   * @returns {void} - No return value.\n   */\n  onConnection = (socket) => {\n    const clientCount = this.clientCount\n\n    this._activeSockets.add(socket)\n    socket.once(\"close\", () => this._activeSockets.delete(socket))\n\n    this.logger.debug(() => [\"New client\", {\n      clientCount,\n      remoteAddress: socket.remoteAddress,\n      remoteFamily: socket.remoteFamily,\n      remotePort: socket.remotePort\n    }])\n    this.clientCount++\n\n    try {\n      const workerHandler = this.workerHandlerToUse()\n      const client = new ServerClient({\n        clientCount,\n        configuration: this.configuration,\n        socket\n      })\n\n      client.events.on(\"close\", this.onClientClose)\n\n      this.logger.debug(`Gave client ${clientCount} to worker ${workerHandler.workerCount}`)\n      workerHandler.addSocketConnection(client)\n      this.clients[clientCount] = client\n    } catch (error) {\n      this.logger.error(`Failed to initialize client ${clientCount} on new connection`, error)\n      socket.destroy()\n    }\n  }\n\n  /**\n   * @param {ServerClient} client - Client instance.\n   * @returns {void} - No return value.\n   */\n  onClientClose = (client) => {\n    const clientCount = digg(client, \"clientCount\")\n    const oldClientsLength = Object.keys(this.clients).length\n\n    delete this.clients[clientCount]\n\n    const newClientsLength = Object.keys(this.clients).length\n\n    if (newClientsLength != (oldClientsLength - 1)) {\n      this.logger.error(`Expected client to have been removed but length didn't change from ${oldClientsLength} to ${oldClientsLength - 1}`)\n    }\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async spawnWorker() {\n    const workerHandler = await this._buildWorkerHandler()\n\n    this.workerHandlers.push(workerHandler)\n  }\n\n  /** @returns {Promise<WorkerHandler | InProcessHandler>} - Started worker handler. */\n  async _buildWorkerHandler() {\n    const workerCount = this.workerCount\n\n    this.workerCount++\n\n    const Handler = this.inProcess ? InProcessHandler : WorkerHandler\n    const workerHandler = this.workerHandlerFactory\n      ? this.workerHandlerFactory({configuration: this.configuration, workerCount})\n      : new Handler({\n        configuration: this.configuration,\n        workerCount\n      })\n\n    await workerHandler.start()\n\n    return workerHandler\n  }\n\n  /** @returns {WorkerHandler | InProcessHandler} - The worker handler to use. */\n  workerHandlerToUse() {\n    this.logger.debug(`Worker handlers length: ${this.workerHandlers.length}`)\n\n    const randomWorkerNumber = Math.floor(Math.random() * this.workerHandlers.length)\n    const workerHandler = this.workerHandlers[randomWorkerNumber]\n\n    if (!workerHandler) {\n      throw new Error(`No workerHandler by that number: ${randomWorkerNumber}`)\n    }\n\n    return workerHandler\n  }\n\n  /** @returns {boolean} - Whether development worker hot reload should run. */\n  shouldUseDevelopmentHotReload() {\n    return !this.inProcess && this.configuration.getEnvironment() === \"development\"\n  }\n\n  /** @returns {Promise<void>} - Resolves when watcher setup finishes. */\n  async _startDevelopmentReloader() {\n    if (!this.shouldUseDevelopmentHotReload()) return\n    if (this.developmentReloader) return\n\n    const createDevelopmentReloader = this.developmentReloaderFactory\n      || ((args) => new DevelopmentReloader(args))\n\n    this.developmentReloader = createDevelopmentReloader({\n      configuration: this.configuration,\n      onReload: async ({changedPath}) => {\n        await this.logger.info(`Development hot reload detected change in ${changedPath}`)\n        await this.reloadWorkersForDevelopment()\n      }\n    })\n\n    await this.developmentReloader.start()\n  }\n\n  /** @returns {Promise<void>} - Resolves when workers have been refreshed. */\n  async reloadWorkersForDevelopment() {\n    if (this._stopping) return\n\n    if (this._reloadingWorkersForDevelopment) {\n      this._reloadWorkersForDevelopmentQueued = true\n      return\n    }\n\n    this._reloadingWorkersForDevelopment = true\n\n    try {\n      do {\n        this._reloadWorkersForDevelopmentQueued = false\n\n        const oldWorkerHandlers = [...this.workerHandlers]\n        const newWorkerHandler = await this._buildWorkerHandler()\n\n        this.workerHandlers = [newWorkerHandler]\n\n        await Promise.all(oldWorkerHandlers.map((workerHandler) => workerHandler.stop()))\n      } while (this._reloadWorkersForDevelopmentQueued && !this._stopping)\n    } finally {\n      this._reloadingWorkersForDevelopment = false\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/http-server/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\nimport DevelopmentReloader from \"./development-reloader.js\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport InProcessHandler from \"./worker-handler/in-process.js\"\nimport Logger from \"../logger.js\"\nimport Net from \"net\"\nimport ServerClient from \"./server-client.js\"\nimport WorkerHandler from \"./worker-handler/index.js\"\n\n/** @typedef {{start: () => Promise<void>, stop: () => Promise<void>}} DevelopmentReloaderLike */\n/** @typedef {function({configuration: import(\"../configuration.js\").default, workerCount: number}) : (WorkerHandler | InProcessHandler)} WorkerHandlerFactory */\n\n/**\n * @param {object} args - Options object.\n * @param {number} [args.maxWorkers] - Backward-compatible worker count alias.\n * @param {number} [args.workers] - Configured worker count.\n * @returns {number} - Normalized worker count.\n */\nfunction normalizeWorkerCount({maxWorkers, workers}) {\n  const workerCount = workers ?? maxWorkers ?? 1\n\n  if (!Number.isInteger(workerCount) || workerCount < 1) {\n    throw new Error(\"HTTP server workers must be a positive integer\")\n  }\n\n  return workerCount\n}\n\nexport default class VelociousHttpServer {\n  clientCount = 0\n  _starting = false\n\n  /** @type {DevelopmentReloader | DevelopmentReloaderLike | undefined} */\n  developmentReloader\n\n  /** @type {import(\"net\").Server | undefined} */\n  netServer\n\n  /** @type {WorkerHandlerFactory | undefined} */\n  workerHandlerFactory\n\n  /** @type {Record<string, ServerClient>}  */\n  clients = {}\n\n  /** @type {Set<import(\"net\").Socket>} */\n  _activeSockets = new Set()\n\n  events = new EventEmitter()\n  workerCount = 0\n\n  /** @type {Array<WorkerHandler | InProcessHandler>} */\n  workerHandlers = []\n  nextWorkerHandlerIndex = 0\n  /** @type {Map<string, WorkerHandler | InProcessHandler>} */\n  stickyWorkerHandlers = new Map()\n\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string} [args.host] - Host.\n   * @param {boolean} [args.inProcess] - Run HTTP handlers in the main thread instead of worker threads.\n   * @param {number} [args.port] - Port.\n   * @param {number} [args.maxWorkers] - Max workers.\n   * @param {number} [args.workers] - Worker handlers to start.\n   * @param {function({configuration: import(\"../configuration.js\").default, onReload: function({changedPath: string}) : Promise<void>}) : {start: () => Promise<void>, stop: () => Promise<void>}} [args.developmentReloaderFactory] - Development reloader factory.\n   * @param {WorkerHandlerFactory} [args.workerHandlerFactory] - Worker handler factory.\n   */\n  constructor({configuration, developmentReloaderFactory, host, inProcess, maxWorkers, port, workerHandlerFactory, workers}) {\n    this.configuration = configuration\n    this.developmentReloaderFactory = developmentReloaderFactory\n    this.workerHandlerFactory = workerHandlerFactory\n    this.inProcess = inProcess || false\n    this.logger = new Logger(this)\n    this.host = host ?? \"0.0.0.0\"\n    this.port = port ?? 3006\n    this.workers = normalizeWorkerCount({maxWorkers, workers})\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async start() {\n    if (this._starting) throw new Error(\"Velocious HTTP server is already starting\")\n    if (this.isActive()) throw new Error(\"Velocious HTTP server is already running\")\n\n    this._starting = true\n    const startupState = this._captureStartupState()\n\n    try {\n      await this._ensureWorkers()\n      await this._startDevelopmentReloader()\n      /** @type {import(\"net\").Server} */\n      const netServer = new Net.Server()\n      this.netServer = netServer\n      netServer.on(\"close\", this.onClose)\n      netServer.on(\"connection\", this.onConnection)\n      netServer.on(\"error\", this.onServerError)\n      await this._netServerListen()\n    } catch (error) {\n      await this._stopStartupResources(startupState)\n      throw error\n    } finally {\n      this._starting = false\n    }\n  }\n\n  /** @returns {{developmentReloader: DevelopmentReloader | DevelopmentReloaderLike | undefined, netServer: import(\"net\").Server | undefined, workerHandlers: Array<WorkerHandler | InProcessHandler>}} - Startup state. */\n  _captureStartupState() {\n    return {\n      developmentReloader: this.developmentReloader,\n      netServer: this.netServer,\n      workerHandlers: [...this.workerHandlers]\n    }\n  }\n\n  /**\n   * @param {ReturnType<VelociousHttpServer[\"_captureStartupState\"]>} startupState - State captured before startup.\n   * @returns {Promise<void>} - Resolves when cleanup is complete.\n   */\n  async _stopStartupResources(startupState) {\n    /** @type {import(\"net\").Server | undefined} */\n    const startupNetServer = this.netServer\n\n    if (this.developmentReloader && this.developmentReloader !== startupState.developmentReloader) {\n      await this.developmentReloader.stop()\n    }\n\n    if (startupNetServer && startupNetServer !== startupState.netServer) {\n      await this.stopServer(startupNetServer)\n    }\n\n    const startupWorkerHandlers = this.workerHandlers.filter((workerHandler) => !startupState.workerHandlers.includes(workerHandler))\n\n    await Promise.all(startupWorkerHandlers.map((handler) => handler.stop()))\n\n    this.developmentReloader = startupState.developmentReloader\n    this.netServer = startupState.netServer\n    this.workerHandlers = startupState.workerHandlers\n    this.stickyWorkerHandlers.clear()\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  _netServerListen() {\n    return new Promise((resolve, reject) => {\n      if (!this.netServer) throw new Error(\"No netServer\")\n\n      /** @param {Error} error - Listen error. */\n      const onListenError = (error) => {\n        this.netServer?.off(\"error\", onListenError)\n        reject(error)\n      }\n\n      try {\n        this.netServer.once(\"error\", onListenError)\n        this.netServer.listen(this.port, this.host, () => {\n          this.netServer?.off(\"error\", onListenError)\n          this.logger.debug(`Velocious listening on ${this.host}:${this.port}`)\n          resolve(undefined)\n        })\n      } catch (error) {\n        reject(error)\n      }\n    })\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async _ensureWorkers() {\n    while (this.workerHandlers.length < this.workers) {\n      await this.spawnWorker()\n    }\n  }\n\n  /** @returns {boolean} - Whether active.  */\n  isActive() {\n    if (this.netServer) {\n      return this.netServer.listening\n    }\n\n    return false\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async stopClients() {\n    const promises = []\n\n    for (const clientCount in this.clients) {\n      const client = this.clients[clientCount]\n\n      promises.push(client.end())\n    }\n\n    await Promise.all(promises)\n  }\n\n  /**\n   * @param {import(\"net\").Server | undefined} [netServer] - Server to stop.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  stopServer(netServer = this.netServer) {\n    return new Promise((resolve, reject) => {\n      if (!netServer || !netServer.listening) {\n        resolve(undefined)\n        return\n      }\n\n      if (netServer === this.netServer) {\n        // Force-close lingering sockets (e.g. WebSocket upgrade\n        // connections mid-close-handshake) so the port is released\n        // immediately instead of waiting for graceful drain.\n        for (const socket of this._activeSockets) {\n          socket.destroy()\n        }\n\n        this._activeSockets.clear()\n      }\n\n      netServer.close((error) => {\n        if (error) {\n          reject(error)\n        } else {\n          resolve(undefined)\n        }\n      })\n    })\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async stop() {\n    this._stopping = true\n    await this.developmentReloader?.stop()\n    this.developmentReloader = undefined\n    await this.stopClients()\n    await this.stopServer()\n\n    const stopTasks = this.workerHandlers.map((handler) => handler.stop())\n    await Promise.all(stopTasks)\n    this.workerHandlers = []\n    this.stickyWorkerHandlers.clear()\n  }\n\n  /** @returns {void} - No return value.  */\n  onClose = () => {\n    this.events.emit(\"close\")\n  }\n\n  /**\n   * @param {Error} error - Server socket error.\n   * @returns {void} - No return value.\n   */\n  onServerError = (error) => {\n    this.logger.error(`Velocious HTTP server socket error on ${this.host}:${this.port}`, error)\n  }\n\n  /**\n   * @param {import(\"net\").Socket} socket - Socket instance.\n   * @returns {void} - No return value.\n   */\n  onConnection = (socket) => {\n    const clientCount = this.clientCount\n\n    this._activeSockets.add(socket)\n    socket.once(\"close\", () => this._activeSockets.delete(socket))\n\n    this.logger.debug(() => [\"New client\", {\n      clientCount,\n      remoteAddress: socket.remoteAddress,\n      remoteFamily: socket.remoteFamily,\n      remotePort: socket.remotePort\n    }])\n    this.clientCount++\n\n    try {\n      // Paused WebSocket sessions are worker-local, so reconnects from\n      // the same client address must return to the same worker.\n      const workerHandler = this.workerHandlerToUse({stickyKey: socket.remoteAddress})\n      const client = new ServerClient({\n        clientCount,\n        configuration: this.configuration,\n        socket\n      })\n\n      client.events.on(\"close\", this.onClientClose)\n\n      this.logger.debug(`Gave client ${clientCount} to worker ${workerHandler.workerCount}`)\n      workerHandler.addSocketConnection(client)\n      this.clients[clientCount] = client\n    } catch (error) {\n      this.logger.error(`Failed to initialize client ${clientCount} on new connection`, error)\n      socket.destroy()\n    }\n  }\n\n  /**\n   * @param {ServerClient} client - Client instance.\n   * @returns {void} - No return value.\n   */\n  onClientClose = (client) => {\n    const clientCount = digg(client, \"clientCount\")\n    const oldClientsLength = Object.keys(this.clients).length\n\n    delete this.clients[clientCount]\n\n    const newClientsLength = Object.keys(this.clients).length\n\n    if (newClientsLength != (oldClientsLength - 1)) {\n      this.logger.error(`Expected client to have been removed but length didn't change from ${oldClientsLength} to ${oldClientsLength - 1}`)\n    }\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  async spawnWorker() {\n    const workerHandler = await this._buildWorkerHandler()\n\n    this.workerHandlers.push(workerHandler)\n  }\n\n  /** @returns {Promise<Array<WorkerHandler | InProcessHandler>>} - Started worker handlers. */\n  async _buildWorkerHandlers() {\n    /** @type {Array<WorkerHandler | InProcessHandler>} */\n    const workerHandlers = []\n\n    for (let index = 0; index < this.workers; index += 1) {\n      workerHandlers.push(await this._buildWorkerHandler())\n    }\n\n    return workerHandlers\n  }\n\n  /** @returns {Promise<WorkerHandler | InProcessHandler>} - Started worker handler. */\n  async _buildWorkerHandler() {\n    const workerCount = this.workerCount\n\n    this.workerCount++\n\n    const Handler = this.inProcess ? InProcessHandler : WorkerHandler\n    const workerHandler = this.workerHandlerFactory\n      ? this.workerHandlerFactory({configuration: this.configuration, workerCount})\n      : new Handler({\n        configuration: this.configuration,\n        workerCount\n      })\n\n    await workerHandler.start()\n\n    return workerHandler\n  }\n\n  /**\n   * @param {object} [args] - Options object.\n   * @param {string} [args.stickyKey] - Stable key that must keep routing to the same worker.\n   * @returns {WorkerHandler | InProcessHandler} - The worker handler to use.\n   */\n  workerHandlerToUse({stickyKey} = {}) {\n    if (stickyKey) {\n      const stickyWorkerHandler = this.stickyWorkerHandlers.get(stickyKey)\n\n      if (stickyWorkerHandler && this.workerHandlers.includes(stickyWorkerHandler)) {\n        return stickyWorkerHandler\n      }\n\n      const workerHandler = this._nextRoundRobinWorkerHandler()\n\n      this.stickyWorkerHandlers.set(stickyKey, workerHandler)\n\n      return workerHandler\n    }\n\n    return this._nextRoundRobinWorkerHandler()\n  }\n\n  /** @returns {WorkerHandler | InProcessHandler} - The next round-robin worker handler. */\n  _nextRoundRobinWorkerHandler() {\n    this.logger.debug(`Worker handlers length: ${this.workerHandlers.length}`)\n\n    const workerHandlerIndex = this.nextWorkerHandlerIndex % this.workerHandlers.length\n    const workerHandler = this.workerHandlers[workerHandlerIndex]\n\n    if (!workerHandler) {\n      throw new Error(`No workerHandler by that number: ${workerHandlerIndex}`)\n    }\n\n    this.nextWorkerHandlerIndex += 1\n\n    return workerHandler\n  }\n\n  /** @returns {boolean} - Whether development worker hot reload should run. */\n  shouldUseDevelopmentHotReload() {\n    return !this.inProcess && this.configuration.getEnvironment() === \"development\"\n  }\n\n  /** @returns {Promise<void>} - Resolves when watcher setup finishes. */\n  async _startDevelopmentReloader() {\n    if (!this.shouldUseDevelopmentHotReload()) return\n    if (this.developmentReloader) return\n\n    const createDevelopmentReloader = this.developmentReloaderFactory\n      || ((args) => new DevelopmentReloader(args))\n\n    this.developmentReloader = createDevelopmentReloader({\n      configuration: this.configuration,\n      onReload: async ({changedPath}) => {\n        await this.logger.info(`Development hot reload detected change in ${changedPath}`)\n        await this.reloadWorkersForDevelopment()\n      }\n    })\n\n    await this.developmentReloader.start()\n  }\n\n  /** @returns {Promise<void>} - Resolves when workers have been refreshed. */\n  async reloadWorkersForDevelopment() {\n    if (this._stopping) return\n\n    if (this._reloadingWorkersForDevelopment) {\n      this._reloadWorkersForDevelopmentQueued = true\n      return\n    }\n\n    this._reloadingWorkersForDevelopment = true\n\n    try {\n      do {\n        this._reloadWorkersForDevelopmentQueued = false\n\n        const oldWorkerHandlers = [...this.workerHandlers]\n        const newWorkerHandlers = await this._buildWorkerHandlers()\n\n        this.workerHandlers = newWorkerHandlers\n        this.nextWorkerHandlerIndex = 0\n        this.stickyWorkerHandlers.clear()\n\n        await Promise.all(oldWorkerHandlers.map((workerHandler) => workerHandler.stop()))\n      } while (this._reloadWorkersForDevelopmentQueued && !this._stopping)\n    } finally {\n      this._reloadingWorkersForDevelopment = false\n    }\n  }\n}\n"]}

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.419",
+  "version": "1.0.421",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [