velocious 1.0.356 → 1.0.358

package/build/src/beacon/client.js

@@ -0,0 +1,224 @@
+// @ts-check
+import { randomUUID } from "node:crypto";
+import net from "node:net";
+import JsonSocket from "../background-jobs/json-socket.js";
+import EventEmitter from "../utils/event-emitter.js";
+const DEFAULT_RECONNECT_DELAY_MS = 1000;
+const MAX_RECONNECT_DELAY_MS = 30_000;
+/**
+ * @typedef {function(import("./types.js").BeaconBroadcastMessage): void} BeaconBroadcastHandler
+ */
+/**
+ * BeaconClient connects to a `velocious beacon` daemon and exchanges
+ * broadcasts with all peer processes connected to the same daemon.
+ *
+ * Lifecycle:
+ *   const client = new BeaconClient({host, port, peerType: "server"})
+ *   await client.connect()                         // resolves on first successful connect
+ *   client.onBroadcast((message) => { ... })       // every fan-out
+ *   client.publish({channel, broadcastParams, body})
+ *   await client.close()
+ *
+ * Reconnect: on socket close (without an explicit `close()` call) the
+ * client schedules a reconnect with exponential backoff. While the
+ * underlying socket is down, `publish(...)` returns false and the
+ * 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 EventEmitter {
+    /**
+     * @param {object} args - Options.
+     * @param {string} args.host - Beacon host.
+     * @param {number} args.port - Beacon port.
+     * @param {string} [args.peerType] - Optional human-readable peer label.
+     * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).
+     * @param {number} [args.reconnectDelayMs] - Starting reconnect delay in ms.
+     * @param {number} [args.maxReconnectDelayMs] - Maximum reconnect delay in ms.
+     */
+    constructor({ host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs }) {
+        super();
+        this.host = host;
+        this.port = port;
+        this.peerType = peerType;
+        this.peerId = peerId || randomUUID();
+        this._initialReconnectDelayMs = reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
+        this._maxReconnectDelayMs = maxReconnectDelayMs ?? MAX_RECONNECT_DELAY_MS;
+        this._reconnectDelayMs = this._initialReconnectDelayMs;
+        /** @type {JsonSocket | undefined} */
+        this._jsonSocket = undefined;
+        /** @type {net.Socket | undefined} */
+        this._socket = undefined;
+        this._connected = false;
+        this._closed = false;
+        /** @type {NodeJS.Timeout | undefined} */
+        this._reconnectTimer = undefined;
+        /** @type {Promise<void> | undefined} */
+        this._connectPromise = undefined;
+        /**
+         * Last socket error observed while connected, surfaced as the disconnect reason.
+         * @type {Error | undefined}
+         */
+        this._lastSocketError = undefined;
+    }
+    /** @returns {string} - The peer id sent on the hello handshake. */
+    getPeerId() { return this.peerId; }
+    /** @returns {boolean} - Whether the underlying socket is currently connected. */
+    isConnected() { return this._connected; }
+    /**
+     * Resolves on the first successful connect. Subsequent calls return
+     * the same promise. Subsequent reconnects after a drop are silent —
+     * use `on("connect")` / `on("disconnect", reason)` to observe them.
+     * The `disconnect` listener receives an `Error` reason: either the
+     * underlying socket error, or `Error("Beacon broker disconnected")`
+     * when the close had no preceding error.
+     * @returns {Promise<void>}
+     */
+    async connect() {
+        if (this._closed)
+            throw new Error("BeaconClient has been closed");
+        if (this._connectPromise)
+            return await this._connectPromise;
+        this._connectPromise = new Promise((resolve, reject) => {
+            const onConnect = () => {
+                this.off("connect", onConnect);
+                this.off("connect-error", onError);
+                resolve();
+            };
+            const onError = (/** @type {Error} */ error) => {
+                this.off("connect", onConnect);
+                this.off("connect-error", onError);
+                reject(error);
+            };
+            this.on("connect", onConnect);
+            this.on("connect-error", onError);
+        });
+        this._openSocket();
+        return await this._connectPromise;
+    }
+    /**
+     * 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, any>} args.broadcastParams - Routing params.
+     * @param {any} 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} */
+        const message = {
+            type: "broadcast",
+            channel,
+            broadcastParams,
+            body,
+            originPeerId: this.peerId
+        };
+        try {
+            this._jsonSocket.send(message);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Registers a handler called once for every `broadcast` message
+     * received from the daemon (including echoes of this client's own
+     * publishes — synapse-style fan-out).
+     * @param {BeaconBroadcastHandler} handler - Handler.
+     * @returns {() => void} - Unregister function.
+     */
+    onBroadcast(handler) {
+        this.on("broadcast", handler);
+        return () => this.off("broadcast", handler);
+    }
+    /** @returns {Promise<void>} - Resolves once the socket is closed. */
+    async close() {
+        this._closed = true;
+        if (this._reconnectTimer) {
+            clearTimeout(this._reconnectTimer);
+            this._reconnectTimer = undefined;
+        }
+        if (this._socket) {
+            const socket = this._socket;
+            await new Promise((resolve) => {
+                socket.once("close", () => resolve(undefined));
+                socket.end();
+            });
+        }
+    }
+    /**
+     * @returns {void}
+     */
+    _openSocket() {
+        if (this._closed)
+            return;
+        const socket = net.createConnection({ host: this.host, port: this.port });
+        this._socket = socket;
+        const jsonSocket = new JsonSocket(socket);
+        this._jsonSocket = jsonSocket;
+        socket.on("connect", () => {
+            this._connected = true;
+            this._reconnectDelayMs = this._initialReconnectDelayMs;
+            jsonSocket.send({
+                type: "hello",
+                role: "client",
+                peerId: this.peerId,
+                peerType: this.peerType
+            });
+            this.emit("connect");
+        });
+        jsonSocket.on("message", (/** @type {import("./types.js").BeaconSocketMessage} */ message) => {
+            if (message?.type === "broadcast") {
+                this.emit("broadcast", message);
+            }
+        });
+        jsonSocket.on("error", (error) => {
+            if (!this._connected) {
+                // Initial connect failed — surface to `connect()`'s promise via `connect-error`.
+                // No `error` emit: that channel is for established-session errors; the
+                // initial-connect path is owned by `connect-error`.
+                this.emit("connect-error", error);
+            }
+            else {
+                // Established session error. Cache so the upcoming `close` event can
+                // surface it as the disconnect reason.
+                this._lastSocketError = error;
+                this.emit("error", error);
+            }
+        });
+        jsonSocket.on("close", () => {
+            const wasConnected = this._connected;
+            this._connected = false;
+            this._jsonSocket = undefined;
+            this._socket = undefined;
+            // Explicit close() sets `_closed = true` before ending the socket.
+            // Don't surface user-initiated teardown as a disconnect "error" —
+            // only network-driven drops should be reported.
+            if (wasConnected && !this._closed) {
+                const reason = this._lastSocketError || new Error("Beacon broker disconnected");
+                this.emit("disconnect", reason);
+            }
+            this._lastSocketError = undefined;
+            if (this._closed)
+                return;
+            this._scheduleReconnect();
+        });
+    }
+    /**
+     * @returns {void}
+     */
+    _scheduleReconnect() {
+        if (this._reconnectTimer)
+            return;
+        const delay = this._reconnectDelayMs;
+        this._reconnectTimer = setTimeout(() => {
+            this._reconnectTimer = undefined;
+            this._reconnectDelayMs = Math.min(delay * 2, this._maxReconnectDelayMs);
+            this._openSocket();
+        }, delay);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {randomUUID} from \"node:crypto\"\nimport net from \"node:net\"\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 *   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._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  /**\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   * 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._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 === \"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._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"]}

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

