velocious 1.0.291 → 1.0.293

package/build/src/http-server/development-reloader.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Development-only file watcher that asks the HTTP server to recycle workers
+ * when application source files change.
+ */
+export default class VelociousHttpServerDevelopmentReloader {
+    /**
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {function({changedPath: string}) : Promise<void>} args.onReload - Reload callback.
+     * @param {number} [args.debounceMs] - Debounce window for grouped changes.
+     * @param {typeof fsWatch} [args.watchFactory] - File watch factory.
+     * @param {typeof fs.readdir} [args.readdir] - Directory reader.
+     * @param {typeof fs.stat} [args.stat] - Stat reader.
+     */
+    constructor({ configuration, onReload, debounceMs, watchFactory, readdir, stat }: {
+        configuration: import("../configuration.js").default;
+        onReload: (arg0: {
+            changedPath: string;
+        }) => Promise<void>;
+        debounceMs?: number | undefined;
+        watchFactory?: typeof fsWatch | undefined;
+        readdir?: typeof fs.readdir | undefined;
+        stat?: typeof fs.stat | undefined;
+    });
+    configuration: import("../configuration.js").default;
+    debounceMs: number;
+    logger: Logger;
+    onReload: (arg0: {
+        changedPath: string;
+    }) => Promise<void>;
+    readdir: typeof fs.readdir;
+    stat: typeof fs.stat;
+    watchFactory: typeof fsWatch;
+    /** @type {ReturnType<typeof setTimeout> | undefined} */
+    reloadTimer: ReturnType<typeof setTimeout> | undefined;
+    /** @type {string | undefined} */
+    pendingChangedPath: string | undefined;
+    /** @type {Map<string, import("fs").FSWatcher>} */
+    watchers: Map<string, import("fs").FSWatcher>;
+    /** @returns {Promise<void>} - Resolves when watching has started. */
+    start(): Promise<void>;
+    /** @returns {string[]} - Source directories to watch. */
+    watchRootPaths(): string[];
+    /**
+     * @param {string} directoryPath - Directory path.
+     * @returns {Promise<void>} - Resolves when child directories are watched.
+     */
+    watchDirectoryRecursive(directoryPath: string): Promise<void>;
+    /**
+     * @param {object} args - Options object.
+     * @param {string} args.directoryPath - Watched directory path.
+     * @param {string} args.eventType - Watch event type.
+     * @param {string | Buffer | null} args.fileName - Relative changed filename.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    onWatcherEvent({ directoryPath, eventType, fileName }: {
+        directoryPath: string;
+        eventType: string;
+        fileName: string | Buffer | null;
+    }): Promise<void>;
+    /**
+     * @param {object} args - Options object.
+     * @param {string} args.changedPath - Changed path.
+     * @param {string | Buffer | null} args.fileName - Raw filename from fs.watch.
+     * @returns {boolean} - Whether the path should trigger reload.
+     */
+    shouldReloadPath({ changedPath, fileName }: {
+        changedPath: string;
+        fileName: string | Buffer | null;
+    }): boolean;
+    /**
+     * @param {string} changedPath - Candidate directory path.
+     * @returns {Promise<void>} - Resolves when any new directory watchers are added.
+     */
+    watchPotentialDirectory(changedPath: string): Promise<void>;
+    /**
+     * @param {string} changedPath - Changed path.
+     * @returns {void} - No return value.
+     */
+    scheduleReload(changedPath: string): void;
+    /** @returns {Promise<void>} - Resolves when the queued reload is handled. */
+    flushReload(): Promise<void>;
+    /**
+     * @param {Error} error - Watcher error.
+     * @returns {void} - No return value.
+     */
+    onWatcherError: (error: Error) => void;
+    /** @returns {Promise<void>} - Resolves when watchers are closed. */
+    stop(): Promise<void>;
+}
+import Logger from "../logger.js";
+import fs from "fs/promises";
+import { watch as fsWatch } from "fs";
+//# sourceMappingURL=development-reloader.d.ts.map

