velocious 1.0.428 → 1.0.430

package/build/src/beacon/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":";AAYA;;GAEG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;;;;;;OAQG;IACH,qFAPG;QAAqB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;QACQ,QAAQ;QACR,MAAM;QACN,gBAAgB;QAChB,mBAAmB;KAC3C,EA0BA;IAvBC,aAAgB;IAChB,aAAgB;IAChB,6BAAwB;IACxB,eAAoC;IACpC,iCAA8E;IAC9E,6BAAyE;IACzE,0BAAsD;IACtD,qCAAqC;IACrC,aADW,UAAU,GAAG,SAAS,CACL;IAC5B,qCAAqC;IACrC,SADW,GAAG,CAAC,MAAM,GAAG,SAAS,CACT;IACxB,oBAAuB;IACvB,gBAAmB;IACnB,iBAAoB;IACpB,yCAAyC;IACzC,iBADW,MAAM,CAAC,OAAO,GAAG,SAAS,CACL;IAChC,wCAAwC;IACxC,iBADW,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CACJ;IAChC;;;OAGG;IACH,kBAFU,KAAK,GAAG,SAAS,CAEM;IAGnC,mEAAmE;IACnE,aADc,MAAM,CACc;IAElC,iFAAiF;IACjF,eADc,OAAO,CACmB;IAExC,uFAAuF;IACvF,WADc,OAAO,CACW;IAEhC;;;;;;;;OAQG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;OAQG;IACH,6BAHG;QAAsB,SAAS;KAC/B,GAAU,OAAO,CAAC,IAAI,CAAC,CA4BzB;IAED;;;;;;;;OAQG;IACH,4CALG;QAAqB,OAAO,EAApB,MAAM;QACoB,eAAe,EAAzC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACT,IAAI,EAAd,GAAG;KACX,GAAU,OAAO,CAoBnB;IAED;;;;;;OAMG;IACH,qBAHW,sBAAsB,GACpB,MAAM,IAAI,CAKtB;IAED,qEAAqE;IACrE,SADc,OAAO,CAAC,IAAI,CAAC,CAiB1B;IAED;;OAEG;IACH,eAFa,IAAI,CAuEhB;IAED;;OAEG;IACH,sBAFa,IAAI,CAYhB;CACF;qCA9RY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI;uBAPjD,mCAAmC;gBAH1C,UAAU"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":";AAYA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;;;;;;;OASG;IACH,qFAPG;QAAqB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;QACQ,QAAQ;QACR,MAAM;QACN,gBAAgB;QAChB,mBAAmB;KAC3C,EAkCA;IA/BC,aAAgB;IAChB,aAAgB;IAChB,6BAAwB;IACxB,eAAoC;IACpC,iCAA8E;IAC9E,6BAAyE;IACzE,0BAAsD;IACtD;;uCAEmC;IACnC,aADS,UAAU,GAAG,SAAS,CACH;IAC5B;;uCAEmC;IACnC,SADS,GAAG,CAAC,MAAM,GAAG,SAAS,CACP;IACxB,oBAAuB;IACvB,gBAAmB;IACnB,iBAAoB;IACpB;;2CAEuC;IACvC,iBADS,MAAM,CAAC,OAAO,GAAG,SAAS,CACH;IAChC;;0CAEsC;IACtC,iBADS,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CACF;IAChC;;;OAGG;IACH,kBAFU,KAAK,GAAG,SAAS,CAEM;IAGnC;;;OAGG;IACH,aAFa,MAAM,CAEe;IAElC;;;OAGG;IACH,eAFa,OAAO,CAEoB;IAExC;;;OAGG;IACH,WAFa,OAAO,CAEY;IAEhC;;;;;;;;OAQG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CA2BzB;IAED;;;;;;;;OAQG;IACH,6BAHG;QAAsB,SAAS;KAC/B,GAAU,OAAO,CAAC,IAAI,CAAC,CA4BzB;IAED;;;;;;;;OAQG;IACH,4CALG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;KACT,GAAU,OAAO,CAsBnB;IAED;;;;;;OAMG;IACH,qBAHW,sBAAsB,GACpB,MAAM,IAAI,CAKtB;IAED;;;OAGG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;OAGG;IACH,eAFa,IAAI,CAyEhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAYhB;CACF;;;;qCA3TY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI;uBARjD,mCAAmC;gBAH1C,UAAU"}

package/build/src/beacon/client.js

@@ -7,6 +7,7 @@ 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
  */
 /**
@@ -29,6 +30,7 @@ const MAX_RECONNECT_DELAY_MS = 30_000;
  */
 export default class BeaconClient extends EventEmitter {
     /**
+     * Runs constructor.
      * @param {object} args - Options.
      * @param {string} args.host - Beacon host.
      * @param {number} args.port - Beacon port.
@@ -46,16 +48,24 @@ export default class BeaconClient extends EventEmitter {
         this._initialReconnectDelayMs = reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
         this._maxReconnectDelayMs = maxReconnectDelayMs ?? MAX_RECONNECT_DELAY_MS;
         this._reconnectDelayMs = this._initialReconnectDelayMs;
-        /** @type {JsonSocket | undefined} */
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {JsonSocket | undefined} */
         this._jsonSocket = undefined;
-        /** @type {net.Socket | 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;
-        /** @type {NodeJS.Timeout | undefined} */
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {NodeJS.Timeout | undefined} */
         this._reconnectTimer = undefined;
-        /** @type {Promise<void> | 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.
@@ -63,11 +73,20 @@ export default class BeaconClient extends EventEmitter {
          */
         this._lastSocketError = undefined;
     }
-    /** @returns {string} - The peer id sent on the hello handshake. */
+    /**
+     * Runs get peer id.
+     * @returns {string} - The peer id sent on the hello handshake.
+     */
     getPeerId() { return this.peerId; }
-    /** @returns {boolean} - Whether the underlying socket is currently connected. */
+    /**
+     * Runs is connected.
+     * @returns {boolean} - Whether the underlying socket is currently connected.
+     */
     isConnected() { return this._connected; }