@@ -0,0 +1,22 @@
+/**
+ * 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;
+/**
+ * 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
+ * registered, but never synchronously inside the publish call.
+ * @param {import("./types.js").BeaconBroadcastMessage} message - Broadcast message.
+ * @returns {void}
+ */
+export function publishToInProcessPeers(message: import("./types.js").BeaconBroadcastMessage): void;
+/**
+ * @returns {number} - Current peer count. Exposed for diagnostics and tests.
+ */
+export function getInProcessPeerCount(): number;
+export type InProcessPeer = {
+    _receiveBroadcast: (message: import("./types.js").BeaconBroadcastMessage) => void;
+};
+//# sourceMappingURL=in-process-broker.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,61 @@
+// @ts-check
+/**
+ * Module-level broker singleton for in-process Beacon mode.
+ *
+ * Every `InProcessBeaconClient` registers itself here on `connect()` and
+ * unregisters on `close()`. `publish(message)` schedules a microtask
+ * fan-out to every registered peer's `_receiveBroadcast(message)`. The
+ * microtask boundary keeps "publish, then receive" ordering safe even
+ * when the publisher and a subscriber are the same client — without it,
+ * a synchronous fan-out could re-enter the caller mid-publish if a
+ * broadcast handler synchronously published again.
+ *
+ * Designed for two scenarios:
+ *   1. Tests with multiple `Configuration` instances in one process
+ *      (no TCP socket setup, deterministic ordering via microtasks).
+ *   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>} */
+const peers = new Set();
+/**
+ * Registers a peer with the broker. Returns an unregister function.
+ * @param {InProcessPeer} peer - Peer instance.
+ * @returns {() => void} - Unregister function.
+ */
+export function registerInProcessPeer(peer) {
+    peers.add(peer);
+    return () => {
+        peers.delete(peer);
+    };
+}
+/**
+ * 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
+ * registered, but never synchronously inside the publish call.
+ * @param {import("./types.js").BeaconBroadcastMessage} message - Broadcast message.
+ * @returns {void}
+ */
+export function publishToInProcessPeers(message) {
+    for (const peer of peers) {
+        queueMicrotask(() => {
+            try {
+                peer._receiveBroadcast(message);
+            }
+            catch (error) {
+                // Mirrors the daemon's per-peer fan-out resilience: a thrown
+                // handler on one peer must not prevent delivery to others. The
+                // caller's framework-error path covers higher-level reporting.
+                console.error("In-process Beacon peer threw during broadcast delivery:", error);
+            }
+        });
+    }
+}
+/**
+ * @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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

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

@@ -0,0 +1,74 @@
+declare const InProcessBeaconClient_base: typeof import("eventemitter3").EventEmitter;
+/**
+ * @typedef {function(import("./types.js").BeaconBroadcastMessage): void} BeaconBroadcastHandler
+ */
+/**
+ * In-process counterpart to `BeaconClient`. Registers with the
+ * module-level `in-process-broker` singleton so peers in the same
+ * process exchange broadcasts without ever touching TCP. Implements the
+ * same external surface as `BeaconClient` (`connect`, `publish`,
+ * `onBroadcast`, `isConnected`, `getPeerId`, `close`) so
+ * `Configuration` can use either client interchangeably.
+ *
+ * Lifecycle differs from `BeaconClient` in two intentional ways:
+ *   - `connect()` resolves immediately; there is no broker to wait for.
+ *   - There is no reconnect loop and no `connect-error` / `disconnect`
+ *     event surface, because nothing can fail.
+ */
+export default class InProcessBeaconClient extends InProcessBeaconClient_base {
+    /**
+     * @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).
+     */
+    constructor({ peerType, peerId }?: {
+        peerType?: string | undefined;
+        peerId?: string | undefined;
+    });
+    peerType: string | undefined;
+    peerId: string;
+    _connected: boolean;
+    /** @type {(() => void) | undefined} */
+    _unregister: (() => void) | undefined;
+    /** @returns {string} - Peer id. */
+    getPeerId(): string;
+    /** @returns {boolean} - Whether the peer is registered with the broker. */
+    isConnected(): boolean;
+    /**
+     * Registers with the in-process broker. Idempotent.
+     * @returns {Promise<void>}
+     */
+    connect(): Promise<void>;
+    /**
+     * Publishes a broadcast to every registered peer (including this
+     * one). Returns false if `connect()` hasn't been called yet, matching
+     * `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.
+     * @returns {boolean} - True when the broadcast was queued.
+     */
+    publish({ channel, broadcastParams, body }: {
+        channel: string;
+        broadcastParams: Record<string, any>;
+        body: any;
+    }): boolean;
+    /**
+     * Registers a handler called once for every broadcast received.
+     * @param {BeaconBroadcastHandler} handler - Handler.
+     * @returns {() => void} - Unregister function.
+     */
+    onBroadcast(handler: BeaconBroadcastHandler): () => void;
+    /**
+     * Receives a broadcast from the broker. Called by `in-process-broker`.
+     * @param {import("./types.js").BeaconBroadcastMessage} message - Broadcast message.
+     * @returns {void}
+     */
+    _receiveBroadcast(message: import("./types.js").BeaconBroadcastMessage): void;
+    /** @returns {Promise<void>} - Unregisters from the broker. */
+    close(): Promise<void>;
+}
+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

