velocious 1.0.428 → 1.0.430

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

@@ -1,5 +1,6 @@
 export default class ServerClient {
     /**
+     * Runs constructor.
      * @param {object} args - Options object.
      * @param {import("../configuration.js").default} args.configuration - Configuration instance.
      * @param {import("net").Socket} args.socket - Socket instance.
@@ -17,38 +18,66 @@ export default class ServerClient {
     clientCount: number;
     remoteAddress: string | undefined;
     closeEmitted: boolean;
-    /** @returns {void} - No return value.  */
+    /**
+     * Runs listen.
+     * @returns {void} - No return value.
+     */
     listen(): void;
-    /** @returns {Promise<void>} - Resolves when complete.  */
+    /**
+     * Runs end.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
     end(): Promise<void>;
     /**
+     * On socket data.
      * @param {Buffer} chunk - Chunk.
      * @returns {void} - No return value.
      */
     onSocketData: (chunk: Buffer) => void;
-    /** @returns {void} - No return value.  */
+    /**
+     * On socket end.
+     * @returns {void} - No return value.
+     */
     onSocketEnd: () => void;
-    /** @returns {void} - No return value. */
+    /**
+     * On socket close.
+     * @returns {void} - No return value.
+     */
     onSocketClose: () => void;
-    /** @returns {void} - No return value. */
+    /**
+     * On socket timeout.
+     * @returns {void} - No return value.
+     */
     onSocketTimeout: () => void;
-    /** @returns {void} - No return value. */
+    /**
+     * On socket drain.
+     * @returns {void} - No return value.
+     */
     onSocketDrain: () => void;
-    /** @returns {void} - No return value. */
+    /**
+     * On socket finish.
+     * @returns {void} - No return value.
+     */
     onSocketFinish: () => void;
     /**
+     * On socket error.
      * @param {Error} error - Socket error.
      * @returns {void} - No return value.
      */
     onSocketError: (error: Error) => void;
-    /** @returns {void} - No return value. */
+    /**
+     * Runs emit close.
+     * @returns {void} - No return value.
+     */
     emitClose(): void;
     /**
+     * Runs send.
      * @param {string | Uint8Array} data - Data payload.
      * @returns {Promise<void>} - Resolves when complete.
      */
     send(data: string | Uint8Array): Promise<void>;
     /**
+     * Runs set worker.
      * @param {import("worker_threads").Worker} newWorker - New worker.
      * @returns {void} - No return value.
      */

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

@@ -1 +1 @@
-{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"AAkBA;IAGE;;;;;OAKG;IACH,oDAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACV,MAAM,EAAjC,OAAO,KAAK,EAAE,MAAM;QACP,WAAW,EAAxB,MAAM;KAChB,EAiBA;IAxBD,mEAA2B;IAWzB,qDAAkC;IAClC,eAA8B;IAC9B,kCAAoB;IACpB,oBAA8B;IAC9B,kCAAyC;IACzC,sBAAyB;IAU3B,0CAA0C;IAC1C,UADc,IAAI,CASjB;IAED,0DAA0D;IAC1D,OADc,OAAO,CAAC,IAAI,CAAC,CAW1B;IAED;;;OAGG;IACH,eAAgB,OAHL,MAGU,KAFR,IAAI,CAahB;IAED,0CAA0C;IAC1C,mBADc,IAAI,CAIjB;IAED,yCAAyC;IACzC,qBADc,IAAI,CAIjB;IAED,yCAAyC;IACzC,uBADc,IAAI,CAGjB;IAED,yCAAyC;IACzC,qBADc,IAAI,CAGjB;IAED,yCAAyC;IACzC,sBADc,IAAI,CAGjB;IAGD;;;OAGG;IACH,gBAAiB,OAHN,KAGW,KAFT,IAAI,CAWhB;IAED,yCAAyC;IACzC,aADc,IAAI,CAMjB;IAED;;;OAGG;IACH,WAHW,MAAM,GAAG,UAAU,GACjB,OAAO,CAAC,IAAI,CAAC,CAqCzB;IAED;;;OAGG;IACH,qBAHW,OAAO,gBAAgB,EAAE,MAAM,GAC7B,IAAI,CAIhB;IADC,yDAAuB;CAE1B;mBAtLkB,cAAc"}
+{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"AAmBA;IAGE;;;;;;OAMG;IACH,oDAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACV,MAAM,EAAjC,OAAO,KAAK,EAAE,MAAM;QACP,WAAW,EAAxB,MAAM;KAChB,EAiBA;IAzBD,mEAA2B;IAYzB,qDAAkC;IAClC,eAA8B;IAC9B,kCAAoB;IACpB,oBAA8B;IAC9B,kCAAyC;IACzC,sBAAyB;IAU3B;;;OAGG;IACH,UAFa,IAAI,CAUhB;IAED;;;OAGG;IACH,OAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;;OAIG;IACH,eAAgB,OAHL,MAGU,KAFR,IAAI,CAahB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,qBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAGD;;;;OAIG;IACH,gBAAiB,OAHN,KAGW,KAFT,IAAI,CAahB;IAED;;;OAGG;IACH,aAFa,IAAI,CAOhB;IAED;;;;OAIG;IACH,WAHW,MAAM,GAAG,UAAU,GACjB,OAAO,CAAC,IAAI,CAAC,CAyCzB;IAED;;;;OAIG;IACH,qBAHW,OAAO,gBAAgB,EAAE,MAAM,GAC7B,IAAI,CAIhB;IADC,yDAAuB;CAE1B;mBA1NkB,cAAc"}

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

@@ -2,6 +2,7 @@
 import EventEmitter from "../utils/event-emitter.js";
 import Logger from "../logger.js";
 /**
+ * Runs summarize socket chunk.
  * @param {Buffer} chunk - Incoming socket data.
  * @returns {object} - Chunk debug metadata.
  */
@@ -15,6 +16,7 @@ function summarizeSocketChunk(chunk) {
 export default class ServerClient {
     events = new EventEmitter();
     /**
+     * Runs constructor.
      * @param {object} args - Options object.
      * @param {import("../configuration.js").default} args.configuration - Configuration instance.
      * @param {import("net").Socket} args.socket - Socket instance.
@@ -36,7 +38,10 @@ export default class ServerClient {
         socket.on("drain", this.onSocketDrain);
         socket.on("finish", this.onSocketFinish);
     }
-    /** @returns {void} - No return value.  */
+    /**
+     * Runs listen.
+     * @returns {void} - No return value.
+     */
     listen() {
         this.logger.debug(() => ["Socket listen", {
                 clientCount: this.clientCount,
@@ -46,7 +51,10 @@ export default class ServerClient {
             }]);
         this.socket.on("data", this.onSocketData);
     }
-    /** @returns {Promise<void>} - Resolves when complete.  */
+    /**
+     * Runs end.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
     end() {
         return new Promise((resolve) => {
             if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) {
@@ -58,6 +66,7 @@ export default class ServerClient {
         });
     }
     /**
+     * On socket data.
      * @param {Buffer} chunk - Chunk.
      * @returns {void} - No return value.
      */
@@ -72,41 +81,62 @@ export default class ServerClient {
             clientCount: this.clientCount
         });
     };
-    /** @returns {void} - No return value.  */
+    /**
+     * On socket end.
+     * @returns {void} - No return value.
+     */
     onSocketEnd = () => {
         this.logger.debugLowLevel(() => `Socket ${this.clientCount} end`);
         this.emitClose();
     };
-    /** @returns {void} - No return value. */
+    /**
+     * On socket close.
+     * @returns {void} - No return value.
+     */
     onSocketClose = () => {
         this.logger.debugLowLevel(() => `Socket ${this.clientCount} close`);
         this.emitClose();
     };
-    /** @returns {void} - No return value. */
+    /**
+     * On socket timeout.
+     * @returns {void} - No return value.
+     */
     onSocketTimeout = () => {
         this.logger.debug(() => ["Socket timeout", { clientCount: this.clientCount }]);
     };
-    /** @returns {void} - No return value. */
+    /**
+     * On socket drain.
+     * @returns {void} - No return value.
+     */
     onSocketDrain = () => {
         this.logger.debug(() => ["Socket drain", { clientCount: this.clientCount }]);
     };
-    /** @returns {void} - No return value. */
+    /**
+     * On socket finish.
+     * @returns {void} - No return value.
+     */
     onSocketFinish = () => {
         this.logger.debug(() => ["Socket finish", { clientCount: this.clientCount }]);
     };
     /**
+     * On socket error.
      * @param {Error} error - Socket error.
      * @returns {void} - No return value.
      */
     onSocketError = (error) => {
-        const errorCode = /** @type {{code?: string}} */ (error).code;
+        const errorCode = /**
+                           * Narrows the runtime value to the documented type.
+                            @type {{code?: string}} */ (error).code;
         this.logger.error(() => [`Socket ${this.clientCount} error`, errorCode || error.message]);
         this.emitClose();
         if (!this.socket.destroyed) {
             this.socket.destroy(error);
         }
     };
-    /** @returns {void} - No return value. */
+    /**
+     * Runs emit close.
+     * @returns {void} - No return value.
+     */
     emitClose() {
         if (this.closeEmitted)
             return;
@@ -114,6 +144,7 @@ export default class ServerClient {
         this.events.emit("close", this);
     }
     /**
+     * Runs send.
      * @param {string | Uint8Array} data - Data payload.
      * @returns {Promise<void>} - Resolves when complete.
      */
@@ -133,8 +164,12 @@ export default class ServerClient {
                 this.socket.off("error", onWriteError);
                 resolve();
             };
-            const onWriteError = (/** @type {Error} */ error) => {
-                const errorCode = /** @type {{code?: string}} */ (error).code;
+            const onWriteError = (/**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {Error} */ error) => {
+                const errorCode = /**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {{code?: string}} */ (error).code;
                 this.logger.error(() => [`Socket ${this.clientCount} write error`, errorCode || error.message]);
                 finish();
             };
@@ -149,6 +184,7 @@ export default class ServerClient {
         });
     }
     /**
+     * Runs set worker.
      * @param {import("worker_threads").Worker} newWorker - New worker.
      * @returns {void} - No return value.
      */
@@ -156,4 +192,4 @@ export default class ServerClient {
         this.worker = newWorker;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-client.js","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,YAAY,MAAM,2BAA2B,CAAA;AACpD,OAAO,MAAM,MAAM,cAAc,CAAA;AAEjC;;;GAGG;AACH,SAAS,oBAAoB,CAAC,KAAK;IACjC,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAExH,OAAO;QACL,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,OAAO;KACR,CAAA;AACH,CAAC;AAED,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,MAAM,GAAG,IAAI,YAAY,EAAE,CAAA;IAE3B;;;;;OAKG;IACH,YAAY,EAAC,aAAa,EAAE,MAAM,EAAE,WAAW,EAAC;QAC9C,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAA;QAE7D,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAA;QAC9B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;QAC9B,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAA;QACzC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAA;QAEzB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,CAAA;QAClC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAA;QACtC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAA;QACtC,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,CAAA;QAC1C,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAA;QACtC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,CAAA;IAC1C,CAAC;IAED,0CAA0C;IAC1C,MAAM;QACJ,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,eAAe,EAAE;gBACxC,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa;gBACxC,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY;gBACtC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;aACnC,CAAC,CAAC,CAAA;QACH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,CAAA;IAC3C,CAAC;IAED,0DAA0D;IAC1D,GAAG;QACD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7B,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;gBACzF,OAAO,CAAC,SAAS,CAAC,CAAA;gBAClB,OAAM;YACR,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAA;YACnD,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAA;QACnB,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,YAAY,GAAG,CAAC,KAAK,EAAE,EAAE;QACvB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,UAAU,IAAI,CAAC,WAAW,KAAK,KAAK,EAAE,CAAC,CAAA;QACvE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,sBAAsB,EAAE,EAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,GAAG,oBAAoB,CAAC,KAAK,CAAC,EAAC,CAAC,CAAC,CAAA;QAElH,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,WAAW,CAAC,CAAA;QAE9C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;YACtB,OAAO,EAAE,aAAa;YACtB,KAAK;YACL,WAAW,EAAE,IAAI,CAAC,WAAW;SAC9B,CAAC,CAAA;IACJ,CAAC,CAAA;IAED,0CAA0C;IAC1C,WAAW,GAAG,GAAG,EAAE;QACjB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,UAAU,IAAI,CAAC,WAAW,MAAM,CAAC,CAAA;QACjE,IAAI,CAAC,SAAS,EAAE,CAAA;IAClB,CAAC,CAAA;IAED,yCAAyC;IACzC,aAAa,GAAG,GAAG,EAAE;QACnB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,UAAU,IAAI,CAAC,WAAW,QAAQ,CAAC,CAAA;QACnE,IAAI,CAAC,SAAS,EAAE,CAAA;IAClB,CAAC,CAAA;IAED,yCAAyC;IACzC,eAAe,GAAG,GAAG,EAAE;QACrB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,gBAAgB,EAAE,EAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAC,CAAC,CAAC,CAAA;IAC9E,CAAC,CAAA;IAED,yCAAyC;IACzC,aAAa,GAAG,GAAG,EAAE;QACnB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,cAAc,EAAE,EAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAC,CAAC,CAAC,CAAA;IAC5E,CAAC,CAAA;IAED,yCAAyC;IACzC,cAAc,GAAG,GAAG,EAAE;QACpB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,eAAe,EAAE,EAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAC,CAAC,CAAC,CAAA;IAC7E,CAAC,CAAA;IAGD;;;OAGG;IACH,aAAa,GAAG,CAAC,KAAK,EAAE,EAAE;QACxB,MAAM,SAAS,GAAG,8BAA8B,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAA;QAE7D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC,WAAW,QAAQ,EAAE,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAA;QACzF,IAAI,CAAC,SAAS,EAAE,CAAA;QAEhB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;YAC3B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC5B,CAAC;IACH,CAAC,CAAA;IAED,yCAAyC;IACzC,SAAS;QACP,IAAI,IAAI,CAAC,YAAY;YAAE,OAAM;QAE7B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAA;QACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;IACjC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,IAAI,CAAC,IAAI;QACb,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAA;YAC/C,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;gBACzF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,wCAAwC,CAAC,CAAA;gBACzE,OAAO,EAAE,CAAA;gBACT,OAAM;YACR,CAAC;YAED,IAAI,IAAI,GAAG,KAAK,CAAA;YAEhB,MAAM,MAAM,GAAG,GAAG,EAAE;gBAClB,IAAI,IAAI;oBAAE,OAAM;gBAEhB,IAAI,GAAG,IAAI,CAAA;gBACX,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,YAAY,CAAC,CAAA;gBACtC,OAAO,EAAE,CAAA;YACX,CAAC,CAAA;YACD,MAAM,YAAY,GAAG,CAAC,oBAAoB,CAAC,KAAK,EAAE,EAAE;gBAClD,MAAM,SAAS,GAAG,8BAA8B,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAA;gBAE7D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC,WAAW,cAAc,EAAE,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAA;gBAC/F,MAAM,EAAE,CAAA;YACV,CAAC,CAAA;YAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,CAAA;YACvC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE;gBAChC,IAAI,KAAK,EAAE,CAAC;oBACV,YAAY,CAAC,KAAK,CAAC,CAAA;oBACnB,OAAM;gBACR,CAAC;gBAED,MAAM,EAAE,CAAA;YACV,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,SAAS;QACjB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAA;IACzB,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Logger from \"../logger.js\"\n\n/**\n * @param {Buffer} chunk - Incoming socket data.\n * @returns {object} - Chunk debug metadata.\n */\nfunction summarizeSocketChunk(chunk) {\n  const preview = chunk.toString(\"latin1\", 0, Math.min(chunk.length, 160)).replaceAll(\"\\r\", \"\\\\r\").replaceAll(\"\\n\", \"\\\\n\")\n\n  return {\n    length: chunk.length,\n    preview\n  }\n}\n\nexport default class ServerClient {\n  events = new EventEmitter()\n\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"net\").Socket} args.socket - Socket instance.\n   * @param {number} args.clientCount - Client count.\n   */\n  constructor({configuration, socket, clientCount}) {\n    if (!configuration) throw new Error(\"No configuration given\")\n\n    this.configuration = configuration\n    this.logger = new Logger(this)\n    this.socket = socket\n    this.clientCount = clientCount\n    this.remoteAddress = socket.remoteAddress\n    this.closeEmitted = false\n\n    socket.on(\"end\", this.onSocketEnd)\n    socket.on(\"error\", this.onSocketError)\n    socket.on(\"close\", this.onSocketClose)\n    socket.on(\"timeout\", this.onSocketTimeout)\n    socket.on(\"drain\", this.onSocketDrain)\n    socket.on(\"finish\", this.onSocketFinish)\n  }\n\n  /** @returns {void} - No return value.  */\n  listen() {\n    this.logger.debug(() => [\"Socket listen\", {\n      clientCount: this.clientCount,\n      remoteAddress: this.socket.remoteAddress,\n      remoteFamily: this.socket.remoteFamily,\n      remotePort: this.socket.remotePort\n    }])\n    this.socket.on(\"data\", this.onSocketData)\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete.  */\n  end() {\n    return new Promise((resolve) => {\n      if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) {\n        resolve(undefined)\n        return\n      }\n\n      this.socket.once(\"close\", () => resolve(undefined))\n      this.socket.end()\n    })\n  }\n\n  /**\n   * @param {Buffer} chunk - Chunk.\n   * @returns {void} - No return value.\n   */\n  onSocketData = (chunk) => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount}: ${chunk}`)\n    this.logger.debug(() => [\"Socket data received\", {clientCount: this.clientCount, ...summarizeSocketChunk(chunk)}])\n\n    if (!this.worker) throw new Error(\"No worker\")\n\n    this.worker.postMessage({\n      command: \"clientWrite\",\n      chunk,\n      clientCount: this.clientCount\n    })\n  }\n\n  /** @returns {void} - No return value.  */\n  onSocketEnd = () => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount} end`)\n    this.emitClose()\n  }\n\n  /** @returns {void} - No return value. */\n  onSocketClose = () => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount} close`)\n    this.emitClose()\n  }\n\n  /** @returns {void} - No return value. */\n  onSocketTimeout = () => {\n    this.logger.debug(() => [\"Socket timeout\", {clientCount: this.clientCount}])\n  }\n\n  /** @returns {void} - No return value. */\n  onSocketDrain = () => {\n    this.logger.debug(() => [\"Socket drain\", {clientCount: this.clientCount}])\n  }\n\n  /** @returns {void} - No return value. */\n  onSocketFinish = () => {\n    this.logger.debug(() => [\"Socket finish\", {clientCount: this.clientCount}])\n  }\n\n\n  /**\n   * @param {Error} error - Socket error.\n   * @returns {void} - No return value.\n   */\n  onSocketError = (error) => {\n    const errorCode = /** @type {{code?: string}} */ (error).code\n\n    this.logger.error(() => [`Socket ${this.clientCount} error`, errorCode || error.message])\n    this.emitClose()\n\n    if (!this.socket.destroyed) {\n      this.socket.destroy(error)\n    }\n  }\n\n  /** @returns {void} - No return value. */\n  emitClose() {\n    if (this.closeEmitted) return\n\n    this.closeEmitted = true\n    this.events.emit(\"close\", this)\n  }\n\n  /**\n   * @param {string | Uint8Array} data - Data payload.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async send(data) {\n    return new Promise((resolve) => {\n      this.logger.debugLowLevel(() => `Send ${data}`)\n      if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) {\n        this.logger.debugLowLevel(() => \"Skipping send because socket is closed\")\n        resolve()\n        return\n      }\n\n      let done = false\n\n      const finish = () => {\n        if (done) return\n\n        done = true\n        this.socket.off(\"error\", onWriteError)\n        resolve()\n      }\n      const onWriteError = (/** @type {Error} */ error) => {\n        const errorCode = /** @type {{code?: string}} */ (error).code\n\n        this.logger.error(() => [`Socket ${this.clientCount} write error`, errorCode || error.message])\n        finish()\n      }\n\n      this.socket.once(\"error\", onWriteError)\n      this.socket.write(data, (error) => {\n        if (error) {\n          onWriteError(error)\n          return\n        }\n\n        finish()\n      })\n    })\n  }\n\n  /**\n   * @param {import(\"worker_threads\").Worker} newWorker - New worker.\n   * @returns {void} - No return value.\n   */\n  setWorker(newWorker) {\n    this.worker = newWorker\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-client.js","sourceRoot":"","sources":["../../../src/http-server/server-client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Logger from \"../logger.js\"\n\n/**\n * Runs summarize socket chunk.\n * @param {Buffer} chunk - Incoming socket data.\n * @returns {object} - Chunk debug metadata.\n */\nfunction summarizeSocketChunk(chunk) {\n  const preview = chunk.toString(\"latin1\", 0, Math.min(chunk.length, 160)).replaceAll(\"\\r\", \"\\\\r\").replaceAll(\"\\n\", \"\\\\n\")\n\n  return {\n    length: chunk.length,\n    preview\n  }\n}\n\nexport default class ServerClient {\n  events = new EventEmitter()\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {import(\"net\").Socket} args.socket - Socket instance.\n   * @param {number} args.clientCount - Client count.\n   */\n  constructor({configuration, socket, clientCount}) {\n    if (!configuration) throw new Error(\"No configuration given\")\n\n    this.configuration = configuration\n    this.logger = new Logger(this)\n    this.socket = socket\n    this.clientCount = clientCount\n    this.remoteAddress = socket.remoteAddress\n    this.closeEmitted = false\n\n    socket.on(\"end\", this.onSocketEnd)\n    socket.on(\"error\", this.onSocketError)\n    socket.on(\"close\", this.onSocketClose)\n    socket.on(\"timeout\", this.onSocketTimeout)\n    socket.on(\"drain\", this.onSocketDrain)\n    socket.on(\"finish\", this.onSocketFinish)\n  }\n\n  /**\n   * Runs listen.\n   * @returns {void} - No return value.\n   */\n  listen() {\n    this.logger.debug(() => [\"Socket listen\", {\n      clientCount: this.clientCount,\n      remoteAddress: this.socket.remoteAddress,\n      remoteFamily: this.socket.remoteFamily,\n      remotePort: this.socket.remotePort\n    }])\n    this.socket.on(\"data\", this.onSocketData)\n  }\n\n  /**\n   * Runs end.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  end() {\n    return new Promise((resolve) => {\n      if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) {\n        resolve(undefined)\n        return\n      }\n\n      this.socket.once(\"close\", () => resolve(undefined))\n      this.socket.end()\n    })\n  }\n\n  /**\n   * On socket data.\n   * @param {Buffer} chunk - Chunk.\n   * @returns {void} - No return value.\n   */\n  onSocketData = (chunk) => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount}: ${chunk}`)\n    this.logger.debug(() => [\"Socket data received\", {clientCount: this.clientCount, ...summarizeSocketChunk(chunk)}])\n\n    if (!this.worker) throw new Error(\"No worker\")\n\n    this.worker.postMessage({\n      command: \"clientWrite\",\n      chunk,\n      clientCount: this.clientCount\n    })\n  }\n\n  /**\n   * On socket end.\n   * @returns {void} - No return value.\n   */\n  onSocketEnd = () => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount} end`)\n    this.emitClose()\n  }\n\n  /**\n   * On socket close.\n   * @returns {void} - No return value.\n   */\n  onSocketClose = () => {\n    this.logger.debugLowLevel(() => `Socket ${this.clientCount} close`)\n    this.emitClose()\n  }\n\n  /**\n   * On socket timeout.\n   * @returns {void} - No return value.\n   */\n  onSocketTimeout = () => {\n    this.logger.debug(() => [\"Socket timeout\", {clientCount: this.clientCount}])\n  }\n\n  /**\n   * On socket drain.\n   * @returns {void} - No return value.\n   */\n  onSocketDrain = () => {\n    this.logger.debug(() => [\"Socket drain\", {clientCount: this.clientCount}])\n  }\n\n  /**\n   * On socket finish.\n   * @returns {void} - No return value.\n   */\n  onSocketFinish = () => {\n    this.logger.debug(() => [\"Socket finish\", {clientCount: this.clientCount}])\n  }\n\n\n  /**\n   * On socket error.\n   * @param {Error} error - Socket error.\n   * @returns {void} - No return value.\n   */\n  onSocketError = (error) => {\n    const errorCode = /**\n                       * Narrows the runtime value to the documented type.\n                        @type {{code?: string}} */ (error).code\n\n    this.logger.error(() => [`Socket ${this.clientCount} error`, errorCode || error.message])\n    this.emitClose()\n\n    if (!this.socket.destroyed) {\n      this.socket.destroy(error)\n    }\n  }\n\n  /**\n   * Runs emit close.\n   * @returns {void} - No return value.\n   */\n  emitClose() {\n    if (this.closeEmitted) return\n\n    this.closeEmitted = true\n    this.events.emit(\"close\", this)\n  }\n\n  /**\n   * Runs send.\n   * @param {string | Uint8Array} data - Data payload.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async send(data) {\n    return new Promise((resolve) => {\n      this.logger.debugLowLevel(() => `Send ${data}`)\n      if (this.socket.destroyed || this.socket.writableEnded || this.socket.writable === false) {\n        this.logger.debugLowLevel(() => \"Skipping send because socket is closed\")\n        resolve()\n        return\n      }\n\n      let done = false\n\n      const finish = () => {\n        if (done) return\n\n        done = true\n        this.socket.off(\"error\", onWriteError)\n        resolve()\n      }\n      const onWriteError = (/**\n                             * Narrows the runtime value to the documented type.\n                              @type {Error} */ error) => {\n        const errorCode = /**\n                           * Narrows the runtime value to the documented type.\n                            @type {{code?: string}} */ (error).code\n\n        this.logger.error(() => [`Socket ${this.clientCount} write error`, errorCode || error.message])\n        finish()\n      }\n\n      this.socket.once(\"error\", onWriteError)\n      this.socket.write(data, (error) => {\n        if (error) {\n          onWriteError(error)\n          return\n        }\n\n        finish()\n      })\n    })\n  }\n\n  /**\n   * Runs set worker.\n   * @param {import(\"worker_threads\").Worker} newWorker - New worker.\n   * @returns {void} - No return value.\n   */\n  setWorker(newWorker) {\n    this.worker = newWorker\n  }\n}\n"]}

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

@@ -0,0 +1,76 @@
+/**
+ * Directory-based lock that allows only one HTTP server process per app directory.
+ */
+export default class VelociousHttpServerLock {
+    /**
+     * Build a lock for the configured application directory and server endpoint.
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration that owns the application directory.
+     * @param {string} args.host - Configured HTTP host.
+     * @param {number} args.port - Configured HTTP port.
+     */
+    constructor({ configuration, host, port }: {
+        configuration: import("../configuration.js").default;
+        host: string;
+        port: number;
+    });
+    configuration: import("../configuration.js").default;
+    host: string;
+    port: number;
+    lockPath: string;
+    acquired: boolean;
+    /**
+     * Acquires the app-directory HTTP server lock before startup side effects run.
+     * @returns {Promise<void>} - Resolves after the lock has been acquired.
+     */
+    acquire(): Promise<void>;
+    /**
+     * Tries to create the lock directory and write owner metadata.
+     * @returns {Promise<boolean>} - Whether the lock was acquired.
+     */
+    tryAcquire(): Promise<boolean>;
+    /**
+     * Releases the held HTTP server lock directory.
+     * @returns {Promise<void>} - Resolves after best-effort lock release.
+     */
+    release(): Promise<void>;
+    /**
+     * Writes metadata used to explain or reclaim an existing server lock.
+     * @returns {Promise<void>} - Resolves after owner metadata has been written.
+     */
+    writeOwnerMetadata(): Promise<void>;
+    /**
+     * Checks whether the current lock owner is a dead process on this host.
+     * @returns {Promise<boolean>} - Whether the existing lock belongs to a dead process.
+     */
+    isStale(): Promise<boolean>;
+    /**
+     * Runs is local process owner.
+     * @param {Record<string, ?> | null} owner - Existing lock owner metadata.
+     * @returns {boolean} - Whether owner metadata names a local process.
+     */
+    isLocalProcessOwner(owner: Record<string, unknown> | null): boolean;
+    /**
+     * Runs owner hostname matches.
+     * @param {Record<string, ?>} owner - Existing lock owner metadata.
+     * @returns {boolean} - Whether the owner hostname is local or absent.
+     */
+    ownerHostnameMatches(owner: Record<string, unknown>): boolean;
+    /**
+     * Runs process is dead.
+     * @param {number} pid - Process id.
+     * @returns {boolean} - Whether the process no longer exists.
+     */
+    processIsDead(pid: number): boolean;
+    /**
+     * Reads owner metadata from an existing server lock directory.
+     * @returns {Promise<Record<string, ?> | null>} - Parsed owner metadata, when readable.
+     */
+    readOwnerMetadata(): Promise<Record<string, unknown> | null>;
+    /**
+     * Builds a duplicate-server error message with owner details when available.
+     * @returns {Promise<string>} - Error message explaining which server owns the lock.
+     */
+    lockHeldMessage(): Promise<string>;
+}
+//# sourceMappingURL=server-lock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server-lock.d.ts","sourceRoot":"","sources":["../../../src/http-server/server-lock.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACE;;;;;;OAMG;IACH,2CAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACxB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;KAChB,EAOA;IALC,qDAAkC;IAClC,aAAgB;IAChB,aAAgB;IAChB,iBAA6E;IAC7E,kBAAqB;IAGvB;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED;;;OAGG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAqB5B;IAED;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAOzB;IAED;;;OAGG;IACH,sBAFa,OAAO,CAAC,IAAI,CAAC,CAUzB;IAED;;;OAGG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,2BAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GAAG,IAAI,GACtB,OAAO,CAOnB;IAED;;;;OAIG;IACH,4BAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,OAAO,CAOnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;OAGG;IACH,qBAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GAAG,IAAI,CAAC,CAU7C;IAED;;;OAGG;IACH,mBAFa,OAAO,CAAC,MAAM,CAAC,CAS3B;CACF"}

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

@@ -0,0 +1,164 @@
+// @ts-check
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Directory-based lock that allows only one HTTP server process per app directory.
+ */
+export default class VelociousHttpServerLock {
+    /**
+     * Build a lock for the configured application directory and server endpoint.
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration that owns the application directory.
+     * @param {string} args.host - Configured HTTP host.
+     * @param {number} args.port - Configured HTTP port.
+     */
+    constructor({ configuration, host, port }) {
+        this.configuration = configuration;
+        this.host = host;
+        this.port = port;
+        this.lockPath = path.join(configuration.getDirectory(), "tmp", "server.lock");
+        this.acquired = false;
+    }
+    /**
+     * Acquires the app-directory HTTP server lock before startup side effects run.
+     * @returns {Promise<void>} - Resolves after the lock has been acquired.
+     */
+    async acquire() {
+        await fs.mkdir(path.dirname(this.lockPath), { recursive: true });
+        while (true) {
+            const acquired = await this.tryAcquire();
+            if (acquired) {
+                return;
+            }
+            if (await this.isStale()) {
+                await fs.rm(this.lockPath, { recursive: true, force: true });
+                continue;
+            }
+            throw new Error(await this.lockHeldMessage());
+        }
+    }
+    /**
+     * Tries to create the lock directory and write owner metadata.
+     * @returns {Promise<boolean>} - Whether the lock was acquired.
+     */
+    async tryAcquire() {
+        try {
+            await fs.mkdir(this.lockPath);
+        }
+        catch (error) {
+            if ( /**
+                 * Narrows the runtime value to the documented type.
+                  @type {{code?: string}} */(error).code === "EEXIST")
+                return false;
+            throw error;
+        }
+        try {
+            await this.writeOwnerMetadata();
+            this.acquired = true;
+            return true;
+        }
+        catch (error) {
+            await fs.rm(this.lockPath, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    /**
+     * Releases the held HTTP server lock directory.
+     * @returns {Promise<void>} - Resolves after best-effort lock release.
+     */
+    async release() {
+        if (!this.acquired)
+            return;
+        this.acquired = false;
+        await fs.rm(this.lockPath, { recursive: true, force: true });
+    }
+    /**
+     * Writes metadata used to explain or reclaim an existing server lock.
+     * @returns {Promise<void>} - Resolves after owner metadata has been written.
+     */
+    async writeOwnerMetadata() {
+        await fs.writeFile(path.join(this.lockPath, "owner.json"), JSON.stringify({
+            acquiredAt: new Date().toISOString(),
+            host: this.host,
+            hostname: os.hostname(),
+            pid: process.pid,
+            port: this.port
+        }));
+    }
+    /**
+     * Checks whether the current lock owner is a dead process on this host.
+     * @returns {Promise<boolean>} - Whether the existing lock belongs to a dead process.
+     */
+    async isStale() {
+        const owner = await this.readOwnerMetadata();
+        if (!this.isLocalProcessOwner(owner))
+            return false;
+        return this.processIsDead(/**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {{pid: number}} */ (owner).pid);
+    }
+    /**
+     * Runs is local process owner.
+     * @param {Record<string, ?> | null} owner - Existing lock owner metadata.
+     * @returns {boolean} - Whether owner metadata names a local process.
+     */
+    isLocalProcessOwner(owner) {
+        if (!owner)
+            return false;
+        if (typeof owner.pid !== "number")
+            return false;
+        return this.ownerHostnameMatches(owner);
+    }
+    /**
+     * Runs owner hostname matches.
+     * @param {Record<string, ?>} owner - Existing lock owner metadata.
+     * @returns {boolean} - Whether the owner hostname is local or absent.
+     */
+    ownerHostnameMatches(owner) {
+        if (!owner.hostname)
+            return true;
+        if (owner.hostname === os.hostname())
+            return true;
+        return false;
+    }
+    /**
+     * Runs process is dead.
+     * @param {number} pid - Process id.
+     * @returns {boolean} - Whether the process no longer exists.
+     */
+    processIsDead(pid) {
+        try {
+            process.kill(pid, 0);
+            return false;
+        }
+        catch (error) {
+            return /** Narrows the runtime value to the documented type. @type {{code?: string}} */ (error).code === "ESRCH";
+        }
+    }
+    /**
+     * Reads owner metadata from an existing server lock directory.
+     * @returns {Promise<Record<string, ?> | null>} - Parsed owner metadata, when readable.
+     */
+    async readOwnerMetadata() {
+        try {
+            const rawOwner = await fs.readFile(path.join(this.lockPath, "owner.json"), "utf8");
+            return /** Narrows the runtime value to the documented type. @type {Record<string, ?>} */ (JSON.parse(rawOwner));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Builds a duplicate-server error message with owner details when available.
+     * @returns {Promise<string>} - Error message explaining which server owns the lock.
+     */
+    async lockHeldMessage() {
+        const owner = await this.readOwnerMetadata();
+        const details = owner
+            ? `PID ${String(owner.pid)} on ${String(owner.hostname)} (${String(owner.host)}:${String(owner.port)})`
+            : `lock directory ${this.lockPath}`;
+        return `A Velocious HTTP server is already running for this application (${details}). Remove ${this.lockPath} if the server is no longer running.`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-lock.js","sourceRoot":"","sources":["../../../src/http-server/server-lock.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport fs from \"node:fs/promises\"\nimport os from \"node:os\"\nimport path from \"node:path\"\n\n/**\n * Directory-based lock that allows only one HTTP server process per app directory.\n */\nexport default class VelociousHttpServerLock {\n  /**\n   * Build a lock for the configured application directory and server endpoint.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration that owns the application directory.\n   * @param {string} args.host - Configured HTTP host.\n   * @param {number} args.port - Configured HTTP port.\n   */\n  constructor({configuration, host, port}) {\n    this.configuration = configuration\n    this.host = host\n    this.port = port\n    this.lockPath = path.join(configuration.getDirectory(), \"tmp\", \"server.lock\")\n    this.acquired = false\n  }\n\n  /**\n   * Acquires the app-directory HTTP server lock before startup side effects run.\n   * @returns {Promise<void>} - Resolves after the lock has been acquired.\n   */\n  async acquire() {\n    await fs.mkdir(path.dirname(this.lockPath), {recursive: true})\n\n    while (true) {\n      const acquired = await this.tryAcquire()\n\n      if (acquired) {\n        return\n      }\n\n      if (await this.isStale()) {\n        await fs.rm(this.lockPath, {recursive: true, force: true})\n        continue\n      }\n\n      throw new Error(await this.lockHeldMessage())\n    }\n  }\n\n  /**\n   * Tries to create the lock directory and write owner metadata.\n   * @returns {Promise<boolean>} - Whether the lock was acquired.\n   */\n  async tryAcquire() {\n    try {\n      await fs.mkdir(this.lockPath)\n    } catch (error) {\n      if (/**\n           * Narrows the runtime value to the documented type.\n            @type {{code?: string}} */ (error).code === \"EEXIST\") return false\n      throw error\n    }\n\n    try {\n      await this.writeOwnerMetadata()\n      this.acquired = true\n\n      return true\n    } catch (error) {\n      await fs.rm(this.lockPath, {recursive: true, force: true})\n      throw error\n    }\n  }\n\n  /**\n   * Releases the held HTTP server lock directory.\n   * @returns {Promise<void>} - Resolves after best-effort lock release.\n   */\n  async release() {\n    if (!this.acquired) return\n\n    this.acquired = false\n    await fs.rm(this.lockPath, {recursive: true, force: true})\n  }\n\n  /**\n   * Writes metadata used to explain or reclaim an existing server lock.\n   * @returns {Promise<void>} - Resolves after owner metadata has been written.\n   */\n  async writeOwnerMetadata() {\n    await fs.writeFile(path.join(this.lockPath, \"owner.json\"), JSON.stringify({\n      acquiredAt: new Date().toISOString(),\n      host: this.host,\n      hostname: os.hostname(),\n      pid: process.pid,\n      port: this.port\n    }))\n  }\n\n  /**\n   * Checks whether the current lock owner is a dead process on this host.\n   * @returns {Promise<boolean>} - Whether the existing lock belongs to a dead process.\n   */\n  async isStale() {\n    const owner = await this.readOwnerMetadata()\n\n    if (!this.isLocalProcessOwner(owner)) return false\n\n    return this.processIsDead(/**\n                               * Narrows the runtime value to the documented type.\n                                @type {{pid: number}} */ (owner).pid)\n  }\n\n  /**\n   * Runs is local process owner.\n   * @param {Record<string, ?> | null} owner - Existing lock owner metadata.\n   * @returns {boolean} - Whether owner metadata names a local process.\n   */\n  isLocalProcessOwner(owner) {\n    if (!owner) return false\n    if (typeof owner.pid !== \"number\") return false\n\n    return this.ownerHostnameMatches(owner)\n  }\n\n  /**\n   * Runs owner hostname matches.\n   * @param {Record<string, ?>} owner - Existing lock owner metadata.\n   * @returns {boolean} - Whether the owner hostname is local or absent.\n   */\n  ownerHostnameMatches(owner) {\n    if (!owner.hostname) return true\n    if (owner.hostname === os.hostname()) return true\n\n    return false\n  }\n\n  /**\n   * Runs process is dead.\n   * @param {number} pid - Process id.\n   * @returns {boolean} - Whether the process no longer exists.\n   */\n  processIsDead(pid) {\n    try {\n      process.kill(pid, 0)\n\n      return false\n    } catch (error) {\n      return /** Narrows the runtime value to the documented type. @type {{code?: string}} */ (error).code === \"ESRCH\"\n    }\n  }\n\n  /**\n   * Reads owner metadata from an existing server lock directory.\n   * @returns {Promise<Record<string, ?> | null>} - Parsed owner metadata, when readable.\n   */\n  async readOwnerMetadata() {\n    try {\n      const rawOwner = await fs.readFile(path.join(this.lockPath, \"owner.json\"), \"utf8\")\n\n      return /** Narrows the runtime value to the documented type. @type {Record<string, ?>} */ (JSON.parse(rawOwner))\n    } catch {\n      return null\n    }\n  }\n\n  /**\n   * Builds a duplicate-server error message with owner details when available.\n   * @returns {Promise<string>} - Error message explaining which server owns the lock.\n   */\n  async lockHeldMessage() {\n    const owner = await this.readOwnerMetadata()\n    const details = owner\n      ? `PID ${String(owner.pid)} on ${String(owner.hostname)} (${String(owner.host)}:${String(owner.port)})`\n      : `lock directory ${this.lockPath}`\n\n    return `A Velocious HTTP server is already running for this application (${details}). Remove ${this.lockPath} if the server is no longer running.`\n  }\n}\n"]}

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

@@ -8,33 +8,38 @@
  * `setWebsocketChannelSubscribers(...)`.
  */
 export default class VelociousWebsocketChannelSubscribers {
-    /** @type {Map<string, Set<(payload: any, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>>>} */
-    _subscribers: Map<string, Set<(payload: any, meta: {
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {Map<string, Set<(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>>>} */
+    _subscribers: Map<string, Set<(payload: unknown, meta: {
         channel: string;
         createdAt?: string;
         eventId?: string;
     }) => void | Promise<void>>>;
     /**
+     * Runs subscribe.
      * @param {string} channel - Channel name to subscribe to.
-     * @param {(payload: any, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Callback invoked for each event on the channel.
+     * @param {(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Callback invoked for each event on the channel.
      * @returns {() => void} - Unsubscribe function.
      */
-    subscribe(channel: string, callback: (payload: any, meta: {
+    subscribe(channel: string, callback: (payload: unknown, meta: {
         channel: string;
         createdAt?: string;
         eventId?: string;
     }) => void | Promise<void>): () => void;
     /**
+     * Runs unsubscribe.
      * @param {string} channel - Channel name.
-     * @param {(payload: any, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Previously registered callback.
+     * @param {(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Previously registered callback.
      * @returns {void}
      */
-    unsubscribe(channel: string, callback: (payload: any, meta: {
+    unsubscribe(channel: string, callback: (payload: unknown, meta: {
         channel: string;
         createdAt?: string;
         eventId?: string;
     }) => void | Promise<void>): void;
     /**
+     * Runs has subscribers.
      * @param {string} channel - Channel name.
      * @returns {boolean} - Whether any subscribers exist for the channel.
      */
@@ -43,14 +48,14 @@ export default class VelociousWebsocketChannelSubscribers {
      * Dispatch an event to all subscribers of the channel.
      * @param {object} args - Event args.
      * @param {string} args.channel - Channel name.
-     * @param {any} args.payload - Event payload.
+     * @param {?} args.payload - Event payload.
      * @param {string} [args.createdAt] - Event creation time.
      * @param {string} [args.eventId] - Event identifier.
      * @returns {Promise<void>} - Resolves when all subscribers have completed.
      */
     dispatch({ channel, payload, createdAt, eventId }: {
         channel: string;
-        payload: any;
+        payload: unknown;
         createdAt?: string | undefined;
         eventId?: string | undefined;
     }): Promise<void>;

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

@@ -1 +1 @@
-{"version":3,"file":"websocket-channel-subscribers.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-channel-subscribers.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAEI,sIAAsI;IACtI,cADW,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CACrG;IAG/B;;;;OAIG;IACH,mBAJW,MAAM,YACN,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACnG,MAAM,IAAI,CAgBtB;IAED;;;;OAIG;IACH,qBAJW,MAAM,YACN,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACnG,IAAI,CAYhB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;;;;;OAQG;IACH,mDANG;QAAqB,OAAO,EAApB,MAAM;QACI,OAAO,EAAjB,GAAG;QACW,SAAS;QACT,OAAO;KAC7B,GAAU,OAAO,CAAC,IAAI,CAAC,CA2BzB;CACF"}
+{"version":3,"file":"websocket-channel-subscribers.d.ts","sourceRoot":"","sources":["../../../src/http-server/websocket-channel-subscribers.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAEI;;sIAEkI;IAClI,cADS,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE,OAAC,EAAE,IAAI,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CACjG;IAG/B;;;;;OAKG;IACH,mBAJW,MAAM,YACN,CAAC,OAAO,EAAE,OAAC,EAAE,IAAI,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACjG,MAAM,IAAI,CAgBtB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,YACN,CAAC,OAAO,EAAE,OAAC,EAAE,IAAI,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACjG,IAAI,CAYhB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;;;;;OAQG;IACH,mDANG;QAAqB,OAAO,EAApB,MAAM;QACE,OAAO,EAAf,OAAC;QACa,SAAS;QACT,OAAO;KAC7B,GAAU,OAAO,CAAC,IAAI,CAAC,CA+BzB;CACF"}