velocious 1.0.431 → 1.0.433

package/build/src/beacon/client.js

@@ -1,20 +1,15 @@
 // @ts-check
-
-import {randomUUID} from "node:crypto"
-import net from "node:net"
-import timeout from "awaitery/build/timeout.js"
-
-import JsonSocket from "../background-jobs/json-socket.js"
-import EventEmitter from "../utils/event-emitter.js"
-
-const DEFAULT_RECONNECT_DELAY_MS = 1000
-const MAX_RECONNECT_DELAY_MS = 30_000
-
+import { randomUUID } from "node:crypto";
+import net from "node:net";
+import timeout from "awaitery/build/timeout.js";
+import JsonSocket from "../background-jobs/json-socket.js";
+import EventEmitter from "../utils/event-emitter.js";
+const DEFAULT_RECONNECT_DELAY_MS = 1000;
+const MAX_RECONNECT_DELAY_MS = 30_000;
 /**
  * BeaconBroadcastHandler type.
  * @typedef {function(import("./types.js").BeaconBroadcastMessage): void} BeaconBroadcastHandler
  */
-
 /**
  * BeaconClient connects to a `velocious beacon` daemon and exchanges
  * broadcasts with all peer processes connected to the same daemon.
@@ -34,297 +29,273 @@ const MAX_RECONNECT_DELAY_MS = 30_000
  * not replay missed publishes (Beacon is pubsub, not a queue).
  */
 export default class BeaconClient extends EventEmitter {
-  /**
-   * Runs constructor.
-   * @param {object} args - Options.
-   * @param {string} args.host - Beacon host.
-   * @param {number} args.port - Beacon port.
-   * @param {string} [args.peerType] - Optional human-readable peer label.
-   * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).
-   * @param {number} [args.reconnectDelayMs] - Starting reconnect delay in ms.
-   * @param {number} [args.maxReconnectDelayMs] - Maximum reconnect delay in ms.
-   */
-  constructor({host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs}) {
-    super()
-    this.host = host
-    this.port = port
-    this.peerType = peerType
-    this.peerId = peerId || randomUUID()
-    this._initialReconnectDelayMs = reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS
-    this._maxReconnectDelayMs = maxReconnectDelayMs ?? MAX_RECONNECT_DELAY_MS
-    this._reconnectDelayMs = this._initialReconnectDelayMs
     /**
-     * Narrows the runtime value to the documented type.
-      @type {JsonSocket | undefined} */
-    this._jsonSocket = undefined
+     * Runs constructor.
+     * @param {object} args - Options.
+     * @param {string} args.host - Beacon host.
+     * @param {number} args.port - Beacon port.
+     * @param {string} [args.peerType] - Optional human-readable peer label.
+     * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).
+     * @param {number} [args.reconnectDelayMs] - Starting reconnect delay in ms.
+     * @param {number} [args.maxReconnectDelayMs] - Maximum reconnect delay in ms.
+     */
+    constructor({ host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs }) {
+        super();
+        this.host = host;
+        this.port = port;
+        this.peerType = peerType;
+        this.peerId = peerId || randomUUID();
+        this._initialReconnectDelayMs = reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
+        this._maxReconnectDelayMs = maxReconnectDelayMs ?? MAX_RECONNECT_DELAY_MS;
+        this._reconnectDelayMs = this._initialReconnectDelayMs;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {JsonSocket | undefined} */
+        this._jsonSocket = undefined;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {net.Socket | undefined} */
+        this._socket = undefined;
+        this._connected = false;
+        this._ready = false;
+        this._closed = false;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {NodeJS.Timeout | undefined} */
+        this._reconnectTimer = undefined;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {Promise<void> | undefined} */
+        this._connectPromise = undefined;
+        /**
+         * Last socket error observed while connected, surfaced as the disconnect reason.
+         * @type {Error | undefined}
+         */
+        this._lastSocketError = undefined;
+    }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {net.Socket | undefined} */
-    this._socket = undefined
-    this._connected = false
-    this._ready = false
-    this._closed = false
+     * Runs get peer id.
+     * @returns {string} - The peer id sent on the hello handshake.
+     */
+    getPeerId() { return this.peerId; }
+    /**
+     * Runs is connected.
+     * @returns {boolean} - Whether the underlying socket is currently connected.
+     */
+    isConnected() { return this._connected; }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {NodeJS.Timeout | undefined} */
-    this._reconnectTimer = undefined
+     * Runs is ready.
+     * @returns {boolean} - Whether the daemon has acknowledged this peer registration.
+     */
+    isReady() { return this._ready; }
+    /**
+     * Resolves on the first successful connect. Subsequent calls return
+     * the same promise. Subsequent reconnects after a drop are silent —
+     * use `on("connect")` / `on("disconnect", reason)` to observe them.
+     * The `disconnect` listener receives an `Error` reason: either the
+     * underlying socket error, or `Error("Beacon broker disconnected")`
+     * when the close had no preceding error.
+     * @returns {Promise<void>}
+     */
+    async connect() {
+        if (this._closed)
+            throw new Error("BeaconClient has been closed");
+        if (this._connectPromise)
+            return await this._connectPromise;
+        this._connectPromise = new Promise((resolve, reject) => {
+            const onConnect = () => {
+                this.off("connect", onConnect);
+                this.off("connect-error", onError);
+                resolve();
+            };
+            const onError = (/**
+                              * Narrows the runtime value to the documented type.
+                               @type {Error} */ error) => {
+                this.off("connect", onConnect);
+                this.off("connect-error", onError);
+                reject(error);
+            };
+            this.on("connect", onConnect);
+            this.on("connect-error", onError);
+        });
+        this._openSocket();
+        return await this._connectPromise;
+    }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {Promise<void> | undefined} */
-    this._connectPromise = undefined
+     * Resolves after the Beacon daemon has acknowledged this peer's
+     * hello handshake. This is stronger than `isConnected()`: connected
+     * means the TCP socket is open, ready means the daemon has registered
+     * the peer and broadcasts can be routed through the bus.
+     * @param {object} [args] - Options.
+     * @param {number} [args.timeoutMs] - Optional timeout in milliseconds.
+     * @returns {Promise<void>}
+     */
+    async waitForReady({ timeoutMs } = {}) {
+        if (this._ready)
+            return;
+        /** Cleanup. @type {() => void} */
+        let cleanup = () => { };
+        const readyPromise = new Promise((resolve) => {
+            const onReady = () => {
+                cleanup();
+                resolve(undefined);
+            };
+            cleanup = () => this.off("ready", onReady);
+            this.on("ready", onReady);
+        });
+        try {
+            if (typeof timeoutMs === "number") {
+                await timeout({ timeout: timeoutMs }, async () => {
+                    await readyPromise;
+                });
+            }
+            else {
+                await readyPromise;
+            }
+        }
+        finally {
+            cleanup();
+        }
+    }
     /**
-     * Last socket error observed while connected, surfaced as the disconnect reason.
-     * @type {Error | undefined}
+     * Publishes a broadcast message to all peers (including this one,
+     * unless the daemon is restarted mid-publish).
+     * @param {object} args - Broadcast args.
+     * @param {string} args.channel - Channel name.
+     * @param {Record<string, ?>} args.broadcastParams - Routing params.
+     * @param {?} args.body - Message body.
+     * @returns {boolean} - True if the publish was written to the socket. False if the client is currently disconnected.
      */
-    this._lastSocketError = undefined
-  }
-
-  /**
-   * Runs get peer id.
-   * @returns {string} - The peer id sent on the hello handshake.
-   */
-  getPeerId() { return this.peerId }
-
-  /**
-   * Runs is connected.
-   * @returns {boolean} - Whether the underlying socket is currently connected.
-   */
-  isConnected() { return this._connected }
-
-  /**
-   * Runs is ready.
-   * @returns {boolean} - Whether the daemon has acknowledged this peer registration.
-   */
-  isReady() { return this._ready }
-
-  /**
-   * Resolves on the first successful connect. Subsequent calls return
-   * the same promise. Subsequent reconnects after a drop are silent —
-   * use `on("connect")` / `on("disconnect", reason)` to observe them.
-   * The `disconnect` listener receives an `Error` reason: either the
-   * underlying socket error, or `Error("Beacon broker disconnected")`
-   * when the close had no preceding error.
-   * @returns {Promise<void>}
-   */
-  async connect() {
-    if (this._closed) throw new Error("BeaconClient has been closed")
-    if (this._connectPromise) return await this._connectPromise
-
-    this._connectPromise = new Promise((resolve, reject) => {
-      const onConnect = () => {
-        this.off("connect", onConnect)
-        this.off("connect-error", onError)
-        resolve()
-      }
-      const onError = (/**
-                        * Narrows the runtime value to the documented type.
-                         @type {Error} */ error) => {
-        this.off("connect", onConnect)
-        this.off("connect-error", onError)
-        reject(error)
-      }
-
-      this.on("connect", onConnect)
-      this.on("connect-error", onError)
-    })
-
-    this._openSocket()
-
-    return await this._connectPromise
-  }
-
-  /**
-   * Resolves after the Beacon daemon has acknowledged this peer's
-   * hello handshake. This is stronger than `isConnected()`: connected
-   * means the TCP socket is open, ready means the daemon has registered
-   * the peer and broadcasts can be routed through the bus.
-   * @param {object} [args] - Options.
-   * @param {number} [args.timeoutMs] - Optional timeout in milliseconds.
-   * @returns {Promise<void>}
-   */
-  async waitForReady({timeoutMs} = {}) {
-    if (this._ready) return
-
-    /** Cleanup. @type {() => void} */
-    let cleanup = () => {}
-    const readyPromise = new Promise((resolve) => {
-      const onReady = () => {
-        cleanup()
-        resolve(undefined)
-      }
-
-      cleanup = () => this.off("ready", onReady)
-      this.on("ready", onReady)
-    })
-
-    try {
-      if (typeof timeoutMs === "number") {
-        await timeout({timeout: timeoutMs}, async () => {
-          await readyPromise
-        })
-      } else {
-        await readyPromise
-      }
-    } finally {
-      cleanup()
+    publish({ channel, broadcastParams, body }) {
+        if (!this._connected || !this._jsonSocket)
+            return false;
+        /**
+         * Message.
+          @type {import("./types.js").BeaconBroadcastMessage} */
+        const message = {
+            type: "broadcast",
+            channel,
+            broadcastParams,
+            body,
+            originPeerId: this.peerId
+        };
+        try {
+            this._jsonSocket.send(message);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-  }
-
-  /**
-   * Publishes a broadcast message to all peers (including this one,
-   * unless the daemon is restarted mid-publish).
-   * @param {object} args - Broadcast args.
-   * @param {string} args.channel - Channel name.
-   * @param {Record<string, ?>} args.broadcastParams - Routing params.
-   * @param {?} args.body - Message body.
-   * @returns {boolean} - True if the publish was written to the socket. False if the client is currently disconnected.
-   */
-  publish({channel, broadcastParams, body}) {
-    if (!this._connected || !this._jsonSocket) return false
-
     /**
-     * Message.
-      @type {import("./types.js").BeaconBroadcastMessage} */
-    const message = {
-      type: "broadcast",
-      channel,
-      broadcastParams,
-      body,
-      originPeerId: this.peerId
+     * Registers a handler called once for every `broadcast` message
+     * received from the daemon (including echoes of this client's own
+     * publishes — synapse-style fan-out).
+     * @param {BeaconBroadcastHandler} handler - Handler.
+     * @returns {() => void} - Unregister function.
+     */
+    onBroadcast(handler) {
+        this.on("broadcast", handler);
+        return () => this.off("broadcast", handler);
     }
-
-    try {
-      this._jsonSocket.send(message)
-      return true
-    } catch {
-      return false
+    /**
+     * Runs close.
+     * @returns {Promise<void>} - Resolves once the socket is closed.
+     */
+    async close() {
+        this._closed = true;
+        if (this._reconnectTimer) {
+            clearTimeout(this._reconnectTimer);
+            this._reconnectTimer = undefined;
+        }
+        if (this._socket) {
+            const socket = this._socket;
+            await new Promise((resolve) => {
+                socket.once("close", () => resolve(undefined));
+                socket.end();
+            });
+        }
     }
-  }
-
-  /**
-   * Registers a handler called once for every `broadcast` message
-   * received from the daemon (including echoes of this client's own
-   * publishes — synapse-style fan-out).
-   * @param {BeaconBroadcastHandler} handler - Handler.
-   * @returns {() => void} - Unregister function.
-   */
-  onBroadcast(handler) {
-    this.on("broadcast", handler)
-    return () => this.off("broadcast", handler)
-  }
-
-  /**
-   * Runs close.
-   * @returns {Promise<void>} - Resolves once the socket is closed.
-   */
-  async close() {
-    this._closed = true
-
-    if (this._reconnectTimer) {
-      clearTimeout(this._reconnectTimer)
-      this._reconnectTimer = undefined
+    /**
+     * Runs open socket.
+     * @returns {void}
+     */
+    _openSocket() {
+        if (this._closed)
+            return;
+        const socket = net.createConnection({ host: this.host, port: this.port });
+        this._socket = socket;
+        const jsonSocket = new JsonSocket(socket);
+        this._jsonSocket = jsonSocket;
+        socket.on("connect", () => {
+            this._connected = true;
+            this._ready = false;
+            this._reconnectDelayMs = this._initialReconnectDelayMs;
+            jsonSocket.send({
+                type: "hello",
+                role: "client",
+                peerId: this.peerId,
+                peerType: this.peerType
+            });
+            this.emit("connect");
+        });
+        jsonSocket.on("message", (/**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {import("./types.js").BeaconSocketMessage} */ message) => {
+            if (message?.type === "hello-ack" && message.peerId === this.peerId) {
+                this._ready = true;
+                this.emit("ready");
+            }
+            else if (message?.type === "broadcast") {
+                this.emit("broadcast", message);
+            }
+        });
+        jsonSocket.on("error", (error) => {
+            if (!this._connected) {
+                // Initial connect failed — surface to `connect()`'s promise via `connect-error`.
+                // No `error` emit: that channel is for established-session errors; the
+                // initial-connect path is owned by `connect-error`.
+                this.emit("connect-error", error);
+            }
+            else {
+                // Established session error. Cache so the upcoming `close` event can
+                // surface it as the disconnect reason.
+                this._lastSocketError = error;
+                this.emit("error", error);
+            }
+        });
+        jsonSocket.on("close", () => {
+            const wasConnected = this._connected;
+            this._connected = false;
+            this._ready = false;
+            this._jsonSocket = undefined;
+            this._socket = undefined;
+            // Explicit close() sets `_closed = true` before ending the socket.
+            // Don't surface user-initiated teardown as a disconnect "error" —
+            // only network-driven drops should be reported.
+            if (wasConnected && !this._closed) {
+                const reason = this._lastSocketError || new Error("Beacon broker disconnected");
+                this.emit("disconnect", reason);
+            }
+            this._lastSocketError = undefined;
+            if (this._closed)
+                return;
+            this._scheduleReconnect();
+        });
     }
-
-    if (this._socket) {
-      const socket = this._socket
-
-      await new Promise((resolve) => {
-        socket.once("close", () => resolve(undefined))
-        socket.end()
-      })
+    /**
+     * Runs schedule reconnect.
+     * @returns {void}
+     */
+    _scheduleReconnect() {
+        if (this._reconnectTimer)
+            return;
+        const delay = this._reconnectDelayMs;
+        this._reconnectTimer = setTimeout(() => {
+            this._reconnectTimer = undefined;
+            this._reconnectDelayMs = Math.min(delay * 2, this._maxReconnectDelayMs);
+            this._openSocket();
+        }, delay);
     }
-  }
-
-  /**
-   * Runs open socket.
-   * @returns {void}
-   */
-  _openSocket() {
-    if (this._closed) return
-
-    const socket = net.createConnection({host: this.host, port: this.port})
-    this._socket = socket
-    const jsonSocket = new JsonSocket(socket)
-    this._jsonSocket = jsonSocket
-
-    socket.on("connect", () => {
-      this._connected = true
-      this._ready = false
-      this._reconnectDelayMs = this._initialReconnectDelayMs
-
-      jsonSocket.send({
-        type: "hello",
-        role: "client",
-        peerId: this.peerId,
-        peerType: this.peerType
-      })
-
-      this.emit("connect")
-    })
-
-    jsonSocket.on("message", (/**
-                               * Narrows the runtime value to the documented type.
-                                @type {import("./types.js").BeaconSocketMessage} */ message) => {
-      if (message?.type === "hello-ack" && message.peerId === this.peerId) {
-        this._ready = true
-        this.emit("ready")
-      } else if (message?.type === "broadcast") {
-        this.emit("broadcast", message)
-      }
-    })
-
-    jsonSocket.on("error", (error) => {
-      if (!this._connected) {
-        // Initial connect failed — surface to `connect()`'s promise via `connect-error`.
-        // No `error` emit: that channel is for established-session errors; the
-        // initial-connect path is owned by `connect-error`.
-        this.emit("connect-error", error)
-      } else {
-        // Established session error. Cache so the upcoming `close` event can
-        // surface it as the disconnect reason.
-        this._lastSocketError = error
-        this.emit("error", error)
-      }
-    })
-
-    jsonSocket.on("close", () => {
-      const wasConnected = this._connected
-
-      this._connected = false
-      this._ready = false
-      this._jsonSocket = undefined
-      this._socket = undefined
-
-      // Explicit close() sets `_closed = true` before ending the socket.
-      // Don't surface user-initiated teardown as a disconnect "error" —
-      // only network-driven drops should be reported.
-      if (wasConnected && !this._closed) {
-        const reason = this._lastSocketError || new Error("Beacon broker disconnected")
-
-        this.emit("disconnect", reason)
-      }
-
-      this._lastSocketError = undefined
-
-      if (this._closed) return
-
-      this._scheduleReconnect()
-    })
-  }
-
-  /**
-   * Runs schedule reconnect.
-   * @returns {void}
-   */
-  _scheduleReconnect() {
-    if (this._reconnectTimer) return
-
-    const delay = this._reconnectDelayMs
-
-    this._reconnectTimer = setTimeout(() => {
-      this._reconnectTimer = undefined
-      this._reconnectDelayMs = Math.min(delay * 2, this._maxReconnectDelayMs)
-      this._openSocket()
-    }, delay)
-  }
 }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {randomUUID} from \"node:crypto\"\nimport net from \"node:net\"\nimport timeout from \"awaitery/build/timeout.js\"\n\nimport JsonSocket from \"../background-jobs/json-socket.js\"\nimport EventEmitter from \"../utils/event-emitter.js\"\n\nconst DEFAULT_RECONNECT_DELAY_MS = 1000\nconst MAX_RECONNECT_DELAY_MS = 30_000\n\n/**\n * BeaconBroadcastHandler type.\n * @typedef {function(import(\"./types.js\").BeaconBroadcastMessage): void} BeaconBroadcastHandler\n */\n\n/**\n * BeaconClient connects to a `velocious beacon` daemon and exchanges\n * broadcasts with all peer processes connected to the same daemon.\n *\n * Lifecycle:\n *   const client = new BeaconClient({host, port, peerType: \"server\"})\n *   await client.connect()                         // resolves on first successful connect\n *   await client.waitForReady({timeoutMs: 1000})   // resolves after the daemon hello-ack\n *   client.onBroadcast((message) => { ... })       // every fan-out\n *   client.publish({channel, broadcastParams, body})\n *   await client.close()\n *\n * Reconnect: on socket close (without an explicit `close()` call) the\n * client schedules a reconnect with exponential backoff. While the\n * underlying socket is down, `publish(...)` returns false and the\n * caller can fall back to local-only delivery; subsequent reconnects do\n * not replay missed publishes (Beacon is pubsub, not a queue).\n */\nexport default class BeaconClient extends EventEmitter {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options.\n   * @param {string} args.host - Beacon host.\n   * @param {number} args.port - Beacon port.\n   * @param {string} [args.peerType] - Optional human-readable peer label.\n   * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).\n   * @param {number} [args.reconnectDelayMs] - Starting reconnect delay in ms.\n   * @param {number} [args.maxReconnectDelayMs] - Maximum reconnect delay in ms.\n   */\n  constructor({host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs}) {\n    super()\n    this.host = host\n    this.port = port\n    this.peerType = peerType\n    this.peerId = peerId || randomUUID()\n    this._initialReconnectDelayMs = reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS\n    this._maxReconnectDelayMs = maxReconnectDelayMs ?? MAX_RECONNECT_DELAY_MS\n    this._reconnectDelayMs = this._initialReconnectDelayMs\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {JsonSocket | undefined} */\n    this._jsonSocket = undefined\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {net.Socket | undefined} */\n    this._socket = undefined\n    this._connected = false\n    this._ready = false\n    this._closed = false\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {NodeJS.Timeout | undefined} */\n    this._reconnectTimer = undefined\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {Promise<void> | undefined} */\n    this._connectPromise = undefined\n    /**\n     * Last socket error observed while connected, surfaced as the disconnect reason.\n     * @type {Error | undefined}\n     */\n    this._lastSocketError = undefined\n  }\n\n  /**\n   * Runs get peer id.\n   * @returns {string} - The peer id sent on the hello handshake.\n   */\n  getPeerId() { return this.peerId }\n\n  /**\n   * Runs is connected.\n   * @returns {boolean} - Whether the underlying socket is currently connected.\n   */\n  isConnected() { return this._connected }\n\n  /**\n   * Runs is ready.\n   * @returns {boolean} - Whether the daemon has acknowledged this peer registration.\n   */\n  isReady() { return this._ready }\n\n  /**\n   * Resolves on the first successful connect. Subsequent calls return\n   * the same promise. Subsequent reconnects after a drop are silent —\n   * use `on(\"connect\")` / `on(\"disconnect\", reason)` to observe them.\n   * The `disconnect` listener receives an `Error` reason: either the\n   * underlying socket error, or `Error(\"Beacon broker disconnected\")`\n   * when the close had no preceding error.\n   * @returns {Promise<void>}\n   */\n  async connect() {\n    if (this._closed) throw new Error(\"BeaconClient has been closed\")\n    if (this._connectPromise) return await this._connectPromise\n\n    this._connectPromise = new Promise((resolve, reject) => {\n      const onConnect = () => {\n        this.off(\"connect\", onConnect)\n        this.off(\"connect-error\", onError)\n        resolve()\n      }\n      const onError = (/**\n                        * Narrows the runtime value to the documented type.\n                         @type {Error} */ error) => {\n        this.off(\"connect\", onConnect)\n        this.off(\"connect-error\", onError)\n        reject(error)\n      }\n\n      this.on(\"connect\", onConnect)\n      this.on(\"connect-error\", onError)\n    })\n\n    this._openSocket()\n\n    return await this._connectPromise\n  }\n\n  /**\n   * Resolves after the Beacon daemon has acknowledged this peer's\n   * hello handshake. This is stronger than `isConnected()`: connected\n   * means the TCP socket is open, ready means the daemon has registered\n   * the peer and broadcasts can be routed through the bus.\n   * @param {object} [args] - Options.\n   * @param {number} [args.timeoutMs] - Optional timeout in milliseconds.\n   * @returns {Promise<void>}\n   */\n  async waitForReady({timeoutMs} = {}) {\n    if (this._ready) return\n\n    /** Cleanup. @type {() => void} */\n    let cleanup = () => {}\n    const readyPromise = new Promise((resolve) => {\n      const onReady = () => {\n        cleanup()\n        resolve(undefined)\n      }\n\n      cleanup = () => this.off(\"ready\", onReady)\n      this.on(\"ready\", onReady)\n    })\n\n    try {\n      if (typeof timeoutMs === \"number\") {\n        await timeout({timeout: timeoutMs}, async () => {\n          await readyPromise\n        })\n      } else {\n        await readyPromise\n      }\n    } finally {\n      cleanup()\n    }\n  }\n\n  /**\n   * Publishes a broadcast message to all peers (including this one,\n   * unless the daemon is restarted mid-publish).\n   * @param {object} args - Broadcast args.\n   * @param {string} args.channel - Channel name.\n   * @param {Record<string, ?>} args.broadcastParams - Routing params.\n   * @param {?} args.body - Message body.\n   * @returns {boolean} - True if the publish was written to the socket. False if the client is currently disconnected.\n   */\n  publish({channel, broadcastParams, body}) {\n    if (!this._connected || !this._jsonSocket) return false\n\n    /**\n     * Message.\n      @type {import(\"./types.js\").BeaconBroadcastMessage} */\n    const message = {\n      type: \"broadcast\",\n      channel,\n      broadcastParams,\n      body,\n      originPeerId: this.peerId\n    }\n\n    try {\n      this._jsonSocket.send(message)\n      return true\n    } catch {\n      return false\n    }\n  }\n\n  /**\n   * Registers a handler called once for every `broadcast` message\n   * received from the daemon (including echoes of this client's own\n   * publishes — synapse-style fan-out).\n   * @param {BeaconBroadcastHandler} handler - Handler.\n   * @returns {() => void} - Unregister function.\n   */\n  onBroadcast(handler) {\n    this.on(\"broadcast\", handler)\n    return () => this.off(\"broadcast\", handler)\n  }\n\n  /**\n   * Runs close.\n   * @returns {Promise<void>} - Resolves once the socket is closed.\n   */\n  async close() {\n    this._closed = true\n\n    if (this._reconnectTimer) {\n      clearTimeout(this._reconnectTimer)\n      this._reconnectTimer = undefined\n    }\n\n    if (this._socket) {\n      const socket = this._socket\n\n      await new Promise((resolve) => {\n        socket.once(\"close\", () => resolve(undefined))\n        socket.end()\n      })\n    }\n  }\n\n  /**\n   * Runs open socket.\n   * @returns {void}\n   */\n  _openSocket() {\n    if (this._closed) return\n\n    const socket = net.createConnection({host: this.host, port: this.port})\n    this._socket = socket\n    const jsonSocket = new JsonSocket(socket)\n    this._jsonSocket = jsonSocket\n\n    socket.on(\"connect\", () => {\n      this._connected = true\n      this._ready = false\n      this._reconnectDelayMs = this._initialReconnectDelayMs\n\n      jsonSocket.send({\n        type: \"hello\",\n        role: \"client\",\n        peerId: this.peerId,\n        peerType: this.peerType\n      })\n\n      this.emit(\"connect\")\n    })\n\n    jsonSocket.on(\"message\", (/**\n                               * Narrows the runtime value to the documented type.\n                                @type {import(\"./types.js\").BeaconSocketMessage} */ message) => {\n      if (message?.type === \"hello-ack\" && message.peerId === this.peerId) {\n        this._ready = true\n        this.emit(\"ready\")\n      } else if (message?.type === \"broadcast\") {\n        this.emit(\"broadcast\", message)\n      }\n    })\n\n    jsonSocket.on(\"error\", (error) => {\n      if (!this._connected) {\n        // Initial connect failed — surface to `connect()`'s promise via `connect-error`.\n        // No `error` emit: that channel is for established-session errors; the\n        // initial-connect path is owned by `connect-error`.\n        this.emit(\"connect-error\", error)\n      } else {\n        // Established session error. Cache so the upcoming `close` event can\n        // surface it as the disconnect reason.\n        this._lastSocketError = error\n        this.emit(\"error\", error)\n      }\n    })\n\n    jsonSocket.on(\"close\", () => {\n      const wasConnected = this._connected\n\n      this._connected = false\n      this._ready = false\n      this._jsonSocket = undefined\n      this._socket = undefined\n\n      // Explicit close() sets `_closed = true` before ending the socket.\n      // Don't surface user-initiated teardown as a disconnect \"error\" —\n      // only network-driven drops should be reported.\n      if (wasConnected && !this._closed) {\n        const reason = this._lastSocketError || new Error(\"Beacon broker disconnected\")\n\n        this.emit(\"disconnect\", reason)\n      }\n\n      this._lastSocketError = undefined\n\n      if (this._closed) return\n\n      this._scheduleReconnect()\n    })\n  }\n\n  /**\n   * Runs schedule reconnect.\n   * @returns {void}\n   */\n  _scheduleReconnect() {\n    if (this._reconnectTimer) return\n\n    const delay = this._reconnectDelayMs\n\n    this._reconnectTimer = setTimeout(() => {\n      this._reconnectTimer = undefined\n      this._reconnectDelayMs = Math.min(delay * 2, this._maxReconnectDelayMs)\n      this._openSocket()\n    }, delay)\n  }\n}\n"]}