velocious 1.0.431 → 1.0.433

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

@@ -1,178 +1,164 @@
 // @ts-check
-
-import fs from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-
+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())
+    /**
+     * 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;
     }
-  }
-
-  /**
-   * 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
+    /**
+     * 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());
+        }
     }
-
-    try {
-      await this.writeOwnerMetadata()
-      this.acquired = true
-
-      return true
-    } catch (error) {
-      await fs.rm(this.lockPath, {recursive: true, force: true})
-      throw error
+    /**
+     * 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"
+    /**
+     * 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 });
     }
-  }
-
-  /**
-   * 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
+    /**
+     * 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.`;
     }
-  }
-
-  /**
-   * 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.js

@@ -1,5 +1,4 @@
 // @ts-check
-
 /**
  * Per-process registry of channel subscribers used by worker code that
  * needs to react to events broadcast via `websocketEventsHost.publish(...)`
@@ -10,101 +9,90 @@
  * `setWebsocketChannelSubscribers(...)`.
  */
 export default class VelociousWebsocketChannelSubscribers {
-  constructor() {
+    constructor() {
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {Map<string, Set<(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>>>} */
+        this._subscribers = new Map();
+    }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {Map<string, Set<(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>>>} */
-    this._subscribers = new Map()
-  }
-
-  /**
-   * Runs subscribe.
-   * @param {string} channel - Channel name to subscribe to.
-   * @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, callback) {
-    if (!channel) throw new Error("channel is required")
-    if (typeof callback !== "function") throw new Error("callback must be a function")
-
-    let set = this._subscribers.get(channel)
-
-    if (!set) {
-      set = new Set()
-      this._subscribers.set(channel, set)
+     * Runs subscribe.
+     * @param {string} channel - Channel name to subscribe to.
+     * @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, callback) {
+        if (!channel)
+            throw new Error("channel is required");
+        if (typeof callback !== "function")
+            throw new Error("callback must be a function");
+        let set = this._subscribers.get(channel);
+        if (!set) {
+            set = new Set();
+            this._subscribers.set(channel, set);
+        }
+        set.add(callback);
+        return () => this.unsubscribe(channel, callback);
     }
-
-    set.add(callback)
-
-    return () => this.unsubscribe(channel, callback)
-  }
-
-  /**
-   * Runs unsubscribe.
-   * @param {string} channel - Channel name.
-   * @param {(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Previously registered callback.
-   * @returns {void}
-   */
-  unsubscribe(channel, callback) {
-    const set = this._subscribers.get(channel)
-
-    if (!set) return
-
-    set.delete(callback)
-
-    if (set.size === 0) {
-      this._subscribers.delete(channel)
+    /**
+     * Runs unsubscribe.
+     * @param {string} channel - Channel name.
+     * @param {(payload: ?, meta: {channel: string, createdAt?: string, eventId?: string}) => void | Promise<void>} callback - Previously registered callback.
+     * @returns {void}
+     */
+    unsubscribe(channel, callback) {
+        const set = this._subscribers.get(channel);
+        if (!set)
+            return;
+        set.delete(callback);
+        if (set.size === 0) {
+            this._subscribers.delete(channel);
+        }
     }
-  }
-
-  /**
-   * Runs has subscribers.
-   * @param {string} channel - Channel name.
-   * @returns {boolean} - Whether any subscribers exist for the channel.
-   */
-  hasSubscribers(channel) {
-    const set = this._subscribers.get(channel)
-
-    return Boolean(set && set.size > 0)
-  }
-
-  /**
-   * Dispatch an event to all subscribers of the channel.
-   * @param {object} args - Event args.
-   * @param {string} args.channel - Channel name.
-   * @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.
-   */
-  async dispatch({channel, payload, createdAt, eventId}) {
-    const set = this._subscribers.get(channel)
-
-    if (!set || set.size === 0) return
-
-    // Snapshot the subscribers so callbacks that unsubscribe (themselves or
-    // others) during dispatch do not skip later deliveries for this event.
-    const callbacks = Array.from(set)
-    const meta = {channel, createdAt, eventId}
-    const tasks = []
-
-    for (const callback of callbacks) {
-      try {
-        const result = callback(payload, meta)
-
-        if (result && typeof (/**
-                               * Narrows the runtime value to the documented type.
-                                @type {Promise<void>} */ (result)).then === "function") {
-          tasks.push(/**
-                      * Narrows the runtime value to the documented type.
-                       @type {Promise<void>} */ (result))
+    /**
+     * Runs has subscribers.
+     * @param {string} channel - Channel name.
+     * @returns {boolean} - Whether any subscribers exist for the channel.
+     */
+    hasSubscribers(channel) {
+        const set = this._subscribers.get(channel);
+        return Boolean(set && set.size > 0);
+    }
+    /**
+     * Dispatch an event to all subscribers of the channel.
+     * @param {object} args - Event args.
+     * @param {string} args.channel - Channel name.
+     * @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.
+     */
+    async dispatch({ channel, payload, createdAt, eventId }) {
+        const set = this._subscribers.get(channel);
+        if (!set || set.size === 0)
+            return;
+        // Snapshot the subscribers so callbacks that unsubscribe (themselves or
+        // others) during dispatch do not skip later deliveries for this event.
+        const callbacks = Array.from(set);
+        const meta = { channel, createdAt, eventId };
+        const tasks = [];
+        for (const callback of callbacks) {
+            try {
+                const result = callback(payload, meta);
+                if (result && typeof ( /**
+                                       * Narrows the runtime value to the documented type.
+                                        @type {Promise<void>} */(result)).then === "function") {
+                    tasks.push(/**
+                                * Narrows the runtime value to the documented type.
+                                 @type {Promise<void>} */ (result));
+                }
+            }
+            catch (error) {
+                // Don't let one subscriber's failure abort the others; surface via the returned promises instead.
+                tasks.push(Promise.reject(error));
+            }
         }
-      } catch (error) {
-        // Don't let one subscriber's failure abort the others; surface via the returned promises instead.
-        tasks.push(Promise.reject(error))
-      }
+        await Promise.all(tasks);
     }
-
-    await Promise.all(tasks)
-  }
 }
+//# sourceMappingURL=data:application/json;base64,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