package/build/src/http-server/development-reloader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"development-reloader.d.ts","sourceRoot":"","sources":["../../../src/http-server/development-reloader.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IACE;;;;;;;;OAQG;IACH,kFAPG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACiB,QAAQ,EAA9D,CAAS,IAAqB,EAArB;YAAC,WAAW,EAAE,MAAM,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC;QACjC,UAAU;QACF,YAAY;QACT,OAAO;QACV,IAAI;KACpC,EAkBA;IAhBC,qDAAkC;IAClC,mBAA4B;IAC5B,eAAgE;IAChE,iBAVkB;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAUhC;IACxB,2BAAsB;IACtB,qBAAgB;IAChB,6BAAgC;IAEhC,wDAAwD;IACxD,aADW,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,SAAS,CACxB;IAE5B,iCAAiC;IACjC,oBADW,MAAM,GAAG,SAAS,CACM;IAEnC,kDAAkD;IAClD,UADW,GAAG,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE,SAAS,CAAC,CACrB;IAG3B,qEAAqE;IACrE,SADc,OAAO,CAAC,IAAI,CAAC,CAK1B;IAED,yDAAyD;IACzD,kBADc,MAAM,EAAE,CAarB;IAED;;;OAGG;IACH,uCAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAgCzB;IAED;;;;;;OAMG;IACH,uDALG;QAAqB,aAAa,EAA1B,MAAM;QACO,SAAS,EAAtB,MAAM;QACuB,QAAQ,EAArC,MAAM,GAAG,MAAM,GAAG,IAAI;KAC9B,GAAU,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;;;;OAKG;IACH,4CAJG;QAAqB,WAAW,EAAxB,MAAM;QACuB,QAAQ,EAArC,MAAM,GAAG,MAAM,GAAG,IAAI;KAC9B,GAAU,OAAO,CAQnB;IAED;;;OAGG;IACH,qCAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;;OAGG;IACH,4BAHW,MAAM,GACJ,IAAI,CAYhB;IAED,6EAA6E;IAC7E,eADc,OAAO,CAAC,IAAI,CAAC,CAU1B;IAED;;;OAGG;IACH,iBAAkB,OAHP,KAGY,KAFV,IAAI,CAIhB;IAED,oEAAoE;IACpE,QADc,OAAO,CAAC,IAAI,CAAC,CAc1B;CACF;mBA9MkB,cAAc;eADlB,aAAa;iCADG,IAAI"}

package/build/src/http-server/development-reloader.js

