@dxos/shell 0.6.3-staging.9c1c979 → 0.6.3

package/dist/bundle/index-ZweceImk.mjs

@@ -1,1322 +0,0 @@
-import { l as n, i as _, A as Y, s 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-CLKnEc1H.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-ZweceImk.mjs.map