-    /** @returns {boolean} - Whether the daemon has acknowledged this peer registration. */
+    /**
+     * 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
@@ -89,7 +108,9 @@ export default class BeaconClient extends EventEmitter {
                 this.off("connect-error", onError);
                 resolve();
             };
-            const onError = (/** @type {Error} */ error) => {
+            const onError = (/**
+                              * Narrows the runtime value to the documented type.
+                               @type {Error} */ error) => {
                 this.off("connect", onConnect);
                 this.off("connect-error", onError);
                 reject(error);
@@ -112,7 +133,7 @@ export default class BeaconClient extends EventEmitter {
     async waitForReady({ timeoutMs } = {}) {
         if (this._ready)
             return;
-        /** @type {() => void} */
+        /** Cleanup. @type {() => void} */
         let cleanup = () => { };
         const readyPromise = new Promise((resolve) => {
             const onReady = () => {
@@ -141,14 +162,16 @@ export default class BeaconClient extends EventEmitter {
      * unless the daemon is restarted mid-publish).
      * @param {object} args - Broadcast args.
      * @param {string} args.channel - Channel name.
-     * @param {Record<string, any>} args.broadcastParams - Routing params.
-     * @param {any} args.body - Message body.
+     * @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;
-        /** @type {import("./types.js").BeaconBroadcastMessage} */
+        /**
+         * Message.
+          @type {import("./types.js").BeaconBroadcastMessage} */
         const message = {
             type: "broadcast",
             channel,
@@ -175,7 +198,10 @@ export default class BeaconClient extends EventEmitter {
         this.on("broadcast", handler);
         return () => this.off("broadcast", handler);
     }
-    /** @returns {Promise<void>} - Resolves once the socket is closed. */
+    /**
+     * Runs close.
+     * @returns {Promise<void>} - Resolves once the socket is closed.
+     */
     async close() {
         this._closed = true;
         if (this._reconnectTimer) {
@@ -191,6 +217,7 @@ export default class BeaconClient extends EventEmitter {
         }
     }
     /**
+     * Runs open socket.
      * @returns {void}
      */
     _openSocket() {
@@ -212,7 +239,9 @@ export default class BeaconClient extends EventEmitter {
             });
             this.emit("connect");
         });
-        jsonSocket.on("message", (/** @type {import("./types.js").BeaconSocketMessage} */ message) => {
+        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");
@@ -255,6 +284,7 @@ export default class BeaconClient extends EventEmitter {
         });
     }
     /**
+     * Runs schedule reconnect.
      * @returns {void}
      */
     _scheduleReconnect() {
@@ -268,4 +298,4 @@ export default class BeaconClient extends EventEmitter {
         }, 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 * @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   * @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    /** @type {JsonSocket | undefined} */\n    this._jsonSocket = undefined\n    /** @type {net.Socket | undefined} */\n    this._socket = undefined\n    this._connected = false\n    this._ready = false\n    this._closed = false\n    /** @type {NodeJS.Timeout | undefined} */\n    this._reconnectTimer = undefined\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  /** @returns {string} - The peer id sent on the hello handshake. */\n  getPeerId() { return this.peerId }\n\n  /** @returns {boolean} - Whether the underlying socket is currently connected. */\n  isConnected() { return this._connected }\n\n  /** @returns {boolean} - Whether the daemon has acknowledged this peer registration. */\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 = (/** @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    /** @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, any>} args.broadcastParams - Routing params.\n   * @param {any} 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    /** @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  /** @returns {Promise<void>} - Resolves once the socket is closed. */\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   * @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\", (/** @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   * @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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AACtC,OAAO,GAAG,MAAM,UAAU,CAAA;AAC1B,OAAO,OAAO,MAAM,2BAA2B,CAAA;AAE/C,OAAO,UAAU,MAAM,mCAAmC,CAAA;AAC1D,OAAO,YAAY,MAAM,2BAA2B,CAAA;AAEpD,MAAM,0BAA0B,GAAG,IAAI,CAAA;AACvC,MAAM,sBAAsB,GAAG,MAAM,CAAA;AAErC;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,YAAY;IACpD;;;;;;;;;OASG;IACH,YAAY,EAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,mBAAmB,EAAC;QAC/E,KAAK,EAAE,CAAA;QACP,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,UAAU,EAAE,CAAA;QACpC,IAAI,CAAC,wBAAwB,GAAG,gBAAgB,IAAI,0BAA0B,CAAA;QAC9E,IAAI,CAAC,oBAAoB,GAAG,mBAAmB,IAAI,sBAAsB,CAAA;QACzE,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,wBAAwB,CAAA;QACtD;;2CAEmC;QACnC,IAAI,CAAC,WAAW,GAAG,SAAS,CAAA;QAC5B;;2CAEmC;QACnC,IAAI,CAAC,OAAO,GAAG,SAAS,CAAA;QACxB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;QACvB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QACnB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAA;QACpB;;+CAEuC;QACvC,IAAI,CAAC,eAAe,GAAG,SAAS,CAAA;QAChC;;8CAEsC;QACtC,IAAI,CAAC,eAAe,GAAG,SAAS,CAAA;QAChC;;;WAGG;QACH,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAA;IACnC,CAAC;IAED;;;OAGG;IACH,SAAS,KAAK,OAAO,IAAI,CAAC,MAAM,CAAA,CAAC,CAAC;IAElC;;;OAGG;IACH,WAAW,KAAK,OAAO,IAAI,CAAC,UAAU,CAAA,CAAC,CAAC;IAExC;;;OAGG;IACH,OAAO,KAAK,OAAO,IAAI,CAAC,MAAM,CAAA,CAAC,CAAC;IAEhC;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAA;QACjE,IAAI,IAAI,CAAC,eAAe;YAAE,OAAO,MAAM,IAAI,CAAC,eAAe,CAAA;QAE3D,IAAI,CAAC,eAAe,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrD,MAAM,SAAS,GAAG,GAAG,EAAE;gBACrB,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;gBAC9B,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,OAAO,CAAC,CAAA;gBAClC,OAAO,EAAE,CAAA;YACX,CAAC,CAAA;YACD,MAAM,OAAO,GAAG,CAAC;;+CAEkB,CAAC,KAAK,EAAE,EAAE;gBAC3C,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;gBAC9B,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,OAAO,CAAC,CAAA;gBAClC,MAAM,CAAC,KAAK,CAAC,CAAA;YACf,CAAC,CAAA;YAED,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;YAC7B,IAAI,CAAC,EAAE,CAAC,eAAe,EAAE,OAAO,CAAC,CAAA;QACnC,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,WAAW,EAAE,CAAA;QAElB,OAAO,MAAM,IAAI,CAAC,eAAe,CAAA;IACnC,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,YAAY,CAAC,EAAC,SAAS,EAAC,GAAG,EAAE;QACjC,IAAI,IAAI,CAAC,MAAM;YAAE,OAAM;QAEvB,kCAAkC;QAClC,IAAI,OAAO,GAAG,GAAG,EAAE,GAAE,CAAC,CAAA;QACtB,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC3C,MAAM,OAAO,GAAG,GAAG,EAAE;gBACnB,OAAO,EAAE,CAAA;gBACT,OAAO,CAAC,SAAS,CAAC,CAAA;YACpB,CAAC,CAAA;YAED,OAAO,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;YAC1C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QAC3B,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC;YACH,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;gBAClC,MAAM,OAAO,CAAC,EAAC,OAAO,EAAE,SAAS,EAAC,EAAE,KAAK,IAAI,EAAE;oBAC7C,MAAM,YAAY,CAAA;gBACpB,CAAC,CAAC,CAAA;YACJ,CAAC;iBAAM,CAAC;gBACN,MAAM,YAAY,CAAA;YACpB,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,OAAO,EAAE,CAAA;QACX,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAC;QACtC,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO,KAAK,CAAA;QAEvD;;gEAEwD;QACxD,MAAM,OAAO,GAAG;YACd,IAAI,EAAE,WAAW;YACjB,OAAO;YACP,eAAe;YACf,IAAI;YACJ,YAAY,EAAE,IAAI,CAAC,MAAM;SAC1B,CAAA;QAED,IAAI,CAAC;YACH,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;YAC9B,OAAO,IAAI,CAAA;QACb,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAC,OAAO;QACjB,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;QAC7B,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;IAC7C,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;QAEnB,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;YAClC,IAAI,CAAC,eAAe,GAAG,SAAS,CAAA;QAClC,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAA;YAE3B,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC5B,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAA;gBAC9C,MAAM,CAAC,GAAG,EAAE,CAAA;YACd,CAAC,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,IAAI,IAAI,CAAC,OAAO;YAAE,OAAM;QAExB,MAAM,MAAM,GAAG,GAAG,CAAC,gBAAgB,CAAC,EAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAC,CAAC,CAAA;QACvE,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QACrB,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAA;QACzC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAA;QAE7B,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;YACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;YACtB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;YACnB,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,wBAAwB,CAAA;YAEtD,UAAU,CAAC,IAAI,CAAC;gBACd,IAAI,EAAE,OAAO;gBACb,IAAI,EAAE,QAAQ;gBACd,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;aACxB,CAAC,CAAA;YAEF,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACtB,CAAC,CAAC,CAAA;QAEF,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC;;uFAEqD,CAAC,OAAO,EAAE,EAAE;YACzF,IAAI,OAAO,EAAE,IAAI,KAAK,WAAW,IAAI,OAAO,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;gBACpE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;gBAClB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;YACpB,CAAC;iBAAM,IAAI,OAAO,EAAE,IAAI,KAAK,WAAW,EAAE,CAAC;gBACzC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;YACjC,CAAC;QACH,CAAC,CAAC,CAAA;QAEF,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YAC/B,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;gBACrB,iFAAiF;gBACjF,uEAAuE;gBACvE,oDAAoD;gBACpD,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,CAAA;YACnC,CAAC;iBAAM,CAAC;gBACN,qEAAqE;gBACrE,uCAAuC;gBACvC,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAA;gBAC7B,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;YAC3B,CAAC;QACH,CAAC,CAAC,CAAA;QAEF,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;YAC1B,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAA;YAEpC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;YACvB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;YACnB,IAAI,CAAC,WAAW,GAAG,SAAS,CAAA;YAC5B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAA;YAExB,mEAAmE;YACnE,kEAAkE;YAClE,gDAAgD;YAChD,IAAI,YAAY,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;gBAClC,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,IAAI,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAA;gBAE/E,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CAAA;YACjC,CAAC;YAED,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAA;YAEjC,IAAI,IAAI,CAAC,OAAO;gBAAE,OAAM;YAExB,IAAI,CAAC,kBAAkB,EAAE,CAAA;QAC3B,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,kBAAkB;QAChB,IAAI,IAAI,CAAC,eAAe;YAAE,OAAM;QAEhC,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAA;QAEpC,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC,GAAG,EAAE;YACrC,IAAI,CAAC,eAAe,GAAG,SAAS,CAAA;YAChC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAA;YACvE,IAAI,CAAC,WAAW,EAAE,CAAA;QACpB,CAAC,EAAE,KAAK,CAAC,CAAA;IACX,CAAC;CACF","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"]}

package/build/src/beacon/in-process-broker.d.ts

@@ -13,9 +13,13 @@ export function registerInProcessPeer(peer: InProcessPeer): () => void;
  */
 export function publishToInProcessPeers(message: import("./types.js").BeaconBroadcastMessage): void;
 /**
+ * Runs the getInProcessPeerCount helper.
  * @returns {number} - Current peer count. Exposed for diagnostics and tests.
  */
 export function getInProcessPeerCount(): number;
+/**
+ * Defines this typedef.
+ */
 export type InProcessPeer = {
     _receiveBroadcast: (message: import("./types.js").BeaconBroadcastMessage) => void;
 };

package/build/src/beacon/in-process-broker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-process-broker.d.ts","sourceRoot":"","sources":["../../../src/beacon/in-process-broker.js"],"names":[],"mappings":"AAyBA;;;;GAIG;AACH,4CAHW,aAAa,GACX,MAAM,IAAI,CAQtB;AAED;;;;;;GAMG;AACH,iDAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAehB;AAED;;GAEG;AACH,yCAFa,MAAM,CAIlB;4BA7Ca;IAAC,iBAAiB,EAAE,CAAC,OAAO,EAAE,OAAO,YAAY,EAAE,sBAAsB,KAAK,IAAI,CAAA;CAAC"}
+{"version":3,"file":"in-process-broker.d.ts","sourceRoot":"","sources":["../../../src/beacon/in-process-broker.js"],"names":[],"mappings":"AA6BA;;;;GAIG;AACH,4CAHW,aAAa,GACX,MAAM,IAAI,CAQtB;AAED;;;;;;GAMG;AACH,iDAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAehB;AAED;;;GAGG;AACH,yCAFa,MAAM,CAIlB;;;;4BAhDW;IAAC,iBAAiB,EAAE,CAAC,OAAO,EAAE,OAAO,YAAY,EAAE,sBAAsB,KAAK,IAAI,CAAA;CAAC"}

package/build/src/beacon/in-process-broker.js

@@ -16,8 +16,12 @@
  *   2. Single-process production deployments that want the same
  *      `broadcastToChannel` ergonomics without running the daemon.
  */
-/** @typedef {{_receiveBroadcast: (message: import("./types.js").BeaconBroadcastMessage) => void}} InProcessPeer */
-/** @type {Set<InProcessPeer>} */
+/**
+ * Defines this typedef.
+  @typedef {{_receiveBroadcast: (message: import("./types.js").BeaconBroadcastMessage) => void}} InProcessPeer */
+/**
+ * Peers.
+  @type {Set<InProcessPeer>} */
 const peers = new Set();
 /**
  * Registers a peer with the broker. Returns an unregister function.
@@ -53,9 +57,10 @@ export function publishToInProcessPeers(message) {
     }
 }
 /**
+ * Runs the getInProcessPeerCount helper.
  * @returns {number} - Current peer count. Exposed for diagnostics and tests.
  */
 export function getInProcessPeerCount() {
     return peers.size;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/beacon/in-process-client.d.ts

@@ -1,5 +1,6 @@
 declare const InProcessBeaconClient_base: typeof import("eventemitter3").EventEmitter;
 /**
+ * BeaconBroadcastHandler type.
  * @typedef {function(import("./types.js").BeaconBroadcastMessage): void} BeaconBroadcastHandler
  */
 /**
@@ -17,6 +18,7 @@ declare const InProcessBeaconClient_base: typeof import("eventemitter3").EventEm
  */
 export default class InProcessBeaconClient extends InProcessBeaconClient_base {
     /**
+     * Runs constructor.
      * @param {object} [args] - Options.
      * @param {string} [args.peerType] - Optional human-readable peer label.
      * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).
@@ -28,13 +30,24 @@ export default class InProcessBeaconClient extends InProcessBeaconClient_base {
     peerType: string | undefined;
     peerId: string;
     _connected: boolean;
-    /** @type {(() => void) | undefined} */
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {(() => void) | undefined} */
     _unregister: (() => void) | undefined;
-    /** @returns {string} - Peer id. */
+    /**
+     * Runs get peer id.
+     * @returns {string} - Peer id.
+     */
     getPeerId(): string;
-    /** @returns {boolean} - Whether the peer is registered with the broker. */
+    /**
+     * Runs is connected.
+     * @returns {boolean} - Whether the peer is registered with the broker.
+     */
     isConnected(): boolean;
-    /** @returns {boolean} - Whether the peer is ready to publish through the broker. */
+    /**
+     * Runs is ready.
+     * @returns {boolean} - Whether the peer is ready to publish through the broker.
+     */
     isReady(): boolean;
     /**
      * Registers with the in-process broker. Idempotent.
@@ -52,14 +65,14 @@ export default class InProcessBeaconClient extends InProcessBeaconClient_base {
      * `BeaconClient` semantics.
      * @param {object} args - Broadcast args.
      * @param {string} args.channel - Channel name.
-     * @param {Record<string, any>} args.broadcastParams - Routing params.
-     * @param {any} args.body - Message body.
+     * @param {Record<string, ?>} args.broadcastParams - Routing params.
+     * @param {?} args.body - Message body.
      * @returns {boolean} - True when the broadcast was queued.
      */
     publish({ channel, broadcastParams, body }: {
         channel: string;
-        broadcastParams: Record<string, any>;
-        body: any;
+        broadcastParams: Record<string, unknown>;
+        body: unknown;
     }): boolean;
     /**
      * Registers a handler called once for every broadcast received.
@@ -73,9 +86,15 @@ export default class InProcessBeaconClient extends InProcessBeaconClient_base {
      * @returns {void}
      */
     _receiveBroadcast(message: import("./types.js").BeaconBroadcastMessage): void;
-    /** @returns {Promise<void>} - Unregisters from the broker. */
+    /**
+     * Runs close.
+     * @returns {Promise<void>} - Unregisters from the broker.
+     */
     close(): Promise<void>;
 }
+/**
+ * BeaconBroadcastHandler type.
+ */
 export type BeaconBroadcastHandler = (arg0: import("./types.js").BeaconBroadcastMessage) => void;
 export {};
 //# sourceMappingURL=in-process-client.d.ts.map

package/build/src/beacon/in-process-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-process-client.d.ts","sourceRoot":"","sources":["../../../src/beacon/in-process-client.js"],"names":[],"mappings":";AAOA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACE;;;;OAIG;IACH,mCAHG;QAAsB,QAAQ;QACR,MAAM;KAC9B,EAQA;IALC,6BAAwB;IACxB,eAAoC;IACpC,oBAAuB;IACvB,uCAAuC;IACvC,aADW,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CACP;IAG9B,mCAAmC;IACnC,aADc,MAAM,CACc;IAElC,2EAA2E;IAC3E,eADc,OAAO,CACmB;IAExC,oFAAoF;IACpF,WADc,OAAO,CACe;IAEpC;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;;;;;OASG;IACH,4CALG;QAAqB,OAAO,EAApB,MAAM;QACoB,eAAe,EAAzC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACT,IAAI,EAAd,GAAG;KACX,GAAU,OAAO,CAiBnB;IAED;;;;OAIG;IACH,qBAHW,sBAAsB,GACpB,MAAM,IAAI,CAKtB;IAED;;;;OAIG;IACH,2BAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAIhB;IAED,8DAA8D;IAC9D,SADc,OAAO,CAAC,IAAI,CAAC,CAK1B;CACF;qCAhHY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI"}
+{"version":3,"file":"in-process-client.d.ts","sourceRoot":"","sources":["../../../src/beacon/in-process-client.js"],"names":[],"mappings":";AAOA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH;IACE;;;;;OAKG;IACH,mCAHG;QAAsB,QAAQ;QACR,MAAM;KAC9B,EAUA;IAPC,6BAAwB;IACxB,eAAoC;IACpC,oBAAuB;IACvB;;yCAEqC;IACrC,aADS,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CACL;IAG9B;;;OAGG;IACH,aAFa,MAAM,CAEe;IAElC;;;OAGG;IACH,eAFa,OAAO,CAEoB;IAExC;;;OAGG;IACH,WAFa,OAAO,CAEgB;IAEpC;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;;;;;OASG;IACH,4CALG;QAAqB,OAAO,EAApB,MAAM;QACkB,eAAe,EAAvC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;QACT,IAAI,EAAZ,OAAC;KACT,GAAU,OAAO,CAmBnB;IAED;;;;OAIG;IACH,qBAHW,sBAAsB,GACpB,MAAM,IAAI,CAKtB;IAED;;;;OAIG;IACH,2BAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAIhB;IAED;;;OAGG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;CACF;;;;qCAjIY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI"}

package/build/src/beacon/in-process-client.js

@@ -3,6 +3,7 @@ import { randomUUID } from "node:crypto";
 import EventEmitter from "../utils/event-emitter.js";
 import { publishToInProcessPeers, registerInProcessPeer } from "./in-process-broker.js";
 /**
+ * BeaconBroadcastHandler type.
  * @typedef {function(import("./types.js").BeaconBroadcastMessage): void} BeaconBroadcastHandler
  */
 /**
@@ -20,6 +21,7 @@ import { publishToInProcessPeers, registerInProcessPeer } from "./in-process-bro
  */
 export default class InProcessBeaconClient extends EventEmitter {
     /**
+     * Runs constructor.
      * @param {object} [args] - Options.
      * @param {string} [args.peerType] - Optional human-readable peer label.
      * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).
@@ -29,14 +31,25 @@ export default class InProcessBeaconClient extends EventEmitter {
         this.peerType = peerType;
         this.peerId = peerId || randomUUID();
         this._connected = false;
-        /** @type {(() => void) | undefined} */
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {(() => void) | undefined} */
         this._unregister = undefined;
     }
-    /** @returns {string} - Peer id. */
+    /**
+     * Runs get peer id.
+     * @returns {string} - Peer id.
+     */
     getPeerId() { return this.peerId; }
-    /** @returns {boolean} - Whether the peer is registered with the broker. */
+    /**
+     * Runs is connected.
+     * @returns {boolean} - Whether the peer is registered with the broker.
+     */
     isConnected() { return this._connected; }
-    /** @returns {boolean} - Whether the peer is ready to publish through the broker. */
+    /**
+     * Runs is ready.
+     * @returns {boolean} - Whether the peer is ready to publish through the broker.
+     */
     isReady() { return this._connected; }
     /**
      * Registers with the in-process broker. Idempotent.
@@ -63,14 +76,16 @@ export default class InProcessBeaconClient extends EventEmitter {
      * `BeaconClient` semantics.
      * @param {object} args - Broadcast args.
      * @param {string} args.channel - Channel name.
-     * @param {Record<string, any>} args.broadcastParams - Routing params.
-     * @param {any} args.body - Message body.
+     * @param {Record<string, ?>} args.broadcastParams - Routing params.
+     * @param {?} args.body - Message body.
      * @returns {boolean} - True when the broadcast was queued.
      */
     publish({ channel, broadcastParams, body }) {
         if (!this._connected)
             return false;
-        /** @type {import("./types.js").BeaconBroadcastMessage} */
+        /**
+         * Message.
+          @type {import("./types.js").BeaconBroadcastMessage} */
         const message = {
             type: "broadcast",
             channel,
@@ -98,7 +113,10 @@ export default class InProcessBeaconClient extends EventEmitter {
     _receiveBroadcast(message) {
         this.emit("broadcast", message);
     }
-    /** @returns {Promise<void>} - Unregisters from the broker. */
+    /**
+     * Runs close.
+     * @returns {Promise<void>} - Unregisters from the broker.
+     */
     async close() {
         if (this._unregister)
             this._unregister();
@@ -106,4 +124,4 @@ export default class InProcessBeaconClient extends EventEmitter {
         this._connected = false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW4tcHJvY2Vzcy1jbGllbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmVhY29uL2luLXByb2Nlc3MtY2xpZW50LmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sYUFBYSxDQUFBO0FBRXRDLE9BQU8sWUFBWSxNQUFNLDJCQUEyQixDQUFBO0FBQ3BELE9BQU8sRUFBQyx1QkFBdUIsRUFBRSxxQkFBcUIsRUFBQyxNQUFNLHdCQUF3QixDQUFBO0FBRXJGOztHQUVHO0FBRUg7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsTUFBTSxDQUFDLE9BQU8sT0FBTyxxQkFBc0IsU0FBUSxZQUFZO0lBQzdEOzs7O09BSUc7SUFDSCxZQUFZLEVBQUMsUUFBUSxFQUFFLE1BQU0sRUFBQyxHQUFHLEVBQUU7UUFDakMsS0FBSyxFQUFFLENBQUE7UUFDUCxJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQTtRQUN4QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sSUFBSSxVQUFVLEVBQUUsQ0FBQTtRQUNwQyxJQUFJLENBQUMsVUFBVSxHQUFHLEtBQUssQ0FBQTtRQUN2Qix1Q0FBdUM7UUFDdkMsSUFBSSxDQUFDLFdBQVcsR0FBRyxTQUFTLENBQUE7SUFDOUIsQ0FBQztJQUVELG1DQUFtQztJQUNuQyxTQUFTLEtBQUssT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFBLENBQUMsQ0FBQztJQUVsQywyRUFBMkU7SUFDM0UsV0FBVyxLQUFLLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQSxDQUFDLENBQUM7SUFFeEMsb0ZBQW9GO0lBQ3BGLE9BQU8sS0FBSyxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUEsQ0FBQyxDQUFDO0lBRXBDOzs7T0FHRztJQUNILEtBQUssQ0FBQyxPQUFPO1FBQ1gsSUFBSSxJQUFJLENBQUMsVUFBVTtZQUFFLE9BQU07UUFFM0IsSUFBSSxDQUFDLFdBQVcsR0FBRyxxQkFBcUIsQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUM5QyxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQTtRQUN0QixJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFBO0lBQ3RCLENBQUM7SUFFRDs7O09BR0c7SUFDSCxLQUFLLENBQUMsWUFBWTtRQUNoQixJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVU7WUFBRSxNQUFNLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQTtJQUM1QyxDQUFDO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0gsT0FBTyxDQUFDLEVBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUM7UUFDdEMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVO1lBQUUsT0FBTyxLQUFLLENBQUE7UUFFbEMsMERBQTBEO1FBQzFELE1BQU0sT0FBTyxHQUFHO1lBQ2QsSUFBSSxFQUFFLFdBQVc7WUFDakIsT0FBTztZQUNQLGVBQWU7WUFDZixJQUFJO1lBQ0osWUFBWSxFQUFFLElBQUksQ0FBQyxNQUFNO1NBQzFCLENBQUE7UUFFRCx1QkFBdUIsQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUVoQyxPQUFPLElBQUksQ0FBQTtJQUNiLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsV0FBVyxDQUFDLE9BQU87UUFDakIsSUFBSSxDQUFDLEVBQUUsQ0FBQyxXQUFXLEVBQUUsT0FBTyxDQUFDLENBQUE7UUFDN0IsT0FBTyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLFdBQVcsRUFBRSxPQUFPLENBQUMsQ0FBQTtJQUM3QyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILGlCQUFpQixDQUFDLE9BQU87UUFDdkIsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsT0FBTyxDQUFDLENBQUE7SUFDakMsQ0FBQztJQUVELDhEQUE4RDtJQUM5RCxLQUFLLENBQUMsS0FBSztRQUNULElBQUksSUFBSSxDQUFDLFdBQVc7WUFBRSxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUE7UUFDeEMsSUFBSSxDQUFDLFdBQVcsR0FBRyxTQUFTLENBQUE7UUFDNUIsSUFBSSxDQUFDLFVBQVUsR0FBRyxLQUFLLENBQUE7SUFDekIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmltcG9ydCB7cmFuZG9tVVVJRH0gZnJvbSBcIm5vZGU6Y3J5cHRvXCJcblxuaW1wb3J0IEV2ZW50RW1pdHRlciBmcm9tIFwiLi4vdXRpbHMvZXZlbnQtZW1pdHRlci5qc1wiXG5pbXBvcnQge3B1Ymxpc2hUb0luUHJvY2Vzc1BlZXJzLCByZWdpc3RlckluUHJvY2Vzc1BlZXJ9IGZyb20gXCIuL2luLXByb2Nlc3MtYnJva2VyLmpzXCJcblxuLyoqXG4gKiBAdHlwZWRlZiB7ZnVuY3Rpb24oaW1wb3J0KFwiLi90eXBlcy5qc1wiKS5CZWFjb25Ccm9hZGNhc3RNZXNzYWdlKTogdm9pZH0gQmVhY29uQnJvYWRjYXN0SGFuZGxlclxuICovXG5cbi8qKlxuICogSW4tcHJvY2VzcyBjb3VudGVycGFydCB0byBgQmVhY29uQ2xpZW50YC4gUmVnaXN0ZXJzIHdpdGggdGhlXG4gKiBtb2R1bGUtbGV2ZWwgYGluLXByb2Nlc3MtYnJva2VyYCBzaW5nbGV0b24gc28gcGVlcnMgaW4gdGhlIHNhbWVcbiAqIHByb2Nlc3MgZXhjaGFuZ2UgYnJvYWRjYXN0cyB3aXRob3V0IGV2ZXIgdG91Y2hpbmcgVENQLiBJbXBsZW1lbnRzIHRoZVxuICogc2FtZSBleHRlcm5hbCBzdXJmYWNlIGFzIGBCZWFjb25DbGllbnRgIChgY29ubmVjdGAsIGBwdWJsaXNoYCxcbiAqIGBvbkJyb2FkY2FzdGAsIGBpc0Nvbm5lY3RlZGAsIGBnZXRQZWVySWRgLCBgY2xvc2VgKSBzb1xuICogYENvbmZpZ3VyYXRpb25gIGNhbiB1c2UgZWl0aGVyIGNsaWVudCBpbnRlcmNoYW5nZWFibHkuXG4gKlxuICogTGlmZWN5Y2xlIGRpZmZlcnMgZnJvbSBgQmVhY29uQ2xpZW50YCBpbiB0d28gaW50ZW50aW9uYWwgd2F5czpcbiAqICAgLSBgY29ubmVjdCgpYCBhbmQgYHdhaXRGb3JSZWFkeSgpYCByZXNvbHZlIGltbWVkaWF0ZWx5OyB0aGVyZSBpcyBubyBicm9rZXIgdG8gd2FpdCBmb3IuXG4gKiAgIC0gVGhlcmUgaXMgbm8gcmVjb25uZWN0IGxvb3AgYW5kIG5vIGBjb25uZWN0LWVycm9yYCAvIGBkaXNjb25uZWN0YFxuICogICAgIGV2ZW50IHN1cmZhY2UsIGJlY2F1c2Ugbm90aGluZyBjYW4gZmFpbC5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgSW5Qcm9jZXNzQmVhY29uQ2xpZW50IGV4dGVuZHMgRXZlbnRFbWl0dGVyIHtcbiAgLyoqXG4gICAqIEBwYXJhbSB7b2JqZWN0fSBbYXJnc10gLSBPcHRpb25zLlxuICAgKiBAcGFyYW0ge3N0cmluZ30gW2FyZ3MucGVlclR5cGVdIC0gT3B0aW9uYWwgaHVtYW4tcmVhZGFibGUgcGVlciBsYWJlbC5cbiAgICogQHBhcmFtIHtzdHJpbmd9IFthcmdzLnBlZXJJZF0gLSBPcHRpb25hbCBleHBsaWNpdCBwZWVyIGlkIChkZWZhdWx0cyB0byBhIHJhbmRvbSBVVUlEKS5cbiAgICovXG4gIGNvbnN0cnVjdG9yKHtwZWVyVHlwZSwgcGVlcklkfSA9IHt9KSB7XG4gICAgc3VwZXIoKVxuICAgIHRoaXMucGVlclR5cGUgPSBwZWVyVHlwZVxuICAgIHRoaXMucGVlcklkID0gcGVlcklkIHx8IHJhbmRvbVVVSUQoKVxuICAgIHRoaXMuX2Nvbm5lY3RlZCA9IGZhbHNlXG4gICAgLyoqIEB0eXBlIHsoKCkgPT4gdm9pZCkgfCB1bmRlZmluZWR9ICovXG4gICAgdGhpcy5fdW5yZWdpc3RlciA9IHVuZGVmaW5lZFxuICB9XG5cbiAgLyoqIEByZXR1cm5zIHtzdHJpbmd9IC0gUGVlciBpZC4gKi9cbiAgZ2V0UGVlcklkKCkgeyByZXR1cm4gdGhpcy5wZWVySWQgfVxuXG4gIC8qKiBAcmV0dXJucyB7Ym9vbGVhbn0gLSBXaGV0aGVyIHRoZSBwZWVyIGlzIHJlZ2lzdGVyZWQgd2l0aCB0aGUgYnJva2VyLiAqL1xuICBpc0Nvbm5lY3RlZCgpIHsgcmV0dXJuIHRoaXMuX2Nvbm5lY3RlZCB9XG5cbiAgLyoqIEByZXR1cm5zIHtib29sZWFufSAtIFdoZXRoZXIgdGhlIHBlZXIgaXMgcmVhZHkgdG8gcHVibGlzaCB0aHJvdWdoIHRoZSBicm9rZXIuICovXG4gIGlzUmVhZHkoKSB7IHJldHVybiB0aGlzLl9jb25uZWN0ZWQgfVxuXG4gIC8qKlxuICAgKiBSZWdpc3RlcnMgd2l0aCB0aGUgaW4tcHJvY2VzcyBicm9rZXIuIElkZW1wb3RlbnQuXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fVxuICAgKi9cbiAgYXN5bmMgY29ubmVjdCgpIHtcbiAgICBpZiAodGhpcy5fY29ubmVjdGVkKSByZXR1cm5cblxuICAgIHRoaXMuX3VucmVnaXN0ZXIgPSByZWdpc3RlckluUHJvY2Vzc1BlZXIodGhpcylcbiAgICB0aGlzLl9jb25uZWN0ZWQgPSB0cnVlXG4gICAgdGhpcy5lbWl0KFwiY29ubmVjdFwiKVxuICB9XG5cbiAgLyoqXG4gICAqIEluLXByb2Nlc3MgcGVlcnMgYXJlIHJlYWR5IGFzIHNvb24gYXMgdGhleSBhcmUgY29ubmVjdGVkLlxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn1cbiAgICovXG4gIGFzeW5jIHdhaXRGb3JSZWFkeSgpIHtcbiAgICBpZiAoIXRoaXMuX2Nvbm5lY3RlZCkgYXdhaXQgdGhpcy5jb25uZWN0KClcbiAgfVxuXG4gIC8qKlxuICAgKiBQdWJsaXNoZXMgYSBicm9hZGNhc3QgdG8gZXZlcnkgcmVnaXN0ZXJlZCBwZWVyIChpbmNsdWRpbmcgdGhpc1xuICAgKiBvbmUpLiBSZXR1cm5zIGZhbHNlIGlmIGBjb25uZWN0KClgIGhhc24ndCBiZWVuIGNhbGxlZCB5ZXQsIG1hdGNoaW5nXG4gICAqIGBCZWFjb25DbGllbnRgIHNlbWFudGljcy5cbiAgICogQHBhcmFtIHtvYmplY3R9IGFyZ3MgLSBCcm9hZGNhc3QgYXJncy5cbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MuY2hhbm5lbCAtIENoYW5uZWwgbmFtZS5cbiAgICogQHBhcmFtIHtSZWNvcmQ8c3RyaW5nLCBhbnk+fSBhcmdzLmJyb2FkY2FzdFBhcmFtcyAtIFJvdXRpbmcgcGFyYW1zLlxuICAgKiBAcGFyYW0ge2FueX0gYXJncy5ib2R5IC0gTWVzc2FnZSBib2R5LlxuICAgKiBAcmV0dXJucyB7Ym9vbGVhbn0gLSBUcnVlIHdoZW4gdGhlIGJyb2FkY2FzdCB3YXMgcXVldWVkLlxuICAgKi9cbiAgcHVibGlzaCh7Y2hhbm5lbCwgYnJvYWRjYXN0UGFyYW1zLCBib2R5fSkge1xuICAgIGlmICghdGhpcy5fY29ubmVjdGVkKSByZXR1cm4gZmFsc2VcblxuICAgIC8qKiBAdHlwZSB7aW1wb3J0KFwiLi90eXBlcy5qc1wiKS5CZWFjb25Ccm9hZGNhc3RNZXNzYWdlfSAqL1xuICAgIGNvbnN0IG1lc3NhZ2UgPSB7XG4gICAgICB0eXBlOiBcImJyb2FkY2FzdFwiLFxuICAgICAgY2hhbm5lbCxcbiAgICAgIGJyb2FkY2FzdFBhcmFtcyxcbiAgICAgIGJvZHksXG4gICAgICBvcmlnaW5QZWVySWQ6IHRoaXMucGVlcklkXG4gICAgfVxuXG4gICAgcHVibGlzaFRvSW5Qcm9jZXNzUGVlcnMobWVzc2FnZSlcblxuICAgIHJldHVybiB0cnVlXG4gIH1cblxuICAvKipcbiAgICogUmVnaXN0ZXJzIGEgaGFuZGxlciBjYWxsZWQgb25jZSBmb3IgZXZlcnkgYnJvYWRjYXN0IHJlY2VpdmVkLlxuICAgKiBAcGFyYW0ge0JlYWNvbkJyb2FkY2FzdEhhbmRsZXJ9IGhhbmRsZXIgLSBIYW5kbGVyLlxuICAgKiBAcmV0dXJucyB7KCkgPT4gdm9pZH0gLSBVbnJlZ2lzdGVyIGZ1bmN0aW9uLlxuICAgKi9cbiAgb25Ccm9hZGNhc3QoaGFuZGxlcikge1xuICAgIHRoaXMub24oXCJicm9hZGNhc3RcIiwgaGFuZGxlcilcbiAgICByZXR1cm4gKCkgPT4gdGhpcy5vZmYoXCJicm9hZGNhc3RcIiwgaGFuZGxlcilcbiAgfVxuXG4gIC8qKlxuICAgKiBSZWNlaXZlcyBhIGJyb2FkY2FzdCBmcm9tIHRoZSBicm9rZXIuIENhbGxlZCBieSBgaW4tcHJvY2Vzcy1icm9rZXJgLlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4vdHlwZXMuanNcIikuQmVhY29uQnJvYWRjYXN0TWVzc2FnZX0gbWVzc2FnZSAtIEJyb2FkY2FzdCBtZXNzYWdlLlxuICAgKiBAcmV0dXJucyB7dm9pZH1cbiAgICovXG4gIF9yZWNlaXZlQnJvYWRjYXN0KG1lc3NhZ2UpIHtcbiAgICB0aGlzLmVtaXQoXCJicm9hZGNhc3RcIiwgbWVzc2FnZSlcbiAgfVxuXG4gIC8qKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn0gLSBVbnJlZ2lzdGVycyBmcm9tIHRoZSBicm9rZXIuICovXG4gIGFzeW5jIGNsb3NlKCkge1xuICAgIGlmICh0aGlzLl91bnJlZ2lzdGVyKSB0aGlzLl91bnJlZ2lzdGVyKClcbiAgICB0aGlzLl91bnJlZ2lzdGVyID0gdW5kZWZpbmVkXG4gICAgdGhpcy5fY29ubmVjdGVkID0gZmFsc2VcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"in-process-client.js","sourceRoot":"","sources":["../../../src/beacon/in-process-client.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AAEtC,OAAO,YAAY,MAAM,2BAA2B,CAAA;AACpD,OAAO,EAAC,uBAAuB,EAAE,qBAAqB,EAAC,MAAM,wBAAwB,CAAA;AAErF;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,YAAY;IAC7D;;;;;OAKG;IACH,YAAY,EAAC,QAAQ,EAAE,MAAM,EAAC,GAAG,EAAE;QACjC,KAAK,EAAE,CAAA;QACP,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,UAAU,EAAE,CAAA;QACpC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;QACvB;;6CAEqC;QACrC,IAAI,CAAC,WAAW,GAAG,SAAS,CAAA;IAC9B,CAAC;IAED;;;OAGG;IACH,SAAS,KAAK,OAAO,IAAI,CAAC,MAAM,CAAA,CAAC,CAAC;IAElC;;;OAGG;IACH,WAAW,KAAK,OAAO,IAAI,CAAC,UAAU,CAAA,CAAC,CAAC;IAExC;;;OAGG;IACH,OAAO,KAAK,OAAO,IAAI,CAAC,UAAU,CAAA,CAAC,CAAC;IAEpC;;;OAGG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,IAAI,CAAC,UAAU;YAAE,OAAM;QAE3B,IAAI,CAAC,WAAW,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAA;QAC9C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;QACtB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IACtB,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,YAAY;QAChB,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,CAAC,OAAO,EAAE,CAAA;IAC5C,CAAC;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAC;QACtC,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,OAAO,KAAK,CAAA;QAElC;;gEAEwD;QACxD,MAAM,OAAO,GAAG;YACd,IAAI,EAAE,WAAW;YACjB,OAAO;YACP,eAAe;YACf,IAAI;YACJ,YAAY,EAAE,IAAI,CAAC,MAAM;SAC1B,CAAA;QAED,uBAAuB,CAAC,OAAO,CAAC,CAAA;QAEhC,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,OAAO;QACjB,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;QAC7B,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;IAC7C,CAAC;IAED;;;;OAIG;IACH,iBAAiB,CAAC,OAAO;QACvB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;IACjC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,WAAW;YAAE,IAAI,CAAC,WAAW,EAAE,CAAA;QACxC,IAAI,CAAC,WAAW,GAAG,SAAS,CAAA;QAC5B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;IACzB,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport {randomUUID} from \"node:crypto\"\n\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport {publishToInProcessPeers, registerInProcessPeer} from \"./in-process-broker.js\"\n\n/**\n * BeaconBroadcastHandler type.\n * @typedef {function(import(\"./types.js\").BeaconBroadcastMessage): void} BeaconBroadcastHandler\n */\n\n/**\n * In-process counterpart to `BeaconClient`. Registers with the\n * module-level `in-process-broker` singleton so peers in the same\n * process exchange broadcasts without ever touching TCP. Implements the\n * same external surface as `BeaconClient` (`connect`, `publish`,\n * `onBroadcast`, `isConnected`, `getPeerId`, `close`) so\n * `Configuration` can use either client interchangeably.\n *\n * Lifecycle differs from `BeaconClient` in two intentional ways:\n *   - `connect()` and `waitForReady()` resolve immediately; there is no broker to wait for.\n *   - There is no reconnect loop and no `connect-error` / `disconnect`\n *     event surface, because nothing can fail.\n */\nexport default class InProcessBeaconClient extends EventEmitter {\n  /**\n   * Runs constructor.\n   * @param {object} [args] - Options.\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   */\n  constructor({peerType, peerId} = {}) {\n    super()\n    this.peerType = peerType\n    this.peerId = peerId || randomUUID()\n    this._connected = false\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {(() => void) | undefined} */\n    this._unregister = undefined\n  }\n\n  /**\n   * Runs get peer id.\n   * @returns {string} - Peer id.\n   */\n  getPeerId() { return this.peerId }\n\n  /**\n   * Runs is connected.\n   * @returns {boolean} - Whether the peer is registered with the broker.\n   */\n  isConnected() { return this._connected }\n\n  /**\n   * Runs is ready.\n   * @returns {boolean} - Whether the peer is ready to publish through the broker.\n   */\n  isReady() { return this._connected }\n\n  /**\n   * Registers with the in-process broker. Idempotent.\n   * @returns {Promise<void>}\n   */\n  async connect() {\n    if (this._connected) return\n\n    this._unregister = registerInProcessPeer(this)\n    this._connected = true\n    this.emit(\"connect\")\n  }\n\n  /**\n   * In-process peers are ready as soon as they are connected.\n   * @returns {Promise<void>}\n   */\n  async waitForReady() {\n    if (!this._connected) await this.connect()\n  }\n\n  /**\n   * Publishes a broadcast to every registered peer (including this\n   * one). Returns false if `connect()` hasn't been called yet, matching\n   * `BeaconClient` semantics.\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 when the broadcast was queued.\n   */\n  publish({channel, broadcastParams, body}) {\n    if (!this._connected) 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    publishToInProcessPeers(message)\n\n    return true\n  }\n\n  /**\n   * Registers a handler called once for every broadcast received.\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   * Receives a broadcast from the broker. Called by `in-process-broker`.\n   * @param {import(\"./types.js\").BeaconBroadcastMessage} message - Broadcast message.\n   * @returns {void}\n   */\n  _receiveBroadcast(message) {\n    this.emit(\"broadcast\", message)\n  }\n\n  /**\n   * Runs close.\n   * @returns {Promise<void>} - Unregisters from the broker.\n   */\n  async close() {\n    if (this._unregister) this._unregister()\n    this._unregister = undefined\n    this._connected = false\n  }\n}\n"]}

package/build/src/beacon/server.d.ts

@@ -10,6 +10,7 @@
  */
 export default class BeaconServer {
     /**
+     * Runs constructor.
      * @param {object} args - Options.
      * @param {import("../configuration.js").default} args.configuration - Configuration.
      * @param {string} [args.host] - Hostname to bind. Defaults to the configured beacon host.
@@ -24,32 +25,42 @@ export default class BeaconServer {
     host: string;
     port: number;
     logger: Logger;
-    /** @type {Set<JsonSocket>} */
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {Set<JsonSocket>} */
     peers: Set<JsonSocket>;
-    /** @type {net.Server | undefined} */
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {net.Server | undefined} */
     server: net.Server | undefined;
     /**
+     * Runs start.
      * @returns {Promise<void>} - Resolves when listening.
      */
     start(): Promise<void>;
     /**
+     * Runs stop.
      * @returns {Promise<void>} - Resolves when closed.
      */
     stop(): Promise<void>;
     /**
+     * Runs get port.
      * @returns {number} - Bound port.
      */
     getPort(): number;
     /**
+     * Runs get peer count.
      * @returns {number} - Number of connected peers.
      */
     getPeerCount(): number;
     /**
+     * Runs handle connection.
      * @param {import("net").Socket} socket - Socket.
      * @returns {void}
      */
     _handleConnection(socket: import("net").Socket): void;
     /**
+     * Runs fan out.
      * @param {import("./types.js").BeaconBroadcastMessage} message - Broadcast message.
      * @returns {void}
      */

package/build/src/beacon/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/beacon/server.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH;IACE;;;;;OAKG;IACH,2CAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI;QACJ,IAAI;KAC5B,EAWA;IATC,qDAAkC;IAElC,aAA+B;IAC/B,aAAyD;IACzD,eAA8B;IAC9B,8BAA8B;IAC9B,OADW,GAAG,CAAC,UAAU,CAAC,CACJ;IACtB,qCAAqC;IACrC,QADW,GAAG,CAAC,MAAM,GAAG,SAAS,CACV;IAGzB;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;OAEG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;OAEG;IACH,WAFa,MAAM,CAIlB;IAED;;OAEG;IACH,gBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,0BAHW,OAAO,KAAK,EAAE,MAAM,GAClB,IAAI,CA8BhB;IAED;;;OAGG;IACH,iBAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAUhB;CACF;mBA9HkB,cAAc;uBADV,mCAAmC;gBAF1C,KAAK"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/beacon/server.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH;IACE;;;;;;OAMG;IACH,2CAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI;QACJ,IAAI;KAC5B,EAeA;IAbC,qDAAkC;IAElC,aAA+B;IAC/B,aAAyD;IACzD,eAA8B;IAC9B;;gCAE4B;IAC5B,OADS,GAAG,CAAC,UAAU,CAAC,CACF;IACtB;;uCAEmC;IACnC,QADS,GAAG,CAAC,MAAM,GAAG,SAAS,CACR;IAGzB;;;OAGG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;OAGG;IACH,WAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,0BAHW,OAAO,KAAK,EAAE,MAAM,GAClB,IAAI,CAmChB;IAED;;;;OAIG;IACH,iBAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAUhB;CACF;mBA9IkB,cAAc;uBADV,mCAAmC;gBAF1C,KAAK"}