@@ -0,0 +1,180 @@
+// @ts-check
+import { watch as fsWatch } from "fs";
+import fs from "fs/promises";
+import Logger from "../logger.js";
+import path from "path";
+const RELOADABLE_EXTENSIONS = new Set([
+    ".cjs",
+    ".ejs",
+    ".js",
+    ".json",
+    ".mjs"
+]);
+/**
+ * Development-only file watcher that asks the HTTP server to recycle workers
+ * when application source files change.
+ */
+export default class VelociousHttpServerDevelopmentReloader {
+    /**
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {function({changedPath: string}) : Promise<void>} args.onReload - Reload callback.
+     * @param {number} [args.debounceMs] - Debounce window for grouped changes.
+     * @param {typeof fsWatch} [args.watchFactory] - File watch factory.
+     * @param {typeof fs.readdir} [args.readdir] - Directory reader.
+     * @param {typeof fs.stat} [args.stat] - Stat reader.
+     */
+    constructor({ configuration, onReload, debounceMs = 75, watchFactory = fsWatch, readdir = fs.readdir, stat = fs.stat }) {
+        this.configuration = configuration;
+        this.debounceMs = debounceMs;
+        this.logger = new Logger("DevelopmentReloader", { configuration });
+        this.onReload = onReload;
+        this.readdir = readdir;
+        this.stat = stat;
+        this.watchFactory = watchFactory;
+        /** @type {ReturnType<typeof setTimeout> | undefined} */
+        this.reloadTimer = undefined;
+        /** @type {string | undefined} */
+        this.pendingChangedPath = undefined;
+        /** @type {Map<string, import("fs").FSWatcher>} */
+        this.watchers = new Map();
+    }
+    /** @returns {Promise<void>} - Resolves when watching has started. */
+    async start() {
+        for (const rootPath of this.watchRootPaths()) {
+            await this.watchDirectoryRecursive(rootPath);
+        }
+    }
+    /** @returns {string[]} - Source directories to watch. */
+    watchRootPaths() {
+        const rootPaths = new Set();
+        const configurationDirectory = this.configuration.getDirectory();
+        rootPaths.add(path.join(configurationDirectory, "src"));
+        for (const backendProject of this.configuration.getBackendProjects()) {
+            if (!backendProject?.path)
+                continue;
+            rootPaths.add(path.join(backendProject.path, "src"));
+        }
+        return Array.from(rootPaths);
+    }
+    /**
+     * @param {string} directoryPath - Directory path.
+     * @returns {Promise<void>} - Resolves when child directories are watched.
+     */
+    async watchDirectoryRecursive(directoryPath) {
+        const resolvedDirectoryPath = path.resolve(directoryPath);
+        if (this.watchers.has(resolvedDirectoryPath))
+            return;
+        let entries;
+        try {
+            entries = await this.readdir(resolvedDirectoryPath, { withFileTypes: true });
+        }
+        catch (error) {
+            if ( /** @type {{code?: string}} */(error)?.code === "ENOENT")
+                return;
+            throw error;
+        }
+        const watcher = this.watchFactory(resolvedDirectoryPath, (eventType, fileName) => {
+            void this.onWatcherEvent({
+                directoryPath: resolvedDirectoryPath,
+                eventType,
+                fileName
+            });
+        });
+        watcher.on("error", this.onWatcherError);
+        this.watchers.set(resolvedDirectoryPath, watcher);
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            await this.watchDirectoryRecursive(path.join(resolvedDirectoryPath, entry.name));
+        }
+    }
+    /**
+     * @param {object} args - Options object.
+     * @param {string} args.directoryPath - Watched directory path.
+     * @param {string} args.eventType - Watch event type.
+     * @param {string | Buffer | null} args.fileName - Relative changed filename.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async onWatcherEvent({ directoryPath, eventType, fileName }) {
+        const changedPath = fileName
+            ? path.join(directoryPath, fileName.toString())
+            : directoryPath;
+        await this.watchPotentialDirectory(changedPath);
+        if (!this.shouldReloadPath({ changedPath, fileName }))
+            return;
+        this.scheduleReload(changedPath);
+        await this.logger.debug(() => ["Queued development hot reload", { changedPath, eventType }]);
+    }
+    /**
+     * @param {object} args - Options object.
+     * @param {string} args.changedPath - Changed path.
+     * @param {string | Buffer | null} args.fileName - Raw filename from fs.watch.
+     * @returns {boolean} - Whether the path should trigger reload.
+     */
+    shouldReloadPath({ changedPath, fileName }) {
+        if (!fileName)
+            return true;
+        const extension = path.extname(changedPath).toLowerCase();
+        return RELOADABLE_EXTENSIONS.has(extension);
+    }
+    /**
+     * @param {string} changedPath - Candidate directory path.
+     * @returns {Promise<void>} - Resolves when any new directory watchers are added.
+     */
+    async watchPotentialDirectory(changedPath) {
+        try {
+            const stat = await this.stat(changedPath);
+            if (stat.isDirectory()) {
+                await this.watchDirectoryRecursive(changedPath);
+            }
+        }
+        catch (error) {
+            if ( /** @type {{code?: string}} */(error)?.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    /**
+     * @param {string} changedPath - Changed path.
+     * @returns {void} - No return value.
+     */
+    scheduleReload(changedPath) {
+        this.pendingChangedPath = changedPath;
+        if (this.reloadTimer) {
+            clearTimeout(this.reloadTimer);
+        }
+        this.reloadTimer = setTimeout(() => {
+            void this.flushReload();
+        }, this.debounceMs);
+    }
+    /** @returns {Promise<void>} - Resolves when the queued reload is handled. */
+    async flushReload() {
+        this.reloadTimer = undefined;
+        const changedPath = this.pendingChangedPath;
+        if (!changedPath)
+            return;
+        this.pendingChangedPath = undefined;
+        await this.onReload({ changedPath });
+    }
+    /**
+     * @param {Error} error - Watcher error.
+     * @returns {void} - No return value.
+     */
+    onWatcherError = (error) => {
+        void this.logger.warn("Development hot reload watcher error", error);
+    };
+    /** @returns {Promise<void>} - Resolves when watchers are closed. */
+    async stop() {
+        if (this.reloadTimer) {
+            clearTimeout(this.reloadTimer);
+            this.reloadTimer = undefined;
+        }
+        this.pendingChangedPath = undefined;
+        for (const watcher of this.watchers.values()) {
+            watcher.close();
+        }
+        this.watchers.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"development-reloader.js","sourceRoot":"","sources":["../../../src/http-server/development-reloader.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {watch as fsWatch} from \"fs\"\nimport fs from \"fs/promises\"\nimport Logger from \"../logger.js\"\nimport path from \"path\"\n\nconst RELOADABLE_EXTENSIONS = new Set([\n  \".cjs\",\n  \".ejs\",\n  \".js\",\n  \".json\",\n  \".mjs\"\n])\n\n/**\n * Development-only file watcher that asks the HTTP server to recycle workers\n * when application source files change.\n */\nexport default class VelociousHttpServerDevelopmentReloader {\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {function({changedPath: string}) : Promise<void>} args.onReload - Reload callback.\n   * @param {number} [args.debounceMs] - Debounce window for grouped changes.\n   * @param {typeof fsWatch} [args.watchFactory] - File watch factory.\n   * @param {typeof fs.readdir} [args.readdir] - Directory reader.\n   * @param {typeof fs.stat} [args.stat] - Stat reader.\n   */\n  constructor({configuration, onReload, debounceMs = 75, watchFactory = fsWatch, readdir = fs.readdir, stat = fs.stat}) {\n    this.configuration = configuration\n    this.debounceMs = debounceMs\n    this.logger = new Logger(\"DevelopmentReloader\", {configuration})\n    this.onReload = onReload\n    this.readdir = readdir\n    this.stat = stat\n    this.watchFactory = watchFactory\n\n    /** @type {ReturnType<typeof setTimeout> | undefined} */\n    this.reloadTimer = undefined\n\n    /** @type {string | undefined} */\n    this.pendingChangedPath = undefined\n\n    /** @type {Map<string, import(\"fs\").FSWatcher>} */\n    this.watchers = new Map()\n  }\n\n  /** @returns {Promise<void>} - Resolves when watching has started. */\n  async start() {\n    for (const rootPath of this.watchRootPaths()) {\n      await this.watchDirectoryRecursive(rootPath)\n    }\n  }\n\n  /** @returns {string[]} - Source directories to watch. */\n  watchRootPaths() {\n    const rootPaths = new Set()\n    const configurationDirectory = this.configuration.getDirectory()\n\n    rootPaths.add(path.join(configurationDirectory, \"src\"))\n\n    for (const backendProject of this.configuration.getBackendProjects()) {\n      if (!backendProject?.path) continue\n      rootPaths.add(path.join(backendProject.path, \"src\"))\n    }\n\n    return Array.from(rootPaths)\n  }\n\n  /**\n   * @param {string} directoryPath - Directory path.\n   * @returns {Promise<void>} - Resolves when child directories are watched.\n   */\n  async watchDirectoryRecursive(directoryPath) {\n    const resolvedDirectoryPath = path.resolve(directoryPath)\n\n    if (this.watchers.has(resolvedDirectoryPath)) return\n\n    let entries\n\n    try {\n      entries = await this.readdir(resolvedDirectoryPath, {withFileTypes: true})\n    } catch (error) {\n      if (/** @type {{code?: string}} */ (error)?.code === \"ENOENT\") return\n      throw error\n    }\n\n    const watcher = this.watchFactory(resolvedDirectoryPath, (eventType, fileName) => {\n      void this.onWatcherEvent({\n        directoryPath: resolvedDirectoryPath,\n        eventType,\n        fileName\n      })\n    })\n\n    watcher.on(\"error\", this.onWatcherError)\n    this.watchers.set(resolvedDirectoryPath, watcher)\n\n    for (const entry of entries) {\n      if (!entry.isDirectory()) continue\n\n      await this.watchDirectoryRecursive(path.join(resolvedDirectoryPath, entry.name))\n    }\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.directoryPath - Watched directory path.\n   * @param {string} args.eventType - Watch event type.\n   * @param {string | Buffer | null} args.fileName - Relative changed filename.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async onWatcherEvent({directoryPath, eventType, fileName}) {\n    const changedPath = fileName\n      ? path.join(directoryPath, fileName.toString())\n      : directoryPath\n\n    await this.watchPotentialDirectory(changedPath)\n\n    if (!this.shouldReloadPath({changedPath, fileName})) return\n\n    this.scheduleReload(changedPath)\n\n    await this.logger.debug(() => [\"Queued development hot reload\", {changedPath, eventType}])\n  }\n\n  /**\n   * @param {object} args - Options object.\n   * @param {string} args.changedPath - Changed path.\n   * @param {string | Buffer | null} args.fileName - Raw filename from fs.watch.\n   * @returns {boolean} - Whether the path should trigger reload.\n   */\n  shouldReloadPath({changedPath, fileName}) {\n    if (!fileName) return true\n\n    const extension = path.extname(changedPath).toLowerCase()\n\n    return RELOADABLE_EXTENSIONS.has(extension)\n  }\n\n  /**\n   * @param {string} changedPath - Candidate directory path.\n   * @returns {Promise<void>} - Resolves when any new directory watchers are added.\n   */\n  async watchPotentialDirectory(changedPath) {\n    try {\n      const stat = await this.stat(changedPath)\n\n      if (stat.isDirectory()) {\n        await this.watchDirectoryRecursive(changedPath)\n      }\n    } catch (error) {\n      if (/** @type {{code?: string}} */ (error)?.code !== \"ENOENT\") {\n        throw error\n      }\n    }\n  }\n\n  /**\n   * @param {string} changedPath - Changed path.\n   * @returns {void} - No return value.\n   */\n  scheduleReload(changedPath) {\n    this.pendingChangedPath = changedPath\n\n    if (this.reloadTimer) {\n      clearTimeout(this.reloadTimer)\n    }\n\n    this.reloadTimer = setTimeout(() => {\n      void this.flushReload()\n    }, this.debounceMs)\n  }\n\n  /** @returns {Promise<void>} - Resolves when the queued reload is handled. */\n  async flushReload() {\n    this.reloadTimer = undefined\n\n    const changedPath = this.pendingChangedPath\n\n    if (!changedPath) return\n\n    this.pendingChangedPath = undefined\n    await this.onReload({changedPath})\n  }\n\n  /**\n   * @param {Error} error - Watcher error.\n   * @returns {void} - No return value.\n   */\n  onWatcherError = (error) => {\n    void this.logger.warn(\"Development hot reload watcher error\", error)\n  }\n\n  /** @returns {Promise<void>} - Resolves when watchers are closed. */\n  async stop() {\n    if (this.reloadTimer) {\n      clearTimeout(this.reloadTimer)\n      this.reloadTimer = undefined\n    }\n\n    this.pendingChangedPath = undefined\n\n    for (const watcher of this.watchers.values()) {\n      watcher.close()\n    }\n\n    this.watchers.clear()\n  }\n}\n"]}

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

@@ -6,13 +6,23 @@ 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 {function({configuration: import("../configuration.js").default, onReload: function({changedPath: string}) : Promise<void>}) : {start: () => Promise<void>, stop: () => Promise<void>}} [args.developmentReloaderFactory] - Development reloader factory.
      */
-    constructor({ configuration, host, inProcess, maxWorkers, port }: {
+    constructor({ configuration, developmentReloaderFactory, host, inProcess, maxWorkers, port }: {
         configuration: import("../configuration.js").default;
         host?: string | undefined;
         inProcess?: boolean | undefined;
         port?: number | undefined;
         maxWorkers?: number | undefined;
+        developmentReloaderFactory?: ((arg0: {
+            configuration: import("../configuration.js").default;
+            onReload: (arg0: {
+                changedPath: string;
+            }) => Promise<void>;
+        }) => {
+            start: () => Promise<void>;
+            stop: () => Promise<void>;
+        }) | undefined;
     });
     clientCount: number;
     /** @type {Record<string, ServerClient>}  */
@@ -22,6 +32,15 @@ export default class VelociousHttpServer {
     /** @type {Array<WorkerHandler | InProcessHandler>} */
     workerHandlers: Array<WorkerHandler | InProcessHandler>;
     configuration: import("../configuration.js").default;
+    developmentReloaderFactory: ((arg0: {
+        configuration: import("../configuration.js").default;
+        onReload: (arg0: {
+            changedPath: string;
+        }) => Promise<void>;
+    }) => {
+        start: () => Promise<void>;
+        stop: () => Promise<void>;
+    }) | undefined;
     inProcess: boolean;
     logger: Logger;
     host: string;
@@ -42,6 +61,11 @@ export default class VelociousHttpServer {
     stopServer(): Promise<void>;
     /** @returns {Promise<void>} - Resolves when complete.  */
     stop(): Promise<void>;
+    _stopping: boolean | undefined;
+    developmentReloader: {
+        start: () => Promise<void>;
+        stop: () => Promise<void>;
+    } | undefined;
     /** @returns {void} - No return value.  */
     onClose: () => void;
     /**
@@ -61,8 +85,18 @@ export default class VelociousHttpServer {
     onClientClose: (client: ServerClient) => void;
     /** @returns {Promise<void>} - Resolves when complete.  */
     spawnWorker(): Promise<void>;
+    /** @returns {Promise<WorkerHandler | InProcessHandler>} - Started worker handler. */
+    _buildWorkerHandler(): Promise<WorkerHandler | InProcessHandler>;
     /** @returns {WorkerHandler | InProcessHandler} - The worker handler to use. */
     workerHandlerToUse(): WorkerHandler | InProcessHandler;
+    /** @returns {boolean} - Whether development worker hot reload should run. */
+    shouldUseDevelopmentHotReload(): boolean;
+    /** @returns {Promise<void>} - Resolves when watcher setup finishes. */
+    _startDevelopmentReloader(): Promise<void>;
+    /** @returns {Promise<void>} - Resolves when workers have been refreshed. */
+    reloadWorkersForDevelopment(): Promise<void>;
+    _reloadWorkersForDevelopmentQueued: boolean | undefined;
+    _reloadingWorkersForDevelopment: boolean | undefined;
 }
 import ServerClient from "./server-client.js";
 import WorkerHandler from "./worker-handler/index.js";

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":"AAUA;IAYE;;;;;;;OAOG;IACH,kEANG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI;QACH,SAAS;QACV,IAAI;QACJ,UAAU;KAClC,EAQA;IA1BD,oBAAe;IAEf,4CAA4C;IAC5C,SADW,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAC3B;IAEZ,mEAA2B;IAC3B,oBAAe;IAEf,sDAAsD;IACtD,gBADW,KAAK,CAAC,aAAa,GAAG,gBAAgB,CAAC,CAC/B;IAWjB,qDAAkC;IAClC,mBAAmC;IACnC,eAA8B;IAC9B,aAA6B;IAC7B,aAAwB;IACxB,mBAAkC;IAGpC,0DAA0D;IAC1D,SADc,OAAO,CAAC,IAAI,CAAC,CAQ1B;IALC,kCAAiC;IAOnC,0DAA0D;IAC1D,oBADc,OAAO,CAAC,IAAI,CAAC,CAc1B;IAED,0DAA0D;IAC1D,2BADc,OAAO,CAAC,IAAI,CAAC,CAK1B;IAED,4CAA4C;IAC5C,YADc,OAAO,CAOpB;IAED,0DAA0D;IAC1D,eADc,OAAO,CAAC,IAAI,CAAC,CAW1B;IAED,0DAA0D;IAC1D,cADc,OAAO,CAAC,IAAI,CAAC,CAgB1B;IAED,0DAA0D;IAC1D,QADc,OAAO,CAAC,IAAI,CAAC,CAQ1B;IAED,0CAA0C;IAC1C,eADc,IAAI,CAGjB;IAED;;;OAGG;IACH,gBAAiB,OAHN,KAGW,KAFT,IAAI,CAIhB;IAED;;;OAGG;IACH,eAAgB,QAHL,OAAO,KAAK,EAAE,MAGH,KAFT,IAAI,CA8BhB;IAED;;;OAGG;IACH,gBAAiB,QAHN,YAGY,KAFV,IAAI,CAahB;IAED,0DAA0D;IAC1D,eADc,OAAO,CAAC,IAAI,CAAC,CAc1B;IAED,+EAA+E;IAC/E,sBADc,aAAa,GAAG,gBAAgB,CAY7C;CACF;yBAhNwB,oBAAoB;0BACnB,2BAA2B;6BAJxB,gCAAgC;mBAC1C,cAAc;gBACjB,KAAK"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/http-server/index.js"],"names":[],"mappings":"AAWA;IAYE;;;;;;;;OAQG;IACH,8FAPG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI;QACH,SAAS;QACV,IAAI;QACJ,UAAU;QACqK,0BAA0B,WAA9M;YAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;YAAC,QAAQ,EAAE,CAAS,IAAqB,EAArB;gBAAC,WAAW,EAAE,MAAM,CAAA;aAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAAA;SAAC,KAAI;YAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;YAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;SAAC;KAC/L,EASA;IA5BD,oBAAe;IAEf,4CAA4C;IAC5C,SADW,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAC3B;IAEZ,mEAA2B;IAC3B,oBAAe;IAEf,sDAAsD;IACtD,gBADW,KAAK,CAAC,aAAa,GAAG,gBAAgB,CAAC,CAC/B;IAYjB,qDAAkC;IAClC,oCAJkB;QAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,CAAS,IAAqB,EAArB;YAAC,WAAW,EAAE,MAAM,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KAAC,KAAI;QAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAC,cAIlI;IAC5D,mBAAmC;IACnC,eAA8B;IAC9B,aAA6B;IAC7B,aAAwB;IACxB,mBAAkC;IAGpC,0DAA0D;IAC1D,SADc,OAAO,CAAC,IAAI,CAAC,CAS1B;IALC,kCAAiC;IAOnC,0DAA0D;IAC1D,oBADc,OAAO,CAAC,IAAI,CAAC,CAc1B;IAED,0DAA0D;IAC1D,2BADc,OAAO,CAAC,IAAI,CAAC,CAK1B;IAED,4CAA4C;IAC5C,YADc,OAAO,CAOpB;IAED,0DAA0D;IAC1D,eADc,OAAO,CAAC,IAAI,CAAC,CAW1B;IAED,0DAA0D;IAC1D,cADc,OAAO,CAAC,IAAI,CAAC,CAgB1B;IAED,0DAA0D;IAC1D,QADc,OAAO,CAAC,IAAI,CAAC,CAW1B;IATC,+BAAqB;IAErB;eA1F+I,MAAM,OAAO,CAAC,IAAI,CAAC;cAAQ,MAAM,OAAO,CAAC,IAAI,CAAC;kBA0FzJ;IAStC,0CAA0C;IAC1C,eADc,IAAI,CAGjB;IAED;;;OAGG;IACH,gBAAiB,OAHN,KAGW,KAFT,IAAI,CAIhB;IAED;;;OAGG;IACH,eAAgB,QAHL,OAAO,KAAK,EAAE,MAGH,KAFT,IAAI,CA8BhB;IAED;;;OAGG;IACH,gBAAiB,QAHN,YAGY,KAFV,IAAI,CAahB;IAED,0DAA0D;IAC1D,eADc,OAAO,CAAC,IAAI,CAAC,CAK1B;IAED,qFAAqF;IACrF,uBADc,OAAO,CAAC,aAAa,GAAG,gBAAgB,CAAC,CAetD;IAED,+EAA+E;IAC/E,sBADc,aAAa,GAAG,gBAAgB,CAY7C;IAED,6EAA6E;IAC7E,iCADc,OAAO,CAGpB;IAED,uEAAuE;IACvE,6BADc,OAAO,CAAC,IAAI,CAAC,CAiB1B;IAED,4EAA4E;IAC5E,+BADc,OAAO,CAAC,IAAI,CAAC,CAyB1B;IApBG,wDAA8C;IAIhD,qDAA2C;CAiB9C;yBAjRwB,oBAAoB;0BACnB,2BAA2B;6BAJxB,gCAAgC;mBAC1C,cAAc;gBACjB,KAAK"}

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

@@ -1,5 +1,6 @@
 // @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";
@@ -21,9 +22,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 {function({configuration: import("../configuration.js").default, onReload: function({changedPath: string}) : Promise<void>}) : {start: () => Promise<void>, stop: () => Promise<void>}} [args.developmentReloaderFactory] - Development reloader factory.
      */
-    constructor({ configuration, host, inProcess, maxWorkers, port }) {
+    constructor({ configuration, developmentReloaderFactory, host, inProcess, maxWorkers, port }) {
         this.configuration = configuration;
+        this.developmentReloaderFactory = developmentReloaderFactory;
         this.inProcess = inProcess || false;
         this.logger = new Logger(this);
         this.host = host || "0.0.0.0";
@@ -33,6 +36,7 @@ export default class VelociousHttpServer {
     /** @returns {Promise<void>} - Resolves when complete.  */
     async start() {
         await this._ensureAtLeastOneWorker();
+        await this._startDevelopmentReloader();
         this.netServer = new Net.Server();
         this.netServer.on("close", this.onClose);
         this.netServer.on("connection", this.onConnection);
@@ -96,6 +100,9 @@ export default class VelociousHttpServer {
     }
     /** @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());
@@ -158,6 +165,11 @@ export default class VelociousHttpServer {
     };
     /** @returns {Promise<void>} - Resolves when complete.  */
     async spawnWorker() {
+        const workerHandler = await this._buildWorkerHandler();
+        this.workerHandlers.push(workerHandler);
+    }
+    /** @returns {Promise<WorkerHandler | InProcessHandler>} - Started worker handler. */
+    async _buildWorkerHandler() {
         const workerCount = this.workerCount;
         this.workerCount++;
         const Handler = this.inProcess ? InProcessHandler : WorkerHandler;
@@ -166,7 +178,7 @@ export default class VelociousHttpServer {
             workerCount
         });
         await workerHandler.start();
-        this.workerHandlers.push(workerHandler);
+        return workerHandler;
     }
     /** @returns {WorkerHandler | InProcessHandler} - The worker handler to use. */
     workerHandlerToUse() {
@@ -178,5 +190,48 @@ export default class VelociousHttpServer {
         }
         return workerHandler;
     }
+    /** @returns {boolean} - Whether development worker hot reload should run. */
+    shouldUseDevelopmentHotReload() {
+        return !this.inProcess && this.configuration.getEnvironment() === "development";
+    }
+    /** @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();
+    }
+    /** @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 newWorkerHandler = await this._buildWorkerHandler();
+                this.workerHandlers = [newWorkerHandler];
+                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 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\nexport default class VelociousHttpServer {\n  clientCount = 0\n\n  /** @type {Record<string, ServerClient>}  */\n  clients = {}\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   */\n  constructor({configuration, host, inProcess, maxWorkers, port}) {\n    this.configuration = configuration\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    await this._ensureAtLeastOneWorker()\n    this.netServer = new Net.Server()\n    this.netServer.on(\"close\", this.onClose)\n    this.netServer.on(\"connection\", this.onConnection)\n    this.netServer.on(\"error\", this.onServerError)\n    await this._netServerListen()\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      try {\n        this.netServer.listen(this.port, this.host, () => {\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  /** @returns {Promise<void>} - Resolves when complete.  */\n  stopServer() {\n    return new Promise((resolve, reject) => {\n      if (!this.netServer || !this.netServer.listening) {\n        resolve(undefined)\n        return\n      }\n\n      this.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    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.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 workerCount = this.workerCount\n\n    this.workerCount++\n\n    const Handler = this.inProcess ? InProcessHandler : WorkerHandler\n    const workerHandler = new Handler({\n      configuration: this.configuration,\n      workerCount\n    })\n\n    await workerHandler.start()\n    this.workerHandlers.push(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"]}
+//# 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\nexport default class VelociousHttpServer {\n  clientCount = 0\n\n  /** @type {Record<string, ServerClient>}  */\n  clients = {}\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   */\n  constructor({configuration, developmentReloaderFactory, host, inProcess, maxWorkers, port}) {\n    this.configuration = configuration\n    this.developmentReloaderFactory = developmentReloaderFactory\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    await this._ensureAtLeastOneWorker()\n    await this._startDevelopmentReloader()\n    this.netServer = new Net.Server()\n    this.netServer.on(\"close\", this.onClose)\n    this.netServer.on(\"connection\", this.onConnection)\n    this.netServer.on(\"error\", this.onServerError)\n    await this._netServerListen()\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      try {\n        this.netServer.listen(this.port, this.host, () => {\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  /** @returns {Promise<void>} - Resolves when complete.  */\n  stopServer() {\n    return new Promise((resolve, reject) => {\n      if (!this.netServer || !this.netServer.listening) {\n        resolve(undefined)\n        return\n      }\n\n      this.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.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 = 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"]}