@dxos/shell 0.6.3-next.2f65b78 → 0.6.3-staging.0f23fb2

package/dist/bundle/index-BoJU28fu.mjs

@@ -0,0 +1,1322 @@
+import { l as n, i as _, A as Y, f as b, E as p, P as S, B as y, F as T, w as $, C as D, R as Q, T as N, D as P, v as R, k as I, m as V, G as C, q as E, H as x, I as Z, p as z, h as j, c as q, e as ee } from "./index-Ckc10jMw.mjs";
+import { schema as O, trace as w, RateLimitExceededError as se, TimeoutError as J } from "@dxos/protocols";
+import { W as M } from "./browser-C2u-GX_T.mjs";
+var l;
+(function(e) {
+  e[e.CONNECTING = 0] = "CONNECTING", e[e.RECONNECTING = 1] = "RECONNECTING", e[e.CONNECTED = 2] = "CONNECTED", e[e.DISCONNECTED = 3] = "DISCONNECTED", e[e.ERROR = 4] = "ERROR", e[e.CLOSED = 5] = "CLOSED";
+})(l || (l = {}));
+var te = class {
+  recordMessageAckFailed() {
+    C.metrics.increment("dxos.mesh.signal.messenger.failed-ack", 1);
+  }
+  recordReliableMessage(e) {
+    C.metrics.increment("dxos.mesh.signal.messenger.reliable-send", 1, {
+      tags: {
+        success: e.sent,
+        attempts: e.sendAttempts
+      }
+    });
+  }
+}, G = 1e4, g = "/home/runner/work/dxos/dxos/packages/core/mesh/messaging/src/messenger.ts", U = O.getCodecForType("dxos.mesh.messaging.ReliablePayload"), H = O.getCodecForType("dxos.mesh.messaging.Acknowledgement"), ie = 12e4, ve = class {
+  constructor({ signalManager: e, retryDelay: s = 300 }) {
+    this._monitor = new te(), this._listeners = new E(({ peerId: i, payloadType: t }) => i.toHex() + t), this._defaultListeners = new E(S.hash), this._onAckCallbacks = new E(S.hash), this._receivedMessages = new x(S.hash), this._toClear = new x(S.hash), this._closed = !0, this._signalManager = e, this._retryDelay = s, this.open();
+  }
+  open() {
+    if (!this._closed)
+      return;
+    const e = S.random().toHex();
+    n.trace("dxos.mesh.messenger.open", w.begin({
+      id: e
+    }), {
+      F: g,
+      L: 71,
+      S: this,
+      C: (s, i) => s(...i)
+    }), this._ctx = new D({
+      onError: (s) => n.catch(s, void 0, {
+        F: g,
+        L: 73,
+        S: this,
+        C: (i, t) => i(...t)
+      })
+    }, {
+      F: g,
+      L: 72
+    }), this._ctx.onDispose(this._signalManager.onMessage.on(async (s) => {
+      n("received message", {
+        from: s.author
+      }, {
+        F: g,
+        L: 77,
+        S: this,
+        C: (i, t) => i(...t)
+      }), await this._handleMessage(s);
+    })), I(this._ctx, async () => {
+      this._performGc();
+    }, ie), this._closed = !1, n.trace("dxos.mesh.messenger.open", w.end({
+      id: e
+    }), {
+      F: g,
+      L: 92,
+      S: this,
+      C: (s, i) => s(...i)
+    });
+  }
+  async close() {
+    this._closed || (this._closed = !0, await this._ctx.dispose());
+  }
+  async sendMessage({ author: e, recipient: s, payload: i }) {
+    _(!this._closed, "Closed", {
+      F: g,
+      L: 104,
+      S: this,
+      A: [
+        "!this._closed",
+        "'Closed'"
+      ]
+    });
+    const t = this._ctx.derive(), a = {
+      messageId: S.random(),
+      payload: i
+    };
+    _(!this._onAckCallbacks.has(a.messageId), void 0, {
+      F: g,
+      L: 111,
+      S: this,
+      A: [
+        "!this._onAckCallbacks.has(reliablePayload.messageId!)",
+        ""
+      ]
+    }), n("send message", {
+      messageId: a.messageId,
+      author: e,
+      recipient: s
+    }, {
+      F: g,
+      L: 112,
+      S: this,
+      C: (f, v) => f(...v)
+    });
+    let r, o, c = 0;
+    const m = new Promise((f, v) => {
+      r = f, o = v;
+    });
+    return Z(t, async () => {
+      n("retrying message", {
+        messageId: a.messageId
+      }, {
+        F: g,
+        L: 127,
+        S: this,
+        C: (f, v) => f(...v)
+      }), c++, await this._encodeAndSend({
+        author: e,
+        recipient: s,
+        reliablePayload: a
+      }).catch((f) => n("failed to send message", {
+        err: f
+      }, {
+        F: g,
+        L: 130,
+        S: this,
+        C: (v, X) => v(...X)
+      }));
+    }, this._retryDelay), V(t, () => {
+      n("message not delivered", {
+        messageId: a.messageId
+      }, {
+        F: g,
+        L: 139,
+        S: this,
+        C: (f, v) => f(...v)
+      }), this._onAckCallbacks.delete(a.messageId), o(new J("signaling message not delivered", new z(G, "Message not delivered"))), t.dispose(), this._monitor.recordReliableMessage({
+        sendAttempts: c,
+        sent: !1
+      });
+    }, G), this._onAckCallbacks.set(a.messageId, () => {
+      r(), this._onAckCallbacks.delete(a.messageId), t.dispose(), this._monitor.recordReliableMessage({
+        sendAttempts: c,
+        sent: !0
+      });
+    }), await this._encodeAndSend({
+      author: e,
+      recipient: s,
+      reliablePayload: a
+    }), m;
+  }
+  /**
+  * Subscribes onMessage function to messages that contains payload with payloadType.
+  * @param payloadType if not specified, onMessage will be subscribed to all types of messages.
+  */
+  async listen({ peerId: e, payloadType: s, onMessage: i }) {
+    _(!this._closed, "Closed", {
+      F: g,
+      L: 177,
+      S: this,
+      A: [
+        "!this._closed",
+        "'Closed'"
+      ]
+    }), await this._signalManager.subscribeMessages(e);
+    let t;
+    return s ? (t = this._listeners.get({
+      peerId: e,
+      payloadType: s
+    }), t || (t = /* @__PURE__ */ new Set(), this._listeners.set({
+      peerId: e,
+      payloadType: s
+    }, t))) : (t = this._defaultListeners.get(e), t || (t = /* @__PURE__ */ new Set(), this._defaultListeners.set(e, t))), t.add(i), {
+      unsubscribe: async () => {
+        t.delete(i);
+      }
+    };
+  }
+  async _encodeAndSend({ author: e, recipient: s, reliablePayload: i }) {
+    await this._signalManager.sendMessage({
+      author: e,
+      recipient: s,
+      payload: {
+        type_url: "dxos.mesh.messaging.ReliablePayload",
+        value: U.encode(i, {
+          preserveAny: !0
+        })
+      }
+    });
+  }
+  async _handleMessage(e) {
+    switch (e.payload.type_url) {
+      case "dxos.mesh.messaging.ReliablePayload": {
+        await this._handleReliablePayload(e);
+        break;
+      }
+      case "dxos.mesh.messaging.Acknowledgement": {
+        await this._handleAcknowledgement({
+          payload: e.payload
+        });
+        break;
+      }
+    }
+  }
+  async _handleReliablePayload({ author: e, recipient: s, payload: i }) {
+    _(i.type_url === "dxos.mesh.messaging.ReliablePayload", void 0, {
+      F: g,
+      L: 238,
+      S: this,
+      A: [
+        "payload.type_url === 'dxos.mesh.messaging.ReliablePayload'",
+        ""
+      ]
+    });
+    const t = U.decode(i.value, {
+      preserveAny: !0
+    });
+    n("handling message", {
+      messageId: t.messageId
+    }, {
+      F: g,
+      L: 241,
+      S: this,
+      C: (a, r) => a(...r)
+    });
+    try {
+      await this._sendAcknowledgement({
+        author: e,
+        recipient: s,
+        messageId: t.messageId
+      });
+    } catch (a) {
+      throw this._monitor.recordMessageAckFailed(), a;
+    }
+    this._receivedMessages.has(t.messageId) || (this._receivedMessages.add(t.messageId), await this._callListeners({
+      author: e,
+      recipient: s,
+      payload: t.payload
+    }));
+  }
+  async _handleAcknowledgement({ payload: e }) {
+    var s;
+    _(e.type_url === "dxos.mesh.messaging.Acknowledgement", void 0, {
+      F: g,
+      L: 269,
+      S: this,
+      A: [
+        "payload.type_url === 'dxos.mesh.messaging.Acknowledgement'",
+        ""
+      ]
+    }), (s = this._onAckCallbacks.get(H.decode(e.value).messageId)) == null || s();
+  }
+  async _sendAcknowledgement({ author: e, recipient: s, messageId: i }) {
+    n("sending ACK", {
+      messageId: i,
+      from: s,
+      to: e
+    }, {
+      F: g,
+      L: 282,
+      S: this,
+      C: (t, a) => t(...a)
+    }), await this._signalManager.sendMessage({
+      author: s,
+      recipient: e,
+      payload: {
+        type_url: "dxos.mesh.messaging.Acknowledgement",
+        value: H.encode({
+          messageId: i
+        })
+      }
+    });
+  }
+  async _callListeners(e) {
+    {
+      const s = this._defaultListeners.get(e.recipient);
+      if (s)
+        for (const i of s)
+          await i(e);
+    }
+    {
+      const s = this._listeners.get({
+        peerId: e.recipient,
+        payloadType: e.payload.type_url
+      });
+      if (s)
+        for (const i of s)
+          await i(e);
+    }
+  }
+  _performGc() {
+    const e = performance.now();
+    for (const i of this._toClear.keys())
+      this._receivedMessages.delete(i);
+    this._toClear.clear();
+    for (const i of this._receivedMessages.keys())
+      this._toClear.add(i);
+    const s = performance.now() - e;
+    s > 100 && n.warn("GC took too long", {
+      elapsed: s
+    }, {
+      F: g,
+      L: 330,
+      S: this,
+      C: (i, t) => i(...t)
+    });
+  }
+}, ae = class {
+  constructor() {
+    this._performance = {
+      sentMessages: 0,
+      receivedMessages: 0,
+      reconnectCounter: 0,
+      joinCounter: 0,
+      leaveCounter: 0
+    }, this._connectionStarted = /* @__PURE__ */ new Date(), this._lastStateChange = /* @__PURE__ */ new Date();
+  }
+  getRecordedTimestamps() {
+    return {
+      connectionStarted: this._connectionStarted,
+      lastStateChange: this._lastStateChange
+    };
+  }
+  recordStateChangeTime() {
+    this._lastStateChange = /* @__PURE__ */ new Date();
+  }
+  recordConnectionStartTime() {
+    this._connectionStarted = /* @__PURE__ */ new Date();
+  }
+  recordReconnect(e) {
+    this._performance.reconnectCounter++, C.metrics.increment("dxos.mesh.signal.signal-client.reconnect", 1, {
+      tags: {
+        success: e.success
+      }
+    });
+  }
+  recordJoin() {
+    this._performance.joinCounter++;
+  }
+  recordLeave() {
+    this._performance.leaveCounter++;
+  }
+  recordMessageReceived(e) {
+    this._performance.receivedMessages++, C.metrics.increment("dxos.mesh.signal.signal-client.received-total", 1, {
+      tags: A(e)
+    }), C.metrics.distribution("dxos.mesh.signal.signal-client.bytes-in", B(e), {
+      tags: A(e)
+    });
+  }
+  async recordMessageSending(e, s) {
+    this._performance.sentMessages++;
+    const i = A(e);
+    let t = !0;
+    try {
+      const a = Date.now();
+      await s();
+      const r = Date.now() - a;
+      C.metrics.distribution("dxos.mesh.signal.signal-client.send-duration", r, {
+        tags: i
+      }), C.metrics.distribution("dxos.mesh.signal.signal-client.bytes-out", B(e), {
+        tags: i
+      });
+    } catch {
+      t = !1;
+    }
+    C.metrics.increment("dxos.mesh.signal.signal-client.sent-total", 1, {
+      tags: {
+        ...i,
+        success: t
+      }
+    });
+  }
+  recordStreamCloseErrors(e) {
+    C.metrics.increment("dxos.mesh.signal.signal-client.stream-close-errors", e);
+  }
+  recordReconciliation(e) {
+    C.metrics.increment("dxos.mesh.signal.signal-client.reconciliation", 1, {
+      tags: {
+        success: e.success
+      }
+    });
+  }
+}, B = (e) => e.author.asUint8Array().length + e.recipient.asUint8Array().length + e.payload.type_url.length + e.payload.value.length, A = (e) => ({
+  peer: e.author.toHex()
+}), W = "/home/runner/work/dxos/dxos/packages/core/mesh/messaging/src/signal-client/signal-local-state.ts", ne = class {
+  constructor(e, s) {
+    this._onMessage = e, this._onSwarmEvent = s, this._swarmStreams = new E(({ topic: i, peerId: t }) => i.toHex() + t.toHex()), this._joinedTopics = new x(({ topic: i, peerId: t }) => i.toHex() + t.toHex()), this._subscribedMessages = new x(({ peerId: i }) => i.toHex()), this.messageStreams = new E((i) => i.toHex()), this.reconciled = new p();
+  }
+  async safeCloseStreams() {
+    const e = [
+      ...this._swarmStreams.values()
+    ].concat([
+      ...this.messageStreams.values()
+    ]);
+    return this._swarmStreams.clear(), this.messageStreams.clear(), {
+      failureCount: (await T(e, (i) => i.close())).length
+    };
+  }
+  join({ topic: e, peerId: s }) {
+    this._joinedTopics.add({
+      topic: e,
+      peerId: s
+    });
+  }
+  leave({ topic: e, peerId: s }) {
+    var i;
+    (i = this._swarmStreams.get({
+      topic: e,
+      peerId: s
+    })) == null || i.close(), this._swarmStreams.delete({
+      topic: e,
+      peerId: s
+    }), this._joinedTopics.delete({
+      topic: e,
+      peerId: s
+    });
+  }
+  subscribeMessages(e) {
+    this._subscribedMessages.add({
+      peerId: e
+    });
+  }
+  unsubscribeMessages(e) {
+    var s;
+    n("unsubscribing from messages", {
+      peerId: e
+    }, {
+      F: W,
+      L: 76,
+      S: this,
+      C: (i, t) => i(...t)
+    }), this._subscribedMessages.delete({
+      peerId: e
+    }), (s = this.messageStreams.get(e)) == null || s.close(), this.messageStreams.delete(e);
+  }
+  async reconcile(e, s) {
+    await this._reconcileSwarmSubscriptions(e, s), await this._reconcileMessageSubscriptions(e, s), this.reconciled.emit();
+  }
+  async _reconcileSwarmSubscriptions(e, s) {
+    var i;
+    for (const { topic: t, peerId: a } of this._swarmStreams.keys())
+      this._joinedTopics.has({
+        topic: t,
+        peerId: a
+      }) || ((i = this._swarmStreams.get({
+        topic: t,
+        peerId: a
+      })) == null || i.close(), this._swarmStreams.delete({
+        topic: t,
+        peerId: a
+      }));
+    for (const { topic: t, peerId: a } of this._joinedTopics.values()) {
+      if (this._swarmStreams.has({
+        topic: t,
+        peerId: a
+      }))
+        continue;
+      const r = await j(R(e, s.join({
+        topic: t,
+        peerId: a
+      })), 5e3);
+      r.subscribe(async (o) => {
+        this._joinedTopics.has({
+          topic: t,
+          peerId: a
+        }) && (n("swarm event", {
+          swarmEvent: o
+        }, {
+          F: W,
+          L: 112,
+          S: this,
+          C: (c, m) => c(...m)
+        }), await this._onSwarmEvent({
+          topic: t,
+          swarmEvent: o
+        }));
+      }), this._swarmStreams.set({
+        topic: t,
+        peerId: a
+      }, r);
+    }
+  }
+  async _reconcileMessageSubscriptions(e, s) {
+    var i;
+    for (const t of this.messageStreams.keys())
+      this._subscribedMessages.has({
+        peerId: t
+      }) || ((i = this.messageStreams.get(t)) == null || i.close(), this.messageStreams.delete(t));
+    for (const { peerId: t } of this._subscribedMessages.values()) {
+      if (this.messageStreams.has(t))
+        continue;
+      const a = await j(R(e, s.receiveMessages(t)), 5e3);
+      a.subscribe(async (r) => {
+        if (this._subscribedMessages.has({
+          peerId: t
+        })) {
+          const o = {
+            author: S.from(r.author),
+            recipient: S.from(r.recipient),
+            payload: r.payload
+          };
+          await this._onMessage(o);
+        }
+      }), this.messageStreams.set(t, a);
+    }
+  }
+}, re = class {
+  recordClientCloseFailure(e) {
+    C.metrics.increment("dxos.mesh.signal.signal-rpc-client.close-failure", 1, {
+      tags: {
+        reason: e.failureReason
+      }
+    });
+  }
+}, u = "/home/runner/work/dxos/dxos/packages/core/mesh/messaging/src/signal-client/signal-rpc-client.ts", oe = 1e4, ce = class {
+  constructor({ url: e, callbacks: s = {} }) {
+    this._connectTrigger = new N(), this._closed = !1, this._closeComplete = new N(), this._monitor = new re();
+    const i = S.random().toHex();
+    n.trace("dxos.mesh.signal-rpc-client.constructor", w.begin({
+      id: i
+    }), {
+      F: u,
+      L: 60,
+      S: this,
+      C: (t, a) => t(...a)
+    }), this._url = e, this._callbacks = s, this._socket = new M(this._url), this._rpc = q({
+      requested: {
+        Signal: O.getService("dxos.mesh.signal.Signal")
+      },
+      noHandshake: !0,
+      port: {
+        send: (t) => {
+          if (!this._closed)
+            try {
+              this._socket.send(t);
+            } catch (a) {
+              n.warn("send error", a, {
+                F: u,
+                L: 79,
+                S: this,
+                C: (r, o) => r(...o)
+              });
+            }
+        },
+        subscribe: (t) => {
+          this._socket.onmessage = async (a) => {
+            typeof Blob < "u" && a.data instanceof Blob ? t(ee.from(await a.data.arrayBuffer())) : t(a.data);
+          };
+        }
+      },
+      encodingOptions: {
+        preserveAny: !0
+      }
+    }), this._socket.onopen = async () => {
+      var t, a, r, o;
+      try {
+        if (await this._rpc.open(), this._closed) {
+          await this._safeCloseRpc();
+          return;
+        }
+        n(`RPC open ${this._url}`, void 0, {
+          F: u,
+          L: 104,
+          S: this,
+          C: (c, m) => c(...m)
+        }), (a = (t = this._callbacks).onConnected) == null || a.call(t), this._connectTrigger.wake(), this._keepaliveCtx = new D(void 0, {
+          F: u,
+          L: 107
+        }), I(this._keepaliveCtx, async () => {
+          var c;
+          (c = this._socket) == null || c.send("__ping__");
+        }, oe);
+      } catch (c) {
+        (o = (r = this._callbacks).onError) == null || o.call(r, c), this._socket.close(), this._closed = !0;
+      }
+    }, this._socket.onclose = async () => {
+      var t, a;
+      n(`Disconnected ${this._url}`, void 0, {
+        F: u,
+        L: 127,
+        S: this,
+        C: (r, o) => r(...o)
+      }), (a = (t = this._callbacks).onDisconnected) == null || a.call(t), this._closeComplete.wake(), await this.close();
+    }, this._socket.onerror = async (t) => {
+      var a, r;
+      if (this._closed) {
+        this._socket.close();
+        return;
+      }
+      this._closed = !0, (r = (a = this._callbacks).onError) == null || r.call(a, t.error ?? new Error(t.message)), await this._safeCloseRpc(), n.warn(`Socket ${t.type ?? "unknown"} error`, {
+        message: t.message,
+        url: this._url
+      }, {
+        F: u,
+        L: 143,
+        S: this,
+        C: (o, c) => o(...c)
+      });
+    }, n.trace("dxos.mesh.signal-rpc-client.constructor", w.end({
+      id: i
+    }), {
+      F: u,
+      L: 146,
+      S: this,
+      C: (t, a) => t(...a)
+    });
+  }
+  async close() {
+    var e, s;
+    if (!this._closed) {
+      this._closed = !0, await ((e = this._keepaliveCtx) == null ? void 0 : e.dispose());
+      try {
+        await this._safeCloseRpc(), (this._socket.readyState === M.OPEN || this._socket.readyState === M.CONNECTING) && this._socket.close(), await this._closeComplete.wait({
+          timeout: 1e3
+        });
+      } catch (i) {
+        const t = i instanceof z ? "timeout" : ((s = i == null ? void 0 : i.constructor) == null ? void 0 : s.name) ?? "unknown";
+        this._monitor.recordClientCloseFailure({
+          failureReason: t
+        });
+      }
+    }
+  }
+  async join({ topic: e, peerId: s }) {
+    var t, a, r, o;
+    n("join", {
+      topic: e,
+      peerId: s,
+      metadata: (a = (t = this._callbacks) == null ? void 0 : t.getMetadata) == null ? void 0 : a.call(t)
+    }, {
+      F: u,
+      L: 172,
+      S: this,
+      C: (c, m) => c(...m)
+    }), _(!this._closed, "SignalRPCClient is closed", {
+      F: u,
+      L: 173,
+      S: this,
+      A: [
+        "!this._closed",
+        "'SignalRPCClient is closed'"
+      ]
+    }), await this._connectTrigger.wait();
+    const i = this._rpc.rpc.Signal.join({
+      swarm: e.asUint8Array(),
+      peer: s.asUint8Array(),
+      metadata: (o = (r = this._callbacks) == null ? void 0 : r.getMetadata) == null ? void 0 : o.call(r)
+    });
+    return await i.waitUntilReady(), i;
+  }
+  async receiveMessages(e) {
+    n("receiveMessages", {
+      peerId: e
+    }, {
+      F: u,
+      L: 185,
+      S: this,
+      C: (i, t) => i(...t)
+    }), _(!this._closed, "SignalRPCClient is closed", {
+      F: u,
+      L: 186,
+      S: this,
+      A: [
+        "!this._closed",
+        "'SignalRPCClient is closed'"
+      ]
+    }), await this._connectTrigger.wait();
+    const s = this._rpc.rpc.Signal.receiveMessages({
+      peer: e.asUint8Array()
+    });
+    return await s.waitUntilReady(), s;
+  }
+  async sendMessage({ author: e, recipient: s, payload: i }) {
+    var t, a, r, o;
+    n("sendMessage", {
+      author: e,
+      recipient: s,
+      payload: i,
+      metadata: (a = (t = this._callbacks) == null ? void 0 : t.getMetadata) == null ? void 0 : a.call(t)
+    }, {
+      F: u,
+      L: 196,
+      S: this,
+      C: (c, m) => c(...m)
+    }), _(!this._closed, "SignalRPCClient is closed", {
+      F: u,
+      L: 197,
+      S: this,
+      A: [
+        "!this._closed",
+        "'SignalRPCClient is closed'"
+      ]
+    }), await this._connectTrigger.wait(), await this._rpc.rpc.Signal.sendMessage({
+      author: e.asUint8Array(),
+      recipient: s.asUint8Array(),
+      payload: i,
+      metadata: (o = (r = this._callbacks) == null ? void 0 : r.getMetadata) == null ? void 0 : o.call(r)
+    });
+  }
+  async _safeCloseRpc() {
+    try {
+      this._connectTrigger.reset(), await this._rpc.close();
+    } catch (e) {
+      n.catch(e, void 0, {
+        F: u,
+        L: 212,
+        S: this,
+        C: (s, i) => s(...i)
+      });
+    }
+  }
+}, d = "/home/runner/work/dxos/dxos/packages/core/mesh/messaging/src/signal-client/signal-client.ts", K = 100, he = 5e3, le = 1e3, de = 5e3, _e = class extends Q {
+  /**
+  * @param _host Signal server websocket URL.
+  * @param onMessage called when a new message is received.
+  * @param onSwarmEvent called when a new swarm event is received.
+  * @param _getMetadata signal-message metadata provider, called for every message.
+  */
+  constructor(e, s, i, t) {
+    if (super(), this._host = e, this._getMetadata = t, this._monitor = new ae(), this._state = l.CLOSED, this._lastReconciliationFailed = !1, this._clientReady = new N(), this._reconnectAfter = K, this._instanceId = S.random().toHex(), this.statusChanged = new p(), !this._host.startsWith("wss://") && !this._host.startsWith("ws://"))
+      throw new Error(`Signal server requires a websocket URL. Provided: ${this._host}`);
+    this.localState = new ne((a) => (this._monitor.recordMessageReceived(a), s(a)), i);
+  }
+  async _open() {
+    n.trace("dxos.mesh.signal-client.open", w.begin({
+      id: this._instanceId
+    }), {
+      F: d,
+      L: 83,
+      S: this,
+      C: (e, s) => e(...s)
+    }), ![
+      l.CONNECTED,
+      l.CONNECTING
+    ].includes(this._state) && (this._setState(l.CONNECTING), this._reconcileTask = new P(this._ctx, async () => {
+      try {
+        await R(this._connectionCtx, this._clientReady.wait({
+          timeout: 5e3
+        })), _(this._state === l.CONNECTED, "Not connected to Signal Server", {
+          F: d,
+          L: 93,
+          S: this,
+          A: [
+            "this._state === SignalState.CONNECTED",
+            "'Not connected to Signal Server'"
+          ]
+        }), await this.localState.reconcile(this._connectionCtx, this._client), this._monitor.recordReconciliation({
+          success: !0
+        }), this._lastReconciliationFailed = !1;
+      } catch (e) {
+        throw this._lastReconciliationFailed = !0, this._monitor.recordReconciliation({
+          success: !1
+        }), e;
+      }
+    }), I(this._ctx, async () => {
+      this._state === l.CONNECTED && this._reconcileTask.schedule();
+    }, de), this._reconnectTask = new P(this._ctx, async () => {
+      try {
+        await this._reconnect(), this._monitor.recordReconnect({
+          success: !0
+        });
+      } catch (e) {
+        throw this._monitor.recordReconnect({
+          success: !1
+        }), e;
+      }
+    }), this._createClient(), n.trace("dxos.mesh.signal-client.open", w.end({
+      id: this._instanceId
+    }), {
+      F: d,
+      L: 126,
+      S: this,
+      C: (e, s) => e(...s)
+    }));
+  }
+  async _catch(e) {
+    this._state === l.CLOSED || this._ctx.disposed || (this._state === l.CONNECTED && !this._lastReconciliationFailed && n.warn("SignalClient error:", e, {
+      F: d,
+      L: 135,
+      S: this,
+      C: (s, i) => s(...i)
+    }), this._scheduleReconcileAfterError());
+  }
+  async _close() {
+    n("closing...", void 0, {
+      F: d,
+      L: 141,
+      S: this,
+      C: (e, s) => e(...s)
+    }), ![
+      l.CLOSED
+    ].includes(this._state) && (this._setState(l.CLOSED), await this._safeResetClient(), n("closed", void 0, {
+      F: d,
+      L: 149,
+      S: this,
+      C: (e, s) => e(...s)
+    }));
+  }
+  getStatus() {
+    var e;
+    return {
+      host: this._host,
+      state: this._state,
+      error: (e = this._lastError) == null ? void 0 : e.message,
+      reconnectIn: this._reconnectAfter,
+      ...this._monitor.getRecordedTimestamps()
+    };
+  }
+  async join(e) {
+    var s;
+    n("joining", {
+      topic: e.topic,
+      peerId: e.peerId
+    }, {
+      F: d,
+      L: 163,
+      S: this,
+      C: (i, t) => i(...t)
+    }), this._monitor.recordJoin(), this.localState.join(e), (s = this._reconcileTask) == null || s.schedule();
+  }
+  async leave(e) {
+    n("leaving", {
+      topic: e.topic,
+      peerId: e.peerId
+    }, {
+      F: d,
+      L: 170,
+      S: this,
+      C: (s, i) => s(...i)
+    }), this._monitor.recordLeave(), this.localState.leave(e);
+  }
+  async sendMessage(e) {
+    return this._monitor.recordMessageSending(e, async () => {
+      await this._clientReady.wait(), _(this._state === l.CONNECTED, "Not connected to Signal Server", {
+        F: d,
+        L: 178,
+        S: this,
+        A: [
+          "this._state === SignalState.CONNECTED",
+          "'Not connected to Signal Server'"
+        ]
+      }), await this._client.sendMessage(e);
+    });
+  }
+  async subscribeMessages(e) {
+    var s;
+    n("subscribing to messages", {
+      peerId: e
+    }, {
+      F: d,
+      L: 184,
+      S: this,
+      C: (i, t) => i(...t)
+    }), this.localState.subscribeMessages(e), (s = this._reconcileTask) == null || s.schedule();
+  }
+  async unsubscribeMessages(e) {
+    n("unsubscribing from messages", {
+      peerId: e
+    }, {
+      F: d,
+      L: 190,
+      S: this,
+      C: (s, i) => s(...i)
+    }), this.localState.unsubscribeMessages(e);
+  }
+  _scheduleReconcileAfterError() {
+    V(this._ctx, () => this._reconcileTask.schedule(), le);
+  }
+  _createClient() {
+    n("creating client", {
+      host: this._host,
+      state: this._state
+    }, {
+      F: d,
+      L: 199,
+      S: this,
+      C: (e, s) => e(...s)
+    }), _(!this._client, "Client already created", {
+      F: d,
+      L: 200,
+      S: this,
+      A: [
+        "!this._client",
+        "'Client already created'"
+      ]
+    }), this._monitor.recordConnectionStartTime(), this._connectionCtx = this._ctx.derive(), this._connectionCtx.onDispose(async () => {
+      n("connection context disposed", void 0, {
+        F: d,
+        L: 207,
+        S: this,
+        C: (s, i) => s(...i)
+      });
+      const { failureCount: e } = await this.localState.safeCloseStreams();
+      this._monitor.recordStreamCloseErrors(e);
+    });
+    try {
+      const e = new ce({
+        url: this._host,
+        callbacks: {
+          onConnected: () => {
+            e === this._client && (n("socket connected", void 0, {
+              F: d,
+              L: 218,
+              S: this,
+              C: (s, i) => s(...i)
+            }), this._onConnected());
+          },
+          onDisconnected: () => {
+            e === this._client && (n("socket disconnected", {
+              state: this._state
+            }, {
+              F: d,
+              L: 227,
+              S: this,
+              C: (s, i) => s(...i)
+            }), this._state === l.ERROR ? this._setState(l.DISCONNECTED) : this._onDisconnected());
+          },
+          onError: (s) => {
+            e === this._client && (n("socket error", {
+              error: s,
+              state: this._state
+            }, {
+              F: d,
+              L: 239,
+              S: this,
+              C: (i, t) => i(...t)
+            }), this._onDisconnected({
+              error: s
+            }));
+          },
+          getMetadata: this._getMetadata
+        }
+      });
+      this._client = e;
+    } catch (e) {
+      this._client = void 0, this._onDisconnected({
+        error: e
+      });
+    }
+  }
+  async _reconnect() {
+    if (n(`reconnecting in ${this._reconnectAfter}ms`, {
+      state: this._state
+    }, {
+      F: d,
+      L: 254,
+      S: this,
+      C: (e, s) => e(...s)
+    }), this._state === l.RECONNECTING) {
+      n.info("Signal api already reconnecting.", void 0, {
+        F: d,
+        L: 257,
+        S: this,
+        C: (e, s) => e(...s)
+      });
+      return;
+    }
+    this._state !== l.CLOSED && (this._setState(l.RECONNECTING), await this._safeResetClient(), await R(this._ctx, $(this._reconnectAfter)), this._createClient());
+  }
+  _onConnected() {
+    this._lastError = void 0, this._lastReconciliationFailed = !1, this._reconnectAfter = K, this._setState(l.CONNECTED), this._clientReady.wake(), this._reconcileTask.schedule();
+  }
+  _onDisconnected(e) {
+    this._updateReconnectTimeout(), this._state !== l.CLOSED && (e != null && e.error ? (this._lastError = e.error, this._setState(l.ERROR)) : this._setState(l.DISCONNECTED), this._reconnectTask.schedule());
+  }
+  _setState(e) {
+    this._state = e, this._monitor.recordStateChangeTime(), n("signal state changed", {
+      status: this.getStatus()
+    }, {
+      F: d,
+      L: 298,
+      S: this,
+      C: (s, i) => s(...i)
+    }), this.statusChanged.emit(this.getStatus());
+  }
+  _updateReconnectTimeout() {
+    this._state !== l.CONNECTED && this._state !== l.CONNECTING && (this._reconnectAfter *= 2, this._reconnectAfter = Math.min(this._reconnectAfter, he));
+  }
+  async _safeResetClient() {
+    var e, s;
+    await ((e = this._connectionCtx) == null ? void 0 : e.dispose()), this._connectionCtx = void 0, this._clientReady.reset(), await ((s = this._client) == null ? void 0 : s.close().catch(() => {
+    })), this._client = void 0;
+  }
+}, ge = class {
+  recordRateLimitExceeded() {
+    C.metrics.increment("dxos.mesh.signal.signal-manager.rate-limit-hit", 1);
+  }
+  recordServerFailure(e) {
+    C.metrics.increment("dxos.mesh.signal.signal-manager.server-failure", 1, {
+      tags: {
+        server: e.serverName,
+        restarted: e.willRestart
+      }
+    });
+  }
+};
+function L(e, s, i, t) {
+  var a = arguments.length, r = a < 3 ? s : t === null ? t = Object.getOwnPropertyDescriptor(s, i) : t, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+    r = Reflect.decorate(e, s, i, t);
+  else
+    for (var c = e.length - 1; c >= 0; c--)
+      (o = e[c]) && (r = (a < 3 ? o(r) : a > 3 ? o(s, i, r) : o(s, i)) || r);
+  return a > 3 && r && Object.defineProperty(s, i, r), r;
+}
+var h = "/home/runner/work/dxos/dxos/packages/core/mesh/messaging/src/signal-manager/websocket-signal-manager.ts", me = 5, ue = 3e3, k = class {
+  constructor(e, s) {
+    this._hosts = e, this._getMetadata = s, this._servers = /* @__PURE__ */ new Map(), this._monitor = new ge(), this._opened = !1, this.failureCount = /* @__PURE__ */ new Map(), this.statusChanged = new p(), this.swarmEvent = new p(), this.onMessage = new p(), this._instanceId = S.random().toHex(), n("Created WebsocketSignalManager", {
+      hosts: this._hosts
+    }, {
+      F: h,
+      L: 58,
+      S: this,
+      C: (i, t) => i(...t)
+    });
+    for (const i of this._hosts) {
+      if (this._servers.has(i.server))
+        continue;
+      const t = new _e(i.server, async (a) => this.onMessage.emit(a), async (a) => this.swarmEvent.emit(a), this._getMetadata);
+      t.statusChanged.on(() => this.statusChanged.emit(this.getStatus())), this._servers.set(i.server, t), this.failureCount.set(i.server, 0);
+    }
+    this._failedServersBitfield = y.zeros(this._hosts.length);
+  }
+  async open() {
+    this._opened || (n("open signal manager", {
+      hosts: this._hosts
+    }, {
+      F: h,
+      L: 85,
+      S: this,
+      C: (e, s) => e(...s)
+    }), n.trace("dxos.mesh.websocket-signal-manager.open", w.begin({
+      id: this._instanceId
+    }), {
+      F: h,
+      L: 86,
+      S: this,
+      C: (e, s) => e(...s)
+    }), this._initContext(), await T(this._servers.values(), (e) => e.open()), this._opened = !0, n.trace("dxos.mesh.websocket-signal-manager.open", w.end({
+      id: this._instanceId
+    }), {
+      F: h,
+      L: 93,
+      S: this,
+      C: (e, s) => e(...s)
+    }));
+  }
+  async close() {
+    this._opened && (this._opened = !1, await this._ctx.dispose(), await T(this._servers.values(), (e) => e.close()));
+  }
+  async restartServer(e) {
+    n("restarting server", {
+      serverName: e
+    }, {
+      F: h,
+      L: 107,
+      S: this,
+      C: (i, t) => i(...t)
+    }), _(this._opened, "server already closed", {
+      F: h,
+      L: 108,
+      S: this,
+      A: [
+        "this._opened",
+        "'server already closed'"
+      ]
+    });
+    const s = this._servers.get(e);
+    _(s, "server not found", {
+      F: h,
+      L: 111,
+      S: this,
+      A: [
+        "server",
+        "'server not found'"
+      ]
+    }), await s.close(), await $(ue), await s.open();
+  }
+  getStatus() {
+    return Array.from(this._servers.values()).map((e) => e.getStatus());
+  }
+  async join({ topic: e, peerId: s }) {
+    n("join", {
+      topic: e,
+      peerId: s
+    }, {
+      F: h,
+      L: 124,
+      S: this,
+      C: (i, t) => i(...t)
+    }), _(this._opened, "Closed", {
+      F: h,
+      L: 125,
+      S: this,
+      A: [
+        "this._opened",
+        "'Closed'"
+      ]
+    }), await this._forEachServer((i) => i.join({
+      topic: e,
+      peerId: s
+    }));
+  }
+  async leave({ topic: e, peerId: s }) {
+    n("leaving", {
+      topic: e,
+      peerId: s
+    }, {
+      F: h,
+      L: 131,
+      S: this,
+      C: (i, t) => i(...t)
+    }), _(this._opened, "Closed", {
+      F: h,
+      L: 132,
+      S: this,
+      A: [
+        "this._opened",
+        "'Closed'"
+      ]
+    }), await this._forEachServer((i) => i.leave({
+      topic: e,
+      peerId: s
+    }));
+  }
+  async sendMessage({ author: e, recipient: s, payload: i }) {
+    n("signal", {
+      recipient: s
+    }, {
+      F: h,
+      L: 145,
+      S: this,
+      C: (t, a) => t(...a)
+    }), _(this._opened, "Closed", {
+      F: h,
+      L: 146,
+      S: this,
+      A: [
+        "this._opened",
+        "'Closed'"
+      ]
+    }), this._forEachServer(async (t, a, r) => {
+      t.sendMessage({
+        author: e,
+        recipient: s,
+        payload: i
+      }).then(() => this._clearServerFailedFlag(a, r)).catch((o) => {
+        o instanceof se ? (n.info("WSS rate limit exceeded", {
+          err: o
+        }, {
+          F: h,
+          L: 154,
+          S: this,
+          C: (c, m) => c(...m)
+        }), this._monitor.recordRateLimitExceeded()) : o instanceof J || o.constructor.name === "TimeoutError" ? (n.info("WSS sendMessage timeout", {
+          err: o
+        }, {
+          F: h,
+          L: 157,
+          S: this,
+          C: (c, m) => c(...m)
+        }), this.checkServerFailure(a, r)) : (n.warn(`error sending to ${a}`, {
+          err: o
+        }, {
+          F: h,
+          L: 160,
+          S: this,
+          C: (c, m) => c(...m)
+        }), this.checkServerFailure(a, r));
+      });
+    });
+  }
+  async checkServerFailure(e, s) {
+    const i = this.failureCount.get(e) ?? 0, t = i > me;
+    if (this._monitor.recordServerFailure({
+      serverName: e,
+      willRestart: t
+    }), t) {
+      y.get(this._failedServersBitfield, s) || (n.warn("too many failures for ws-server, restarting", {
+        serverName: e,
+        failureCount: i
+      }, {
+        F: h,
+        L: 174,
+        S: this,
+        C: (a, r) => a(...r)
+      }), y.set(this._failedServersBitfield, s, !0)), await this.restartServer(e), this.failureCount.set(e, 0);
+      return;
+    }
+    this.failureCount.set(e, (this.failureCount.get(e) ?? 0) + 1);
+  }
+  _clearServerFailedFlag(e, s) {
+    y.get(this._failedServersBitfield, s) && (n.info("server connection restored", {
+      serverName: e
+    }, {
+      F: h,
+      L: 187,
+      S: this,
+      C: (i, t) => i(...t)
+    }), y.set(this._failedServersBitfield, s, !1), this.failureCount.set(e, 0));
+  }
+  async subscribeMessages(e) {
+    n("subscribed for message stream", {
+      peerId: e
+    }, {
+      F: h,
+      L: 194,
+      S: this,
+      C: (s, i) => s(...i)
+    }), _(this._opened, "Closed", {
+      F: h,
+      L: 195,
+      S: this,
+      A: [
+        "this._opened",
+        "'Closed'"
+      ]
+    }), await this._forEachServer(async (s) => s.subscribeMessages(e));
+  }
+  async unsubscribeMessages(e) {
+    n("subscribed for message stream", {
+      peerId: e
+    }, {
+      F: h,
+      L: 201,
+      S: this,
+      C: (s, i) => s(...i)
+    }), _(this._opened, "Closed", {
+      F: h,
+      L: 202,
+      S: this,
+      A: [
+        "this._opened",
+        "'Closed'"
+      ]
+    }), await this._forEachServer(async (s) => s.unsubscribeMessages(e));
+  }
+  _initContext() {
+    this._ctx = new D({
+      onError: (e) => n.catch(e, void 0, {
+        F: h,
+        L: 209,
+        S: this,
+        C: (s, i) => s(...i)
+      })
+    }, {
+      F: h,
+      L: 208
+    });
+  }
+  async _forEachServer(e) {
+    return Promise.all(Array.from(this._servers.entries()).map(([s, i], t) => e(i, s, t)));
+  }
+};
+L([
+  b
+], k.prototype, "open", null);
+L([
+  b
+], k.prototype, "close", null);
+L([
+  b
+], k.prototype, "join", null);
+L([
+  b
+], k.prototype, "leave", null);
+L([
+  b
+], k.prototype, "checkServerFailure", null);
+var F = "/home/runner/work/dxos/dxos/packages/core/mesh/messaging/src/signal-manager/utils.ts", we = ({ identityService: e, devicesService: s, setTag: i }) => {
+  e.queryIdentity().subscribe((t) => {
+    var a;
+    if (!((a = t == null ? void 0 : t.identity) != null && a.identityKey)) {
+      n("empty response from identity service", {
+        idqr: t
+      }, {
+        F,
+        L: 21,
+        S: void 0,
+        C: (r, o) => r(...o)
+      });
+      return;
+    }
+    i("identityKey", t.identity.identityKey.truncate());
+  }), s.queryDevices().subscribe((t) => {
+    if (!t || !t.devices || t.devices.length === 0) {
+      n("empty response from device service", {
+        device: t
+      }, {
+        F,
+        L: 30,
+        S: void 0,
+        C: (r, o) => r(...o)
+      });
+      return;
+    }
+    _(t, "empty response from device service", {
+      F,
+      L: 33,
+      S: void 0,
+      A: [
+        "dqr",
+        "'empty response from device service'"
+      ]
+    });
+    const a = t.devices.find((r) => r.kind === Y.CURRENT);
+    if (!a) {
+      n("no current device", {
+        device: t
+      }, {
+        F,
+        L: 37,
+        S: void 0,
+        C: (r, o) => r(...o)
+      });
+      return;
+    }
+    i("deviceKey", a.deviceKey.truncate());
+  });
+};
+export {
+  ve as Messenger,
+  _e as SignalClient,
+  k as WebsocketSignalManager,
+  we as setIdentityTags
+};
+//# sourceMappingURL=index-BoJU28fu.mjs.map