@@ -0,0 +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;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAQzB;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;qCArGY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI"}

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

@@ -0,0 +1,99 @@
+// @ts-check
+import { randomUUID } from "node:crypto";
+import EventEmitter from "../utils/event-emitter.js";
+import { publishToInProcessPeers, registerInProcessPeer } from "./in-process-broker.js";
+/**
+ * @typedef {function(import("./types.js").BeaconBroadcastMessage): void} BeaconBroadcastHandler
+ */
+/**
+ * In-process counterpart to `BeaconClient`. Registers with the
+ * module-level `in-process-broker` singleton so peers in the same
+ * process exchange broadcasts without ever touching TCP. Implements the
+ * same external surface as `BeaconClient` (`connect`, `publish`,
+ * `onBroadcast`, `isConnected`, `getPeerId`, `close`) so
+ * `Configuration` can use either client interchangeably.
+ *
+ * Lifecycle differs from `BeaconClient` in two intentional ways:
+ *   - `connect()` resolves immediately; there is no broker to wait for.
+ *   - There is no reconnect loop and no `connect-error` / `disconnect`
+ *     event surface, because nothing can fail.
+ */
+export default class InProcessBeaconClient extends EventEmitter {
+    /**
+     * @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).
+     */
+    constructor({ peerType, peerId } = {}) {
+        super();
+        this.peerType = peerType;
+        this.peerId = peerId || randomUUID();
+        this._connected = false;
+        /** @type {(() => void) | undefined} */
+        this._unregister = undefined;
+    }
+    /** @returns {string} - Peer id. */
+    getPeerId() { return this.peerId; }
+    /** @returns {boolean} - Whether the peer is registered with the broker. */
+    isConnected() { return this._connected; }
+    /**
+     * Registers with the in-process broker. Idempotent.
+     * @returns {Promise<void>}
+     */
+    async connect() {
+        if (this._connected)
+            return;
+        this._unregister = registerInProcessPeer(this);
+        this._connected = true;
+        this.emit("connect");
+    }
+    /**
+     * Publishes a broadcast to every registered peer (including this
+     * one). Returns false if `connect()` hasn't been called yet, matching
+     * `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.
+     * @returns {boolean} - True when the broadcast was queued.
+     */
+    publish({ channel, broadcastParams, body }) {
+        if (!this._connected)
+            return false;
+        /** @type {import("./types.js").BeaconBroadcastMessage} */
+        const message = {
+            type: "broadcast",
+            channel,
+            broadcastParams,
+            body,
+            originPeerId: this.peerId
+        };
+        publishToInProcessPeers(message);
+        return true;
+    }
+    /**
+     * Registers a handler called once for every broadcast received.
+     * @param {BeaconBroadcastHandler} handler - Handler.
+     * @returns {() => void} - Unregister function.
+     */
+    onBroadcast(handler) {
+        this.on("broadcast", handler);
+        return () => this.off("broadcast", handler);
+    }
+    /**
+     * Receives a broadcast from the broker. Called by `in-process-broker`.
+     * @param {import("./types.js").BeaconBroadcastMessage} message - Broadcast message.
+     * @returns {void}
+     */
+    _receiveBroadcast(message) {
+        this.emit("broadcast", message);
+    }
+    /** @returns {Promise<void>} - Unregisters from the broker. */
+    async close() {
+        if (this._unregister)
+            this._unregister();
+        this._unregister = undefined;
+        this._connected = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,61 @@
+/**
+ * Beacon broker daemon.
+ *
+ * Accepts JsonSocket connections from any number of peer processes and
+ * fans every `broadcast` message out to every connected peer.
+ * Intentionally stateless — there is no persistence, no replay, no
+ * channel-name filtering on the daemon. Per-process subscription
+ * matching (already implemented by `_broadcastToChannelLocal`) does the
+ * filtering.
+ */
+export default class BeaconServer {
+    /**
+     * @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;
+    logger: Logger;
+    /** @type {Set<JsonSocket>} */
+    peers: Set<JsonSocket>;
+    /** @type {net.Server | undefined} */
+    server: net.Server | undefined;
+    /**
+     * @returns {Promise<void>} - Resolves when listening.
+     */
+    start(): Promise<void>;
+    /**
+     * @returns {Promise<void>} - Resolves when closed.
+     */
+    stop(): Promise<void>;
+    /**
+     * @returns {number} - Bound port.
+     */
+    getPort(): number;
+    /**
+     * @returns {number} - Number of connected peers.
+     */
+    getPeerCount(): number;
+    /**
+     * @param {import("net").Socket} socket - Socket.
+     * @returns {void}
+     */
+    _handleConnection(socket: import("net").Socket): void;
+    /**
+     * @param {import("./types.js").BeaconBroadcastMessage} message - Broadcast message.
+     * @returns {void}
+     */
+    _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

@@ -0,0 +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,CA6BhB;IAED;;;OAGG;IACH,iBAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAUhB;CACF;mBA7HkB,cAAc;uBADV,mCAAmC;gBAF1C,KAAK"}