velocious 1.0.430 → 1.0.431

package/build/src/beacon/client.js

@@ -1,15 +1,20 @@
 // @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.
@@ -29,273 +34,297 @@ 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
     /**
-     * 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 {JsonSocket | undefined} */
+    this._jsonSocket = 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; }
+     * 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 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 {NodeJS.Timeout | undefined} */
+    this._reconnectTimer = 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();
-        }
-    }
+     * Narrows the runtime value to the documented type.
+      @type {Promise<void> | undefined} */
+    this._connectPromise = 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.
+     * Last socket error observed while connected, surfaced as the disconnect reason.
+     * @type {Error | undefined}
      */
-    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;
-        }
+    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()
     }
+  }
+
+  /**
+   * 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
+
     /**
-     * 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);
+     * Message.
+      @type {import("./types.js").BeaconBroadcastMessage} */
+    const message = {
+      type: "broadcast",
+      channel,
+      broadcastParams,
+      body,
+      originPeerId: this.peerId
     }
-    /**
-     * 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();
-            });
-        }
+
+    try {
+      this._jsonSocket.send(message)
+      return true
+    } catch {
+      return false
     }
-    /**
-     * 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();
-        });
+  }
+
+  /**
+   * 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 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);
+
+    if (this._socket) {
+      const socket = this._socket
+
+      await new Promise((resolve) => {
+        socket.once("close", () => resolve(undefined))
+        socket.end()
+      })
     }
+  }
+
+  /**
+   * 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"]}