velocious 1.0.577 → 1.0.579

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

@@ -1,4 +1,7 @@
-declare const BeaconClient_base: typeof import("eventemitter3").EventEmitter;
+import net from "node:net";
+import JsonSocket from "../background-jobs/json-socket.js";
+import EventEmitter from "../utils/event-emitter.js";
+export type BeaconBroadcastHandler = (arg: import("./types.js").BeaconBroadcastMessage) => void;
 /**
  * BeaconClient connects to a `velocious beacon` daemon and exchanges
  * broadcasts with all peer processes connected to the same daemon.
@@ -17,27 +20,7 @@ declare const BeaconClient_base: typeof import("eventemitter3").EventEmitter;
  * caller can fall back to local-only delivery; subsequent reconnects do
  * not replay missed publishes (Beacon is pubsub, not a queue).
  */
-export default class BeaconClient extends BeaconClient_base {
-    /**
-     * 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.
-     * @param {number} [args.closeTimeoutMs] - Maximum graceful socket close wait in ms.
-     */
-    constructor({ host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs, closeTimeoutMs }: {
-        host: string;
-        port: number;
-        peerType?: string | undefined;
-        peerId?: string | undefined;
-        reconnectDelayMs?: number | undefined;
-        maxReconnectDelayMs?: number | undefined;
-        closeTimeoutMs?: number | undefined;
-    });
+export default class BeaconClient extends EventEmitter {
     host: string;
     port: number;
     peerType: string | undefined;
@@ -70,6 +53,26 @@ export default class BeaconClient extends BeaconClient_base {
      * @type {Error | undefined}
      */
     _lastSocketError: Error | undefined;
+    /**
+     * Runs constructor.
+     * @param {object} args - Options.
+     * @param {string} args.host - Beacon host.
+     * @param {number} args.port - Beacon port.
+     * @param {string} [args.peerType] - Optional human-readable peer label.
+     * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).
+     * @param {number} [args.reconnectDelayMs] - Starting reconnect delay in ms.
+     * @param {number} [args.maxReconnectDelayMs] - Maximum reconnect delay in ms.
+     * @param {number} [args.closeTimeoutMs] - Maximum graceful socket close wait in ms.
+     */
+    constructor({ host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs, closeTimeoutMs }: {
+        host: string;
+        port: number;
+        peerType?: string;
+        peerId?: string;
+        reconnectDelayMs?: number;
+        maxReconnectDelayMs?: number;
+        closeTimeoutMs?: number;
+    });
     /**
      * Runs get peer id.
      * @returns {string} - The peer id sent on the hello handshake.
@@ -105,21 +108,21 @@ export default class BeaconClient extends BeaconClient_base {
      * @returns {Promise<void>}
      */
     waitForReady({ timeoutMs }?: {
-        timeoutMs?: number | undefined;
+        timeoutMs?: number;
     }): Promise<void>;
     /**
      * 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.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.broadcastParams - Routing params.
+     * @param {ReturnType<typeof JSON.parse>} 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 }: {
         channel: string;
-        broadcastParams: Record<string, unknown>;
-        body: unknown;
+        broadcastParams: Record<string, ReturnType<typeof JSON.parse>>;
+        body: ReturnType<typeof JSON.parse>;
     }): boolean;
     /**
      * Registers a handler called once for every `broadcast` message
@@ -145,11 +148,4 @@ export default class BeaconClient extends BeaconClient_base {
      */
     _scheduleReconnect(): void;
 }
-/**
- * BeaconBroadcastHandler type.
- */
-export type BeaconBroadcastHandler = (arg0: import("./types.js").BeaconBroadcastMessage) => void;
-import JsonSocket from "../background-jobs/json-socket.js";
-import net from "node:net";
-export {};
 //# sourceMappingURL=client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":";AAiBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;;;;;;;;OAUG;IACH,qGARG;QAAqB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;QACQ,QAAQ;QACR,MAAM;QACN,gBAAgB;QAChB,mBAAmB;QACnB,cAAc;KACtC,EAmCA;IAhCC,aAAgB;IAChB,aAAgB;IAChB,6BAAwB;IACxB,eAAoC;IACpC,iCAA8E;IAC9E,6BAAyE;IACzE,0BAAsD;IACtD,wBAAiE;IACjE;;wCAEoC;IACpC,aADU,UAAU,GAAG,SAAS,CACJ;IAC5B;;wCAEoC;IACpC,SADU,GAAG,CAAC,MAAM,GAAG,SAAS,CACR;IACxB,oBAAuB;IACvB,gBAAmB;IACnB,iBAAoB;IACpB;;2DAEuD;IACvD,iBADU,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,SAAS,CACnB;IAChC;;2CAEuC;IACvC,iBADU,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CACH;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,CAyBzB;IAED;;;;;;;;OAQG;IACH,6BAHG;QAAsB,SAAS;KAC/B,GAAU,OAAO,CAAC,IAAI,CAAC,CA+BzB;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,CA4BzB;IAED;;;OAGG;IACH,eAFa,IAAI,CAuEhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAYhB;CACF;;;;qCAzUY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI;uBALjD,mCAAmC;gBAH1C,UAAU"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":"AAGA,OAAO,GAAG,MAAM,UAAU,CAAA;AAG1B,OAAO,UAAU,MAAM,mCAAmC,CAAA;AAC1D,OAAO,YAAY,MAAM,2BAA2B,CAAA;AAIjD,YAAsE,sBAAsB,GAAlF,CAAC,GAAG,EAAE,OAAO,YAAY,EAAE,sBAAsB,KAAK,IAAI,CAAwB;AAM/F;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,YAAY;IAc7C,IAAI;IACJ,IAAI;IACJ,QAAQ;IACR,MAAM;IACN,wBAAwB;IACxB,oBAAoB;IACpB,iBAAiB;IACjB,eAAe;IACpB;;wCAEoC;IAC/B,WAAW,EADN,UAAU,GAAG,SAAS;IAEhC;;wCAEoC;IAC/B,OAAO,EADF,GAAG,CAAC,MAAM,GAAG,SAAS;IAE3B,UAAU;IACV,MAAM;IACN,OAAO;IACZ;;2DAEuD;IAClD,eAAe,EADV,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,SAAS;IAEnD;;2CAEuC;IAClC,eAAe,EADV,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;IAEnC;;;OAGG;IACE,gBAAgB,EAFX,KAAK,GAAG,SAAS;IA1C7B;;;;;;;;;;OAUG;IACH,YAAY,EAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,cAAc,EAAC,EAR9F;QAAqB,IAAI,EAAjB,MAAM,CACd;QAAqB,IAAI,EAAjB,MAAM,CACd;QAAsB,QAAQ,AAA9B,CACA,EADQ,MAAM,CACd;QAAsB,MAAM,AAA5B,CACA,EADQ,MAAM,CACd;QAAsB,gBAAgB,AAAtC,CACA,EADQ,MAAM,CACd;QAAsB,mBAAmB,AAAzC,CACA,EADQ,MAAM,CACd;QAAsB,cAAc,AAApC,CACF,EADU,MAAM,CAChB;KACgG,EAkChG;IAED;;;OAGG;IACH,SAAS,IAFI,MAAM,CAEe;IAElC;;;OAGG;IACH,WAAW,IAFE,OAAO,CAEoB;IAExC;;;OAGG;IACH,OAAO,IAFM,OAAO,CAEY;IAEhC;;;;;;;;OAQG;IACG,OAAO,IAFA,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;OAQG;IACG,YAAY,CAAC,EAAC,SAAS,EAAC,AAJ3B,CAEA,EADA;QAAsB,SAAS,AAA/B,CACA,EADQ,MAAM,CACd;KAEgC,GAFtB,OAAO,CAAC,IAAI,CAAC,CA+BzB;IAED;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAC,EALrC;QAAqB,OAAO,EAApB,MAAM,CACd;QAA4D,eAAe,EAAnE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CACrD;QAA4C,IAAI,EAAxC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACrC;KAEqC,GAF3B,OAAO,CAsBnB;IAED;;;;;;OAMG;IACH,WAAW,CAAC,OAAO,EAHR,sBAGQ,GAFN,MAAM,IAAI,CAKtB;IAED;;;OAGG;IACG,KAAK,IAFE,OAAO,CAAC,IAAI,CAAC,CA4BzB;IAED;;;OAGG;IACH,WAAW,IAFE,IAAI,CAuEhB;IAED;;;OAGG;IACH,kBAAkB,IAFL,IAAI,CAYhB;CACF"}

package/build/src/beacon/client.js

@@ -6,7 +6,7 @@ import JsonSocket from "../background-jobs/json-socket.js";
 import EventEmitter from "../utils/event-emitter.js";
 /**
  * BeaconBroadcastHandler type.
- * @typedef {function(import("./types.js").BeaconBroadcastMessage): void} BeaconBroadcastHandler
+ * @typedef {(arg: import("./types.js").BeaconBroadcastMessage) => void} BeaconBroadcastHandler
  */
 const DEFAULT_RECONNECT_DELAY_MS = 1000;
 const MAX_RECONNECT_DELAY_MS = 30_000;
@@ -166,8 +166,8 @@ 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, ?>} args.broadcastParams - Routing params.
-     * @param {?} args.body - Message body.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.broadcastParams - Routing params.
+     * @param {ReturnType<typeof JSON.parse>} 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 }) {
@@ -309,4 +309,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\n/**\n * BeaconBroadcastHandler type.\n * @typedef {function(import(\"./types.js\").BeaconBroadcastMessage): void} BeaconBroadcastHandler\n */\nconst DEFAULT_RECONNECT_DELAY_MS = 1000\nconst MAX_RECONNECT_DELAY_MS = 30_000\nconst DEFAULT_CLOSE_TIMEOUT_MS = 1000\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   * @param {number} [args.closeTimeoutMs] - Maximum graceful socket close wait in ms.\n   */\n  constructor({host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs, closeTimeoutMs}) {\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    this._closeTimeoutMs = closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS\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 {ReturnType<typeof setTimeout> | 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 = (/** @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    /**\n     * Cleans up the ready listener and timeout.\n     * @type {() => void}\n     */\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    const socket = this._socket\n\n    if (!socket) return\n\n    this._socket = undefined\n    this._jsonSocket = undefined\n\n    if (socket.destroyed) return\n\n    await timeout({timeout: this._closeTimeoutMs}, async () => {\n      await new Promise((resolve) => {\n        socket.once(\"close\", () => resolve(undefined))\n        socket.end()\n        socket.destroySoon()\n      })\n    }).catch(() => {\n      socket.destroy()\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\", (/** @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"]}
+//# 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\n/**\n * BeaconBroadcastHandler type.\n * @typedef {(arg: import(\"./types.js\").BeaconBroadcastMessage) => void} BeaconBroadcastHandler\n */\nconst DEFAULT_RECONNECT_DELAY_MS = 1000\nconst MAX_RECONNECT_DELAY_MS = 30_000\nconst DEFAULT_CLOSE_TIMEOUT_MS = 1000\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   * @param {number} [args.closeTimeoutMs] - Maximum graceful socket close wait in ms.\n   */\n  constructor({host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs, closeTimeoutMs}) {\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    this._closeTimeoutMs = closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS\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 {ReturnType<typeof setTimeout> | 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 = (/** @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    /**\n     * Cleans up the ready listener and timeout.\n     * @type {() => void}\n     */\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, ReturnType<typeof JSON.parse>>} args.broadcastParams - Routing params.\n   * @param {ReturnType<typeof JSON.parse>} 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    const socket = this._socket\n\n    if (!socket) return\n\n    this._socket = undefined\n    this._jsonSocket = undefined\n\n    if (socket.destroyed) return\n\n    await timeout({timeout: this._closeTimeoutMs}, async () => {\n      await new Promise((resolve) => {\n        socket.once(\"close\", () => resolve(undefined))\n        socket.end()\n        socket.destroySoon()\n      })\n    }).catch(() => {\n      socket.destroy()\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\", (/** @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

@@ -1,9 +1,12 @@
+export type InProcessPeer = {
+    _receiveBroadcast: (message: import("./types.js").BeaconBroadcastMessage) => void;
+};
 /**
  * Registers a peer with the broker. Returns an unregister function.
  * @param {InProcessPeer} peer - Peer instance.
  * @returns {() => void} - Unregister function.
  */
-export function registerInProcessPeer(peer: InProcessPeer): () => void;
+export declare function registerInProcessPeer(peer: InProcessPeer): () => void;
 /**
  * Schedules a fan-out of the given message to every registered peer.
  * Each delivery is its own microtask so handlers run in the order peers
@@ -11,16 +14,10 @@ export function registerInProcessPeer(peer: InProcessPeer): () => void;
  * @param {import("./types.js").BeaconBroadcastMessage} message - Broadcast message.
  * @returns {void}
  */
-export function publishToInProcessPeers(message: import("./types.js").BeaconBroadcastMessage): void;
+export declare 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;
-};
+export declare function getInProcessPeerCount(): number;
 //# sourceMappingURL=in-process-broker.d.ts.map

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":"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;;;;4BAhDY;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":"AAsBG,YAA+F,aAAa,GAAlG;IAAC,iBAAiB,EAAE,CAAC,OAAO,EAAE,OAAO,YAAY,EAAE,sBAAsB,KAAK,IAAI,CAAA;CAAC,CAAe;AAO/G;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAH/B,aAG+B,GAF7B,MAAM,IAAI,CAQtB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAHpC,OAAO,YAAY,EAAE,sBAGe,GAFlC,IAAI,CAehB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAFxB,MAAM,CAIlB"}

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

@@ -1,7 +1,8 @@
-declare const InProcessBeaconClient_base: typeof import("eventemitter3").EventEmitter;
+import EventEmitter from "../utils/event-emitter.js";
+export type BeaconBroadcastHandler = (arg: import("./types.js").BeaconBroadcastMessage) => void;
 /**
  * BeaconBroadcastHandler type.
- * @typedef {function(import("./types.js").BeaconBroadcastMessage): void} BeaconBroadcastHandler
+ * @typedef {(arg: import("./types.js").BeaconBroadcastMessage) => void} BeaconBroadcastHandler
  */
 /**
  * In-process counterpart to `BeaconClient`. Registers with the
@@ -16,7 +17,14 @@ declare const InProcessBeaconClient_base: typeof import("eventemitter3").EventEm
  *   - There is no reconnect loop and no `connect-error` / `disconnect`
  *     event surface, because nothing can fail.
  */
-export default class InProcessBeaconClient extends InProcessBeaconClient_base {
+export default class InProcessBeaconClient extends EventEmitter {
+    peerType: string | undefined;
+    peerId: string;
+    _connected: boolean;
+    /**
+     * Narrows the runtime value to the documented type.
+     * @type {(() => void) | undefined} */
+    _unregister: (() => void) | undefined;
     /**
      * Runs constructor.
      * @param {object} [args] - Options.
@@ -24,16 +32,9 @@ export default class InProcessBeaconClient extends InProcessBeaconClient_base {
      * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).
      */
     constructor({ peerType, peerId }?: {
-        peerType?: string | undefined;
-        peerId?: string | undefined;
+        peerType?: string;
+        peerId?: string;
     });
-    peerType: string | undefined;
-    peerId: string;
-    _connected: boolean;
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {(() => void) | undefined} */
-    _unregister: (() => void) | undefined;
     /**
      * Runs get peer id.
      * @returns {string} - Peer id.
@@ -65,14 +66,14 @@ export default class InProcessBeaconClient extends InProcessBeaconClient_base {
      * `BeaconClient` semantics.
      * @param {object} args - Broadcast args.
      * @param {string} args.channel - Channel name.
-     * @param {Record<string, ?>} args.broadcastParams - Routing params.
-     * @param {?} args.body - Message body.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.broadcastParams - Routing params.
+     * @param {ReturnType<typeof JSON.parse>} args.body - Message body.
      * @returns {boolean} - True when the broadcast was queued.
      */
     publish({ channel, broadcastParams, body }: {
         channel: string;
-        broadcastParams: Record<string, unknown>;
-        body: unknown;
+        broadcastParams: Record<string, ReturnType<typeof JSON.parse>>;
+        body: ReturnType<typeof JSON.parse>;
     }): boolean;
     /**
      * Registers a handler called once for every broadcast received.
@@ -92,9 +93,4 @@ export default class InProcessBeaconClient extends InProcessBeaconClient_base {
      */
     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;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH;IACE;;;;;OAKG;IACH,mCAHG;QAAsB,QAAQ;QACR,MAAM;KAC9B,EAUA;IAPC,6BAAwB;IACxB,eAAoC;IACpC,oBAAuB;IACvB;;0CAEsC;IACtC,aADU,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CACN;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"}
+{"version":3,"file":"in-process-client.d.ts","sourceRoot":"","sources":["../../../src/beacon/in-process-client.js"],"names":[],"mappings":"AAIA,OAAO,YAAY,MAAM,2BAA2B,CAAA;AAKjD,YAAsE,sBAAsB,GAAlF,CAAC,GAAG,EAAE,OAAO,YAAY,EAAE,sBAAsB,KAAK,IAAI,CAAwB;AAF/F;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,YAAY;IAStD,QAAQ;IACR,MAAM;IACN,UAAU;IACf;;0CAEsC;IACjC,WAAW,EADN,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS;IAbpC;;;;;OAKG;IACH,YAAY,EAAC,QAAQ,EAAE,MAAM,EAAC,AAJ3B,CAGF,EAFE;QAAsB,QAAQ,AAA9B,CACA,EADQ,MAAM,CACd;QAAsB,MAAM,AAA5B,CACF,EADU,MAAM,CAChB;KACkC,EASlC;IAED;;;OAGG;IACH,SAAS,IAFI,MAAM,CAEe;IAElC;;;OAGG;IACH,WAAW,IAFE,OAAO,CAEoB;IAExC;;;OAGG;IACH,OAAO,IAFM,OAAO,CAEgB;IAEpC;;;OAGG;IACG,OAAO,IAFA,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;OAGG;IACG,YAAY,IAFL,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAC,EALrC;QAAqB,OAAO,EAApB,MAAM,CACd;QAA4D,eAAe,EAAnE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CACrD;QAA4C,IAAI,EAAxC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACrC;KAEqC,GAF3B,OAAO,CAmBnB;IAED;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAHR,sBAGQ,GAFN,MAAM,IAAI,CAKtB;IAED;;;;OAIG;IACH,iBAAiB,CAAC,OAAO,EAHd,OAAO,YAAY,EAAE,sBAGP,GAFZ,IAAI,CAIhB;IAED;;;OAGG;IACG,KAAK,IAFE,OAAO,CAAC,IAAI,CAAC,CAMzB;CACF"}

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

@@ -4,7 +4,7 @@ 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
+ * @typedef {(arg: import("./types.js").BeaconBroadcastMessage) => void} BeaconBroadcastHandler
  */
 /**
  * In-process counterpart to `BeaconClient`. Registers with the
@@ -76,8 +76,8 @@ export default class InProcessBeaconClient extends EventEmitter {
      * `BeaconClient` semantics.
      * @param {object} args - Broadcast args.
      * @param {string} args.channel - Channel name.
-     * @param {Record<string, ?>} args.broadcastParams - Routing params.
-     * @param {?} args.body - Message body.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.broadcastParams - Routing params.
+     * @param {ReturnType<typeof JSON.parse>} args.body - Message body.
      * @returns {boolean} - True when the broadcast was queued.
      */
     publish({ channel, broadcastParams, body }) {
@@ -124,4 +124,4 @@ export default class InProcessBeaconClient extends EventEmitter {
         this._connected = false;
     }
 }
-//# 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;;8CAEsC;QACtC,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;;iEAEyD;QACzD,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"]}
+//# 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;;8CAEsC;QACtC,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;;iEAEyD;QACzD,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 {(arg: 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, ReturnType<typeof JSON.parse>>} args.broadcastParams - Routing params.\n   * @param {ReturnType<typeof JSON.parse>} 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

@@ -1,3 +1,6 @@
+import net from "net";
+import JsonSocket from "../background-jobs/json-socket.js";
+import Logger from "../logger.js";
 /**
  * Beacon broker daemon.
  *
@@ -9,18 +12,6 @@
  * filtering.
  */
 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.
-     * @param {number} [args.port] - Port to bind. Defaults to the configured beacon port.
-     */
-    constructor({ configuration, host, port }: {
-        configuration: import("../configuration.js").default;
-        host?: string | undefined;
-        port?: number | undefined;
-    });
     configuration: import("../configuration.js").default;
     host: string;
     port: number;
@@ -38,6 +29,18 @@ export default class BeaconServer {
      * @type {Set<net.Socket>}
      */
     sockets: Set<net.Socket>;
+    /**
+     * 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.
+     * @param {number} [args.port] - Port to bind. Defaults to the configured beacon port.
+     */
+    constructor({ configuration, host, port }: {
+        configuration: import("../configuration.js").default;
+        host?: string;
+        port?: number;
+    });
     /**
      * Runs start.
      * @returns {Promise<void>} - Resolves when listening.
@@ -71,7 +74,4 @@ export default class BeaconServer {
      */
     _fanOut(message: import("./types.js").BeaconBroadcastMessage): void;
 }
-import Logger from "../logger.js";
-import JsonSocket from "../background-jobs/json-socket.js";
-import net from "net";
 //# sourceMappingURL=server.d.ts.map

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;;;;;;OAMG;IACH,2CAJG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI;QACJ,IAAI;KAC5B,EAoBA;IAlBC,qDAAkC;IAElC,aAA+B;IAC/B,aAAyD;IACzD,eAA8B;IAC9B;;iCAE6B;IAC7B,OADU,GAAG,CAAC,UAAU,CAAC,CACH;IACtB;;wCAEoC;IACpC,QADU,GAAG,CAAC,MAAM,GAAG,SAAS,CACT;IACvB;;;OAGG;IACH,SAFU,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAED;IAG1B;;;OAGG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,WAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,0BAHW,OAAO,KAAK,EAAE,MAAM,GAClB,IAAI,CAqChB;IAED;;;;OAIG;IACH,iBAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAUhB;CACF;mBAzJkB,cAAc;uBADV,mCAAmC;gBAF1C,KAAK"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/beacon/server.js"],"names":[],"mappings":"AAEA,OAAO,GAAG,MAAM,KAAK,CAAA;AAErB,OAAO,UAAU,MAAM,mCAAmC,CAAA;AAC1D,OAAO,MAAM,MAAM,cAAc,CAAA;AAEjC;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY;IASxB,aAAa;IAEb,IAAI;IACJ,IAAI;IACJ,MAAM;IACX;;iCAE6B;IACxB,KAAK,EADA,GAAG,CAAC,UAAU,CAAC;IAEzB;;wCAEoC;IAC/B,MAAM,EADD,GAAG,CAAC,MAAM,GAAG,SAAS;IAEhC;;;OAGG;IACE,OAAO,EAFF,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC;IAvB3B;;;;;;OAMG;IACH,YAAY,EAAC,aAAa,EAAE,IAAI,EAAE,IAAI,EAAC,EAJpC;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAsB,IAAI,AAA1B,CACA,EADQ,MAAM,CACd;QAAsB,IAAI,AAA1B,CACF,EADU,MAAM,CAChB;KACsC,EAmBtC;IAED;;;OAGG;IACG,KAAK,IAFE,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACG,IAAI,IAFG,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,OAAO,IAFM,MAAM,CAIlB;IAED;;;OAGG;IACH,YAAY,IAFC,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAHb,OAAO,KAAK,EAAE,MAGD,GAFX,IAAI,CAqChB;IAED;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAHJ,OAAO,YAAY,EAAE,sBAGjB,GAFF,IAAI,CAUhB;CACF"}

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

@@ -1,3 +1,22 @@
+export type BeaconSocketRole = "client";
+export type BeaconHelloMessage = {
+    type: "hello";
+    role: BeaconSocketRole;
+    peerId: string;
+    peerType?: string;
+};
+export type BeaconHelloAckMessage = {
+    type: "hello-ack";
+    peerId: string;
+};
+export type BeaconBroadcastMessage = {
+    type: "broadcast";
+    channel: string;
+    broadcastParams: Record<string, ReturnType<typeof JSON.parse>>;
+    body: ReturnType<typeof JSON.parse>;
+    originPeerId?: string;
+};
+export type BeaconSocketMessage = BeaconHelloMessage | BeaconHelloAckMessage | BeaconBroadcastMessage;
 /**
  * Wire-message typedefs for the Beacon broadcast bus.
  *
@@ -31,7 +50,7 @@
  * that must not fall back to local-only delivery.
  */
 /**
- * @typedef {{type: "broadcast", channel: string, broadcastParams: Record<string, ?>, body: ?, originPeerId?: string}} BeaconBroadcastMessage
+ * @typedef {{type: "broadcast", channel: string, broadcastParams: Record<string, ReturnType<typeof JSON.parse>>, body: ReturnType<typeof JSON.parse>, originPeerId?: string}} BeaconBroadcastMessage
  *
  * `channel`, `broadcastParams`, and `body` mirror the
  * `configuration.broadcastToChannel(channel, broadcastParams, body)`
@@ -44,49 +63,5 @@
 /**
  * @typedef {BeaconHelloMessage | BeaconHelloAckMessage | BeaconBroadcastMessage} BeaconSocketMessage
  */
-export const nothing: {};
-/**
- * Beacon currently only has one role. The role field is kept on the
- * `hello` handshake so future roles (e.g. an admin/inspector role) can
- * be added without bumping the wire format.
- */
-export type BeaconSocketRole = "client";
-/**
- * `peerId` uniquely identifies the connecting process for echo
- * suppression and logging. `peerType` is an optional human-readable
- * label such as `"server"`, `"background-jobs-worker"` — informational
- * only.
- */
-export type BeaconHelloMessage = {
-    type: "hello";
-    role: BeaconSocketRole;
-    peerId: string;
-    peerType?: string;
-};
-/**
- * Sent by the daemon after it has registered the peer. Clients can use
- * this as a deterministic readiness boundary before publishing events
- * that must not fall back to local-only delivery.
- */
-export type BeaconHelloAckMessage = {
-    type: "hello-ack";
-    peerId: string;
-};
-/**
- * `channel`, `broadcastParams`, and `body` mirror the
- * `configuration.broadcastToChannel(channel, broadcastParams, body)`
- * arguments. `originPeerId` is stamped by the publishing client and
- * preserved through the daemon so receivers can choose to skip echoes
- * of their own broadcasts (the default Configuration integration does
- * not skip — synapse-style fan-out always returns to sender so every
- * peer follows the same delivery path).
- */
-export type BeaconBroadcastMessage = {
-    type: "broadcast";
-    channel: string;
-    broadcastParams: Record<string, unknown>;
-    body: unknown;
-    originPeerId?: string;
-};
-export type BeaconSocketMessage = BeaconHelloMessage | BeaconHelloAckMessage | BeaconBroadcastMessage;
+export declare const nothing: {};
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/beacon/types.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;GAUG;AAEH;;GAEG;AAEH,yBAAyB;;;;;;+BAxCZ,QAAQ;;;;;;;iCAQR;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAC;;;;;;oCAS1E;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC;;;;;;;;;;qCAQnC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;IAAC,IAAI,EAAE,OAAC,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAC;kCAYxG,kBAAkB,GAAG,qBAAqB,GAAG,sBAAsB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/beacon/types.js"],"names":[],"mappings":"AAcG,YAAoB,gBAAgB,GAA1B,QAAQ,CAKpB;AAGE,YAAsF,kBAAkB,GAA9F;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAC,CAMtF;AAGE,YAA+C,qBAAqB,GAA1D;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAK/C;AAGE,YAA4K,sBAAsB,GAAxL;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAC,CAS5K;AAGE,YAA+E,mBAAmB,GAAxF,kBAAkB,GAAG,qBAAqB,GAAG,sBAAsB,CAAqB;AAjDrG;;;;;;;;;GASG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;GAUG;AAEH;;GAEG;AAEH,eAAO,MAAM,OAAO,IAAK,CAAA"}

package/build/src/beacon/types.js

@@ -32,7 +32,7 @@
  * that must not fall back to local-only delivery.
  */
 /**
- * @typedef {{type: "broadcast", channel: string, broadcastParams: Record<string, ?>, body: ?, originPeerId?: string}} BeaconBroadcastMessage
+ * @typedef {{type: "broadcast", channel: string, broadcastParams: Record<string, ReturnType<typeof JSON.parse>>, body: ReturnType<typeof JSON.parse>, originPeerId?: string}} BeaconBroadcastMessage
  *
  * `channel`, `broadcastParams`, and `body` mirror the
  * `configuration.broadcastToChannel(channel, broadcastParams, body)`
@@ -46,4 +46,4 @@
  * @typedef {BeaconHelloMessage | BeaconHelloAckMessage | BeaconBroadcastMessage} BeaconSocketMessage
  */
 export const nothing = {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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