velocious 1.0.431 → 1.0.433

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

@@ -1,21 +1,18 @@
 // @ts-check
-
-import {digg} from "diggerize"
-import DevelopmentReloader from "./development-reloader.js"
-import EventEmitter from "../utils/event-emitter.js"
-import InProcessHandler from "./worker-handler/in-process.js"
-import Logger from "../logger.js"
-import Net from "net"
-import ServerClient from "./server-client.js"
-import WorkerHandler from "./worker-handler/index.js"
-
+import { digg } from "diggerize";
+import DevelopmentReloader from "./development-reloader.js";
+import EventEmitter from "../utils/event-emitter.js";
+import InProcessHandler from "./worker-handler/in-process.js";
+import Logger from "../logger.js";
+import Net from "net";
+import ServerClient from "./server-client.js";
+import WorkerHandler from "./worker-handler/index.js";
 /**
  * Defines this typedef.
   @typedef {{start: () => Promise<void>, stop: () => Promise<void>}} DevelopmentReloaderLike */
 /**
  * Defines this typedef.
   @typedef {function({configuration: import("../configuration.js").default, workerCount: number}) : (WorkerHandler | InProcessHandler)} WorkerHandlerFactory */
-
 /**
  * Runs normalize worker count.
  * @param {object} args - Options object.
@@ -23,539 +20,468 @@ import WorkerHandler from "./worker-handler/index.js"
  * @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
+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
-
-  /**
-   * Narrows the runtime value to the documented type.
-    @type {DevelopmentReloader | DevelopmentReloaderLike | undefined} */
-  developmentReloader
-
-  /**
-   * Narrows the runtime value to the documented type.
-    @type {import("net").Server | undefined} */
-  netServer
-
-  /**
-   * Narrows the runtime value to the documented type.
-    @type {WorkerHandlerFactory | undefined} */
-  workerHandlerFactory
-
-  /**
-   * Clients.
-    @type {Record<string, ServerClient>}  */
-  clients = {}
-
-  /**
-   * Active sockets.
-    @type {Set<import("net").Socket>} */
-  _activeSockets = new Set()
-
-  events = new EventEmitter()
-  workerCount = 0
-
-  /**
-   * Worker handlers.
-    @type {Array<WorkerHandler | InProcessHandler>} */
-  workerHandlers = []
-  nextWorkerHandlerIndex = 0
-  /**
-   * Sticky worker handlers.
-    @type {Map<string, WorkerHandler | InProcessHandler>} */
-  stickyWorkerHandlers = new Map()
-
-  /**
-   * Runs constructor.
-   * @param {object} args - Options object.
-   * @param {import("../configuration.js").default} args.configuration - Configuration instance.
-   * @param {string} [args.host] - Host.
-   * @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, workers}) {
-    this.configuration = configuration
-    this.developmentReloaderFactory = developmentReloaderFactory
-    this.workerHandlerFactory = workerHandlerFactory
-    this.inProcess = inProcess || false
-    this.logger = new Logger(this)
-    this.host = host ?? "0.0.0.0"
-    this.port = port ?? 3006
-    this.workers = normalizeWorkerCount({maxWorkers, workers})
-  }
-
-  /**
-   * Runs start.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async start() {
-    if (this._starting) throw new Error("Velocious HTTP server is already starting")
-    if (this.isActive()) throw new Error("Velocious HTTP server is already running")
-
-    this._starting = true
-    const startupState = this._captureStartupState()
-
-    try {
-      await this._ensureWorkers()
-      await this._startDevelopmentReloader()
-      /**
-       * Net server.
-        @type {import("net").Server} */
-      const netServer = new Net.Server()
-      this.netServer = netServer
-      netServer.on("close", this.onClose)
-      netServer.on("connection", this.onConnection)
-      netServer.on("error", this.onServerError)
-      await this._netServerListen()
-    } catch (error) {
-      await this._stopStartupResources(startupState)
-      throw error
-    } finally {
-      this._starting = false
+    clientCount = 0;
+    _starting = false;
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {DevelopmentReloader | DevelopmentReloaderLike | undefined} */
+    developmentReloader;
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {import("net").Server | undefined} */
+    netServer;
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {WorkerHandlerFactory | undefined} */
+    workerHandlerFactory;
+    /**
+     * Clients.
+      @type {Record<string, ServerClient>}  */
+    clients = {};
+    /**
+     * Active sockets.
+      @type {Set<import("net").Socket>} */
+    _activeSockets = new Set();
+    events = new EventEmitter();
+    workerCount = 0;
+    /**
+     * Worker handlers.
+      @type {Array<WorkerHandler | InProcessHandler>} */
+    workerHandlers = [];
+    nextWorkerHandlerIndex = 0;
+    /**
+     * Sticky worker handlers.
+      @type {Map<string, WorkerHandler | InProcessHandler>} */
+    stickyWorkerHandlers = new Map();
+    /**
+     * Runs constructor.
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {string} [args.host] - Host.
+     * @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, workers }) {
+        this.configuration = configuration;
+        this.developmentReloaderFactory = developmentReloaderFactory;
+        this.workerHandlerFactory = workerHandlerFactory;
+        this.inProcess = inProcess || false;
+        this.logger = new Logger(this);
+        this.host = host ?? "0.0.0.0";
+        this.port = port ?? 3006;
+        this.workers = normalizeWorkerCount({ maxWorkers, workers });
     }
-  }
-
-  /**
-   * Runs capture startup state.
-   * @returns {{developmentReloader: DevelopmentReloader | DevelopmentReloaderLike | undefined, netServer: import("net").Server | undefined, workerHandlers: Array<WorkerHandler | InProcessHandler>}} - Startup state.
-   */
-  _captureStartupState() {
-    return {
-      developmentReloader: this.developmentReloader,
-      netServer: this.netServer,
-      workerHandlers: [...this.workerHandlers]
+    /**
+     * Runs start.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async start() {
+        if (this._starting)
+            throw new Error("Velocious HTTP server is already starting");
+        if (this.isActive())
+            throw new Error("Velocious HTTP server is already running");
+        this._starting = true;
+        const startupState = this._captureStartupState();
+        try {
+            await this._ensureWorkers();
+            await this._startDevelopmentReloader();
+            /**
+             * Net server.
+              @type {import("net").Server} */
+            const netServer = new Net.Server();
+            this.netServer = netServer;
+            netServer.on("close", this.onClose);
+            netServer.on("connection", this.onConnection);
+            netServer.on("error", this.onServerError);
+            await this._netServerListen();
+        }
+        catch (error) {
+            await this._stopStartupResources(startupState);
+            throw error;
+        }
+        finally {
+            this._starting = false;
+        }
     }
-  }
-
-  /**
-   * Runs stop startup resources.
-   * @param {ReturnType<VelociousHttpServer["_captureStartupState"]>} startupState - State captured before startup.
-   * @returns {Promise<void>} - Resolves when cleanup is complete.
-   */
-  async _stopStartupResources(startupState) {
-    /**
-     * Startup net server.
-      @type {import("net").Server | undefined} */
-    const startupNetServer = this.netServer
-
-    if (this.developmentReloader && this.developmentReloader !== startupState.developmentReloader) {
-      await this.developmentReloader.stop()
+    /**
+     * Runs capture startup state.
+     * @returns {{developmentReloader: DevelopmentReloader | DevelopmentReloaderLike | undefined, netServer: import("net").Server | undefined, workerHandlers: Array<WorkerHandler | InProcessHandler>}} - Startup state.
+     */
+    _captureStartupState() {
+        return {
+            developmentReloader: this.developmentReloader,
+            netServer: this.netServer,
+            workerHandlers: [...this.workerHandlers]
+        };
+    }
+    /**
+     * Runs stop startup resources.
+     * @param {ReturnType<VelociousHttpServer["_captureStartupState"]>} startupState - State captured before startup.
+     * @returns {Promise<void>} - Resolves when cleanup is complete.
+     */
+    async _stopStartupResources(startupState) {
+        /**
+         * Startup net server.
+          @type {import("net").Server | undefined} */
+        const startupNetServer = this.netServer;
+        if (this.developmentReloader && this.developmentReloader !== startupState.developmentReloader) {
+            await this.developmentReloader.stop();
+        }
+        if (startupNetServer && startupNetServer !== startupState.netServer) {
+            await this.stopServer(startupNetServer);
+        }
+        const startupWorkerHandlers = this.workerHandlers.filter((workerHandler) => !startupState.workerHandlers.includes(workerHandler));
+        await Promise.all(startupWorkerHandlers.map((handler) => handler.stop()));
+        this.developmentReloader = startupState.developmentReloader;
+        this.netServer = startupState.netServer;
+        this.workerHandlers = startupState.workerHandlers;
+        this.stickyWorkerHandlers.clear();
+    }
+    /**
+     * Runs net server listen.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    _netServerListen() {
+        return new Promise((resolve, reject) => {
+            if (!this.netServer)
+                throw new Error("No netServer");
+            /**
+             * On listen error.
+             * @param {Error} error - Listen error.
+             */
+            const onListenError = (error) => {
+                this.netServer?.off("error", onListenError);
+                reject(error);
+            };
+            try {
+                this.netServer.once("error", onListenError);
+                this.netServer.listen(this.port, this.host, () => {
+                    this.netServer?.off("error", onListenError);
+                    this.logger.debug(`Velocious listening on ${this.host}:${this.port}`);
+                    resolve(undefined);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Runs ensure workers.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _ensureWorkers() {
+        while (this.workerHandlers.length < this.workers) {
+            await this.spawnWorker();
+        }
+    }
+    /**
+     * Runs is active.
+     * @returns {boolean} - Whether active.
+     */
+    isActive() {
+        if (this.netServer) {
+            return this.netServer.listening;
+        }
+        return false;
     }
-
-    if (startupNetServer && startupNetServer !== startupState.netServer) {
-      await this.stopServer(startupNetServer)
+    /**
+     * Runs get debug snapshot.
+     * @returns {Promise<Record<string, ?>>} - HTTP server worker diagnostics.
+     */
+    async getDebugSnapshot() {
+        return {
+            active: this.isActive(),
+            activeSocketCount: this._activeSockets.size,
+            clientCount: Object.keys(this.clients).length,
+            configuredWorkerCount: this.workers,
+            inProcess: this.inProcess,
+            workerCount: this.workerHandlers.length,
+            workers: await Promise.all(this.workerHandlers.map((handler) => this.workerDebugSnapshot(handler)))
+        };
     }
-
-    const startupWorkerHandlers = this.workerHandlers.filter((workerHandler) => !startupState.workerHandlers.includes(workerHandler))
-
-    await Promise.all(startupWorkerHandlers.map((handler) => handler.stop()))
-
-    this.developmentReloader = startupState.developmentReloader
-    this.netServer = startupState.netServer
-    this.workerHandlers = startupState.workerHandlers
-    this.stickyWorkerHandlers.clear()
-  }
-
-  /**
-   * Runs net server listen.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  _netServerListen() {
-    return new Promise((resolve, reject) => {
-      if (!this.netServer) throw new Error("No netServer")
-
-      /**
-       * On listen error.
-       * @param {Error} error - Listen error.
-       */
-      const onListenError = (error) => {
-        this.netServer?.off("error", onListenError)
-        reject(error)
-      }
-
-      try {
-        this.netServer.once("error", onListenError)
-        this.netServer.listen(this.port, this.host, () => {
-          this.netServer?.off("error", onListenError)
-          this.logger.debug(`Velocious listening on ${this.host}:${this.port}`)
-          resolve(undefined)
-        })
-      } catch (error) {
-        reject(error)
-      }
-    })
-  }
-
-  /**
-   * Runs ensure workers.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async _ensureWorkers() {
-    while (this.workerHandlers.length < this.workers) {
-      await this.spawnWorker()
+    /**
+     * Runs worker debug snapshot.
+     * @param {WorkerHandler | InProcessHandler} workerHandler - Worker handler to inspect.
+     * @returns {Promise<Record<string, ?>>} Worker debug snapshot.
+     */
+    async workerDebugSnapshot(workerHandler) {
+        if (workerHandler instanceof WorkerHandler)
+            return await workerHandler.getDebugSnapshot();
+        if (workerHandler instanceof InProcessHandler)
+            return this.inProcessWorkerDebugSnapshot(workerHandler);
+        return { active: false, error: "Unknown worker handler type" };
     }
-  }
-
-  /**
-   * Runs is active.
-   * @returns {boolean} - Whether active.
-   */
-  isActive() {
-    if (this.netServer) {
-      return this.netServer.listening
+    /**
+     * Runs in process worker debug snapshot.
+     * @param {InProcessHandler} workerHandler - In-process worker handler to inspect.
+     * @returns {Record<string, ?>} Worker debug snapshot.
+     */
+    inProcessWorkerDebugSnapshot(workerHandler) {
+        return {
+            active: true,
+            clientCount: Object.keys(workerHandler.clients).length,
+            snapshot: workerHandler.configuration.getLocalDebugSnapshot(),
+            workerCount: workerHandler.workerCount
+        };
     }
-
-    return false
-  }
-
-  /**
-   * Runs get debug snapshot.
-   * @returns {Promise<Record<string, ?>>} - HTTP server worker diagnostics.
-   */
-  async getDebugSnapshot() {
-    return {
-      active: this.isActive(),
-      activeSocketCount: this._activeSockets.size,
-      clientCount: Object.keys(this.clients).length,
-      configuredWorkerCount: this.workers,
-      inProcess: this.inProcess,
-      workerCount: this.workerHandlers.length,
-      workers: await Promise.all(this.workerHandlers.map((handler) => this.workerDebugSnapshot(handler)))
+    /**
+     * Runs stop clients.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async stopClients() {
+        const promises = [];
+        for (const clientCount in this.clients) {
+            const client = this.clients[clientCount];
+            promises.push(client.end());
+        }
+        await Promise.all(promises);
     }
-  }
-
-  /**
-   * Runs worker debug snapshot.
-   * @param {WorkerHandler | InProcessHandler} workerHandler - Worker handler to inspect.
-   * @returns {Promise<Record<string, ?>>} Worker debug snapshot.
-   */
-  async workerDebugSnapshot(workerHandler) {
-    if (workerHandler instanceof WorkerHandler) return await workerHandler.getDebugSnapshot()
-    if (workerHandler instanceof InProcessHandler) return this.inProcessWorkerDebugSnapshot(workerHandler)
-
-    return {active: false, error: "Unknown worker handler type"}
-  }
-
-  /**
-   * Runs in process worker debug snapshot.
-   * @param {InProcessHandler} workerHandler - In-process worker handler to inspect.
-   * @returns {Record<string, ?>} Worker debug snapshot.
-   */
-  inProcessWorkerDebugSnapshot(workerHandler) {
-    return {
-      active: true,
-      clientCount: Object.keys(workerHandler.clients).length,
-      snapshot: workerHandler.configuration.getLocalDebugSnapshot(),
-      workerCount: workerHandler.workerCount
+    /**
+     * Runs stop server.
+     * @param {import("net").Server | undefined} [netServer] - Server to stop.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    stopServer(netServer = this.netServer) {
+        return new Promise((resolve, reject) => {
+            if (!netServer || !netServer.listening) {
+                resolve(undefined);
+                return;
+            }
+            if (netServer === this.netServer) {
+                // Force-close lingering sockets (e.g. WebSocket upgrade
+                // connections mid-close-handshake) so the port is released
+                // immediately instead of waiting for graceful drain.
+                for (const socket of this._activeSockets) {
+                    socket.destroy();
+                }
+                this._activeSockets.clear();
+            }
+            netServer.close((error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(undefined);
+                }
+            });
+        });
     }
-  }
-
-  /**
-   * Runs stop clients.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async stopClients() {
-    const promises = []
-
-    for (const clientCount in this.clients) {
-      const client = this.clients[clientCount]
-
-      promises.push(client.end())
+    /**
+     * Runs stop.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async stop() {
+        this._stopping = true;
+        await this.developmentReloader?.stop();
+        this.developmentReloader = undefined;
+        await this.stopClients();
+        await this.stopServer();
+        const stopTasks = this.workerHandlers.map((handler) => handler.stop());
+        await Promise.all(stopTasks);
+        this.workerHandlers = [];
+        this.stickyWorkerHandlers.clear();
     }
-
-    await Promise.all(promises)
-  }
-
-  /**
-   * Runs stop server.
-   * @param {import("net").Server | undefined} [netServer] - Server to stop.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  stopServer(netServer = this.netServer) {
-    return new Promise((resolve, reject) => {
-      if (!netServer || !netServer.listening) {
-        resolve(undefined)
-        return
-      }
-
-      if (netServer === this.netServer) {
-        // Force-close lingering sockets (e.g. WebSocket upgrade
-        // connections mid-close-handshake) so the port is released
-        // immediately instead of waiting for graceful drain.
-        for (const socket of this._activeSockets) {
-          socket.destroy()
+    /**
+     * On close.
+     * @returns {void} - No return value.
+     */
+    onClose = () => {
+        this.events.emit("close");
+    };
+    /**
+     * On server error.
+     * @param {Error} error - Server socket error.
+     * @returns {void} - No return value.
+     */
+    onServerError = (error) => {
+        this.logger.error(`Velocious HTTP server socket error on ${this.host}:${this.port}`, error);
+    };
+    /**
+     * On connection.
+     * @param {import("net").Socket} socket - Socket instance.
+     * @returns {void} - No return value.
+     */
+    onConnection = (socket) => {
+        const clientCount = this.clientCount;
+        this._activeSockets.add(socket);
+        socket.once("close", () => this._activeSockets.delete(socket));
+        this.logger.debug(() => ["New client", {
+                clientCount,
+                remoteAddress: socket.remoteAddress,
+                remoteFamily: socket.remoteFamily,
+                remotePort: socket.remotePort
+            }]);
+        this.clientCount++;
+        try {
+            // 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,
+                socket
+            });
+            client.events.on("close", this.onClientClose);
+            this.logger.debug(`Gave client ${clientCount} to worker ${workerHandler.workerCount}`);
+            workerHandler.addSocketConnection(client);
+            this.clients[clientCount] = client;
         }
-
-        this._activeSockets.clear()
-      }
-
-      netServer.close((error) => {
-        if (error) {
-          reject(error)
-        } else {
-          resolve(undefined)
+        catch (error) {
+            this.logger.error(`Failed to initialize client ${clientCount} on new connection`, error);
+            socket.destroy();
         }
-      })
-    })
-  }
-
-  /**
-   * Runs stop.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async stop() {
-    this._stopping = true
-    await this.developmentReloader?.stop()
-    this.developmentReloader = undefined
-    await this.stopClients()
-    await this.stopServer()
-
-    const stopTasks = this.workerHandlers.map((handler) => handler.stop())
-    await Promise.all(stopTasks)
-    this.workerHandlers = []
-    this.stickyWorkerHandlers.clear()
-  }
-
-  /**
-   * On close.
-   * @returns {void} - No return value.
-   */
-  onClose = () => {
-    this.events.emit("close")
-  }
-
-  /**
-   * On server error.
-   * @param {Error} error - Server socket error.
-   * @returns {void} - No return value.
-   */
-  onServerError = (error) => {
-    this.logger.error(`Velocious HTTP server socket error on ${this.host}:${this.port}`, error)
-  }
-
-  /**
-   * On connection.
-   * @param {import("net").Socket} socket - Socket instance.
-   * @returns {void} - No return value.
-   */
-  onConnection = (socket) => {
-    const clientCount = this.clientCount
-
-    this._activeSockets.add(socket)
-    socket.once("close", () => this._activeSockets.delete(socket))
-
-    this.logger.debug(() => ["New client", {
-      clientCount,
-      remoteAddress: socket.remoteAddress,
-      remoteFamily: socket.remoteFamily,
-      remotePort: socket.remotePort
-    }])
-    this.clientCount++
-
-    try {
-      // 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,
-        socket
-      })
-
-      client.events.on("close", this.onClientClose)
-
-      this.logger.debug(`Gave client ${clientCount} to worker ${workerHandler.workerCount}`)
-      workerHandler.addSocketConnection(client)
-      this.clients[clientCount] = client
-    } catch (error) {
-      this.logger.error(`Failed to initialize client ${clientCount} on new connection`, error)
-      socket.destroy()
+    };
+    /**
+     * On client close.
+     * @param {ServerClient} client - Client instance.
+     * @returns {void} - No return value.
+     */
+    onClientClose = (client) => {
+        const clientCount = digg(client, "clientCount");
+        const oldClientsLength = Object.keys(this.clients).length;
+        delete this.clients[clientCount];
+        const newClientsLength = Object.keys(this.clients).length;
+        if (newClientsLength != (oldClientsLength - 1)) {
+            this.logger.error(`Expected client to have been removed but length didn't change from ${oldClientsLength} to ${oldClientsLength - 1}`);
+        }
+    };
+    /**
+     * Runs spawn worker.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async spawnWorker() {
+        const workerHandler = await this._buildWorkerHandler();
+        this.workerHandlers.push(workerHandler);
     }
-  }
-
-  /**
-   * On client close.
-   * @param {ServerClient} client - Client instance.
-   * @returns {void} - No return value.
-   */
-  onClientClose = (client) => {
-    const clientCount = digg(client, "clientCount")
-    const oldClientsLength = Object.keys(this.clients).length
-
-    delete this.clients[clientCount]
-
-    const newClientsLength = Object.keys(this.clients).length
-
-    if (newClientsLength != (oldClientsLength - 1)) {
-      this.logger.error(`Expected client to have been removed but length didn't change from ${oldClientsLength} to ${oldClientsLength - 1}`)
+    /**
+     * Runs build worker handlers.
+     * @returns {Promise<Array<WorkerHandler | InProcessHandler>>} - Started worker handlers.
+     */
+    async _buildWorkerHandlers() {
+        /**
+         * Worker handlers.
+          @type {Array<WorkerHandler | InProcessHandler>} */
+        const workerHandlers = [];
+        for (let index = 0; index < this.workers; index += 1) {
+            workerHandlers.push(await this._buildWorkerHandler());
+        }
+        return workerHandlers;
     }
-  }
-
-  /**
-   * Runs spawn worker.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async spawnWorker() {
-    const workerHandler = await this._buildWorkerHandler()
-
-    this.workerHandlers.push(workerHandler)
-  }
-
-  /**
-   * Runs build worker handlers.
-   * @returns {Promise<Array<WorkerHandler | InProcessHandler>>} - Started worker handlers.
-   */
-  async _buildWorkerHandlers() {
     /**
-     * Worker handlers.
-      @type {Array<WorkerHandler | InProcessHandler>} */
-    const workerHandlers = []
-
-    for (let index = 0; index < this.workers; index += 1) {
-      workerHandlers.push(await this._buildWorkerHandler())
+     * Runs build worker handler.
+     * @returns {Promise<WorkerHandler | InProcessHandler>} - Started worker handler.
+     */
+    async _buildWorkerHandler() {
+        const workerCount = this.workerCount;
+        this.workerCount++;
+        const Handler = this.inProcess ? InProcessHandler : WorkerHandler;
+        const workerHandler = this.workerHandlerFactory
+            ? this.workerHandlerFactory({ configuration: this.configuration, workerCount })
+            : new Handler({
+                configuration: this.configuration,
+                workerCount
+            });
+        await workerHandler.start();
+        return workerHandler;
     }
-
-    return workerHandlers
-  }
-
-  /**
-   * Runs build worker handler.
-   * @returns {Promise<WorkerHandler | InProcessHandler>} - Started worker handler.
-   */
-  async _buildWorkerHandler() {
-    const workerCount = this.workerCount
-
-    this.workerCount++
-
-    const Handler = this.inProcess ? InProcessHandler : WorkerHandler
-    const workerHandler = this.workerHandlerFactory
-      ? this.workerHandlerFactory({configuration: this.configuration, workerCount})
-      : new Handler({
-        configuration: this.configuration,
-        workerCount
-      })
-
-    await workerHandler.start()
-
-    return workerHandler
-  }
-
-  /**
-   * Runs worker handler to use.
-   * @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
+    /**
+     * Runs worker handler to use.
+     * @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();
+    }
+    /**
+     * Runs next round robin worker handler.
+     * @returns {WorkerHandler | InProcessHandler} - The next round-robin worker handler.
+     */
+    _nextRoundRobinWorkerHandler() {
+        this.logger.debug(`Worker handlers length: ${this.workerHandlers.length}`);
+        const workerHandlerIndex = this.nextWorkerHandlerIndex % this.workerHandlers.length;
+        const workerHandler = this.workerHandlers[workerHandlerIndex];
+        if (!workerHandler) {
+            throw new Error(`No workerHandler by that number: ${workerHandlerIndex}`);
+        }
+        this.nextWorkerHandlerIndex += 1;
+        return workerHandler;
     }
-
-    return this._nextRoundRobinWorkerHandler()
-  }
-
-  /**
-   * Runs next round robin worker handler.
-   * @returns {WorkerHandler | InProcessHandler} - The next round-robin worker handler.
-   */
-  _nextRoundRobinWorkerHandler() {
-    this.logger.debug(`Worker handlers length: ${this.workerHandlers.length}`)
-
-    const workerHandlerIndex = this.nextWorkerHandlerIndex % this.workerHandlers.length
-    const workerHandler = this.workerHandlers[workerHandlerIndex]
-
-    if (!workerHandler) {
-      throw new Error(`No workerHandler by that number: ${workerHandlerIndex}`)
+    /**
+     * Runs should use development hot reload.
+     * @returns {boolean} - Whether development worker hot reload should run.
+     */
+    shouldUseDevelopmentHotReload() {
+        return !this.inProcess && this.configuration.getEnvironment() === "development";
     }
-
-    this.nextWorkerHandlerIndex += 1
-
-    return workerHandler
-  }
-
-  /**
-   * Runs should use development hot reload.
-   * @returns {boolean} - Whether development worker hot reload should run.
-   */
-  shouldUseDevelopmentHotReload() {
-    return !this.inProcess && this.configuration.getEnvironment() === "development"
-  }
-
-  /**
-   * Runs start development reloader.
-   * @returns {Promise<void>} - Resolves when watcher setup finishes.
-   */
-  async _startDevelopmentReloader() {
-    if (!this.shouldUseDevelopmentHotReload()) return
-    if (this.developmentReloader) return
-
-    const createDevelopmentReloader = this.developmentReloaderFactory
-      || ((args) => new DevelopmentReloader(args))
-
-    this.developmentReloader = createDevelopmentReloader({
-      configuration: this.configuration,
-      onReload: async ({changedPath}) => {
-        await this.logger.info(`Development hot reload detected change in ${changedPath}`)
-        await this.reloadWorkersForDevelopment()
-      }
-    })
-
-    await this.developmentReloader.start()
-  }
-
-  /**
-   * Runs reload workers for development.
-   * @returns {Promise<void>} - Resolves when workers have been refreshed.
-   */
-  async reloadWorkersForDevelopment() {
-    if (this._stopping) return
-
-    if (this._reloadingWorkersForDevelopment) {
-      this._reloadWorkersForDevelopmentQueued = true
-      return
+    /**
+     * Runs start development reloader.
+     * @returns {Promise<void>} - Resolves when watcher setup finishes.
+     */
+    async _startDevelopmentReloader() {
+        if (!this.shouldUseDevelopmentHotReload())
+            return;
+        if (this.developmentReloader)
+            return;
+        const createDevelopmentReloader = this.developmentReloaderFactory
+            || ((args) => new DevelopmentReloader(args));
+        this.developmentReloader = createDevelopmentReloader({
+            configuration: this.configuration,
+            onReload: async ({ changedPath }) => {
+                await this.logger.info(`Development hot reload detected change in ${changedPath}`);
+                await this.reloadWorkersForDevelopment();
+            }
+        });
+        await this.developmentReloader.start();
     }
-
-    this._reloadingWorkersForDevelopment = true
-
-    try {
-      do {
-        this._reloadWorkersForDevelopmentQueued = false
-
-        const oldWorkerHandlers = [...this.workerHandlers]
-        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)
-    } finally {
-      this._reloadingWorkersForDevelopment = false
+    /**
+     * Runs reload workers for development.
+     * @returns {Promise<void>} - Resolves when workers have been refreshed.
+     */
+    async reloadWorkersForDevelopment() {
+        if (this._stopping)
+            return;
+        if (this._reloadingWorkersForDevelopment) {
+            this._reloadWorkersForDevelopmentQueued = true;
+            return;
+        }
+        this._reloadingWorkersForDevelopment = true;
+        try {
+            do {
+                this._reloadWorkersForDevelopmentQueued = false;
+                const oldWorkerHandlers = [...this.workerHandlers];
+                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);
+        }
+        finally {
+            this._reloadingWorkersForDevelopment = false;
+        }
     }
-  }
 }
+//# 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/**\n * Defines this typedef.\n  @typedef {{start: () => Promise<void>, stop: () => Promise<void>}} DevelopmentReloaderLike */\n/**\n * Defines this typedef.\n  @typedef {function({configuration: import(\"../configuration.js\").default, workerCount: number}) : (WorkerHandler | InProcessHandler)} WorkerHandlerFactory */\n\n/**\n * Runs normalize worker count.\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  /**\n   * Narrows the runtime value to the documented type.\n    @type {DevelopmentReloader | DevelopmentReloaderLike | undefined} */\n  developmentReloader\n\n  /**\n   * Narrows the runtime value to the documented type.\n    @type {import(\"net\").Server | undefined} */\n  netServer\n\n  /**\n   * Narrows the runtime value to the documented type.\n    @type {WorkerHandlerFactory | undefined} */\n  workerHandlerFactory\n\n  /**\n   * Clients.\n    @type {Record<string, ServerClient>}  */\n  clients = {}\n\n  /**\n   * Active sockets.\n    @type {Set<import(\"net\").Socket>} */\n  _activeSockets = new Set()\n\n  events = new EventEmitter()\n  workerCount = 0\n\n  /**\n   * Worker handlers.\n    @type {Array<WorkerHandler | InProcessHandler>} */\n  workerHandlers = []\n  nextWorkerHandlerIndex = 0\n  /**\n   * Sticky worker handlers.\n    @type {Map<string, WorkerHandler | InProcessHandler>} */\n  stickyWorkerHandlers = new Map()\n\n  /**\n   * Runs constructor.\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  /**\n   * Runs start.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\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      /**\n       * Net server.\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  /**\n   * Runs capture startup state.\n   * @returns {{developmentReloader: DevelopmentReloader | DevelopmentReloaderLike | undefined, netServer: import(\"net\").Server | undefined, workerHandlers: Array<WorkerHandler | InProcessHandler>}} - Startup state.\n   */\n  _captureStartupState() {\n    return {\n      developmentReloader: this.developmentReloader,\n      netServer: this.netServer,\n      workerHandlers: [...this.workerHandlers]\n    }\n  }\n\n  /**\n   * Runs stop startup resources.\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    /**\n     * Startup net server.\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  /**\n   * Runs net server listen.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  _netServerListen() {\n    return new Promise((resolve, reject) => {\n      if (!this.netServer) throw new Error(\"No netServer\")\n\n      /**\n       * On listen error.\n       * @param {Error} error - Listen error.\n       */\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  /**\n   * Runs ensure workers.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _ensureWorkers() {\n    while (this.workerHandlers.length < this.workers) {\n      await this.spawnWorker()\n    }\n  }\n\n  /**\n   * Runs is active.\n   * @returns {boolean} - Whether active.\n   */\n  isActive() {\n    if (this.netServer) {\n      return this.netServer.listening\n    }\n\n    return false\n  }\n\n  /**\n   * Runs get debug snapshot.\n   * @returns {Promise<Record<string, ?>>} - HTTP server worker diagnostics.\n   */\n  async getDebugSnapshot() {\n    return {\n      active: this.isActive(),\n      activeSocketCount: this._activeSockets.size,\n      clientCount: Object.keys(this.clients).length,\n      configuredWorkerCount: this.workers,\n      inProcess: this.inProcess,\n      workerCount: this.workerHandlers.length,\n      workers: await Promise.all(this.workerHandlers.map((handler) => this.workerDebugSnapshot(handler)))\n    }\n  }\n\n  /**\n   * Runs worker debug snapshot.\n   * @param {WorkerHandler | InProcessHandler} workerHandler - Worker handler to inspect.\n   * @returns {Promise<Record<string, ?>>} Worker debug snapshot.\n   */\n  async workerDebugSnapshot(workerHandler) {\n    if (workerHandler instanceof WorkerHandler) return await workerHandler.getDebugSnapshot()\n    if (workerHandler instanceof InProcessHandler) return this.inProcessWorkerDebugSnapshot(workerHandler)\n\n    return {active: false, error: \"Unknown worker handler type\"}\n  }\n\n  /**\n   * Runs in process worker debug snapshot.\n   * @param {InProcessHandler} workerHandler - In-process worker handler to inspect.\n   * @returns {Record<string, ?>} Worker debug snapshot.\n   */\n  inProcessWorkerDebugSnapshot(workerHandler) {\n    return {\n      active: true,\n      clientCount: Object.keys(workerHandler.clients).length,\n      snapshot: workerHandler.configuration.getLocalDebugSnapshot(),\n      workerCount: workerHandler.workerCount\n    }\n  }\n\n  /**\n   * Runs stop clients.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\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   * Runs stop server.\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  /**\n   * Runs stop.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\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  /**\n   * On close.\n   * @returns {void} - No return value.\n   */\n  onClose = () => {\n    this.events.emit(\"close\")\n  }\n\n  /**\n   * On server error.\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   * On connection.\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   * On client close.\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  /**\n   * Runs spawn worker.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async spawnWorker() {\n    const workerHandler = await this._buildWorkerHandler()\n\n    this.workerHandlers.push(workerHandler)\n  }\n\n  /**\n   * Runs build worker handlers.\n   * @returns {Promise<Array<WorkerHandler | InProcessHandler>>} - Started worker handlers.\n   */\n  async _buildWorkerHandlers() {\n    /**\n     * Worker handlers.\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  /**\n   * Runs build worker handler.\n   * @returns {Promise<WorkerHandler | InProcessHandler>} - Started worker handler.\n   */\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   * Runs worker handler to use.\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  /**\n   * Runs next round robin worker handler.\n   * @returns {WorkerHandler | InProcessHandler} - The next round-robin worker handler.\n   */\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  /**\n   * Runs should use development hot reload.\n   * @returns {boolean} - Whether development worker hot reload should run.\n   */\n  shouldUseDevelopmentHotReload() {\n    return !this.inProcess && this.configuration.getEnvironment() === \"development\"\n  }\n\n  /**\n   * Runs start development reloader.\n   * @returns {Promise<void>} - Resolves when watcher setup finishes.\n   */\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  /**\n   * Runs reload workers for development.\n   * @returns {Promise<void>} - Resolves when workers have been refreshed.\n   */\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"]}