@dxos/shell 0.6.3-next.4424131 → 0.6.3-staging.75e3813

package/dist/bundle/index-DXRmq0_o.mjs

@@ -0,0 +1,4593 @@
+import { s as Et, b as ve, r as se, d as It, g as Lt, a as q, f as F, C as N, E as S, i as f, l as a, h as nt, j as rt, T as ee, k as Ae, P as m, m as W, n as Rt, o as Tt, c as Ft, p as At, e as X, q as O, t as ie, S as xt, u as ot, D as at, v as Nt, w as ct, x as Ot, y as ue, z as Pt } from "./index-Ckc10jMw.mjs";
+import { schema as ce, TimeoutError as le, RpcClosedError as ht, trace as $, ConnectionResetError as dt, UnknownProtocolError as Ee, ConnectivityError as he, ProtocolError as lt, CancelledError as xe, SystemError as Dt } from "@dxos/protocols";
+import { Messenger as kt } from "./index-BoJU28fu.mjs";
+function H(t, e) {
+  if (t.length !== e.length) throw new Error("Inputs should have the same length");
+  for (var s = Buffer.allocUnsafe(t.length), i = 0; i < t.length; i++) s[i] = t[i] ^ e[i];
+  return s;
+}
+H.compare = function(e, s) {
+  if (e.length !== s.length) throw new Error("Inputs should have the same length");
+  for (var i = 0; i < e.length; i++)
+    if (e[i] !== s[i])
+      return e[i] < s[i] ? -1 : 1;
+  return 0;
+};
+H.gt = function(e, s) {
+  return H.compare(e, s) === 1;
+};
+H.lt = function(e, s) {
+  return H.compare(e, s) === -1;
+};
+H.eq = function(e, s) {
+  return H.compare(e, s) === 0;
+};
+var Ie = { exports: {} }, ge, ke;
+function Mt() {
+  if (ke) return ge;
+  ke = 1;
+  var t = 1e3, e = t * 60, s = e * 60, i = s * 24, n = i * 7, r = i * 365.25;
+  ge = function(h, l) {
+    l = l || {};
+    var u = typeof h;
+    if (u === "string" && h.length > 0)
+      return o(h);
+    if (u === "number" && isFinite(h))
+      return l.long ? _(h) : c(h);
+    throw new Error(
+      "val is not a non-empty string or a valid number. val=" + JSON.stringify(h)
+    );
+  };
+  function o(h) {
+    if (h = String(h), !(h.length > 100)) {
+      var l = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        h
+      );
+      if (l) {
+        var u = parseFloat(l[1]), D = (l[2] || "ms").toLowerCase();
+        switch (D) {
+          case "years":
+          case "year":
+          case "yrs":
+          case "yr":
+          case "y":
+            return u * r;
+          case "weeks":
+          case "week":
+          case "w":
+            return u * n;
+          case "days":
+          case "day":
+          case "d":
+            return u * i;
+          case "hours":
+          case "hour":
+          case "hrs":
+          case "hr":
+          case "h":
+            return u * s;
+          case "minutes":
+          case "minute":
+          case "mins":
+          case "min":
+          case "m":
+            return u * e;
+          case "seconds":
+          case "second":
+          case "secs":
+          case "sec":
+          case "s":
+            return u * t;
+          case "milliseconds":
+          case "millisecond":
+          case "msecs":
+          case "msec":
+          case "ms":
+            return u;
+          default:
+            return;
+        }
+      }
+    }
+  }
+  function c(h) {
+    var l = Math.abs(h);
+    return l >= i ? Math.round(h / i) + "d" : l >= s ? Math.round(h / s) + "h" : l >= e ? Math.round(h / e) + "m" : l >= t ? Math.round(h / t) + "s" : h + "ms";
+  }
+  function _(h) {
+    var l = Math.abs(h);
+    return l >= i ? d(h, l, i, "day") : l >= s ? d(h, l, s, "hour") : l >= e ? d(h, l, e, "minute") : l >= t ? d(h, l, t, "second") : h + " ms";
+  }
+  function d(h, l, u, D) {
+    var ne = l >= u * 1.5;
+    return Math.round(h / u) + " " + D + (ne ? "s" : "");
+  }
+  return ge;
+}
+function Bt(t) {
+  s.debug = s, s.default = s, s.coerce = _, s.disable = r, s.enable = n, s.enabled = o, s.humanize = Mt(), s.destroy = d, Object.keys(t).forEach((h) => {
+    s[h] = t[h];
+  }), s.names = [], s.skips = [], s.formatters = {};
+  function e(h) {
+    let l = 0;
+    for (let u = 0; u < h.length; u++)
+      l = (l << 5) - l + h.charCodeAt(u), l |= 0;
+    return s.colors[Math.abs(l) % s.colors.length];
+  }
+  s.selectColor = e;
+  function s(h) {
+    let l, u = null, D, ne;
+    function x(...T) {
+      if (!x.enabled)
+        return;
+      const U = x, re = Number(/* @__PURE__ */ new Date()), St = re - (l || re);
+      U.diff = St, U.prev = l, U.curr = re, l = re, T[0] = s.coerce(T[0]), typeof T[0] != "string" && T.unshift("%O");
+      let oe = 0;
+      T[0] = T[0].replace(/%([a-zA-Z%])/g, (pe, bt) => {
+        if (pe === "%%")
+          return "%";
+        oe++;
+        const De = s.formatters[bt];
+        if (typeof De == "function") {
+          const vt = T[oe];
+          pe = De.call(U, vt), T.splice(oe, 1), oe--;
+        }
+        return pe;
+      }), s.formatArgs.call(U, T), (U.log || s.log).apply(U, T);
+    }
+    return x.namespace = h, x.useColors = s.useColors(), x.color = s.selectColor(h), x.extend = i, x.destroy = s.destroy, Object.defineProperty(x, "enabled", {
+      enumerable: !0,
+      configurable: !1,
+      get: () => u !== null ? u : (D !== s.namespaces && (D = s.namespaces, ne = s.enabled(h)), ne),
+      set: (T) => {
+        u = T;
+      }
+    }), typeof s.init == "function" && s.init(x), x;
+  }
+  function i(h, l) {
+    const u = s(this.namespace + (typeof l > "u" ? ":" : l) + h);
+    return u.log = this.log, u;
+  }
+  function n(h) {
+    s.save(h), s.namespaces = h, s.names = [], s.skips = [];
+    let l;
+    const u = (typeof h == "string" ? h : "").split(/[\s,]+/), D = u.length;
+    for (l = 0; l < D; l++)
+      u[l] && (h = u[l].replace(/\*/g, ".*?"), h[0] === "-" ? s.skips.push(new RegExp("^" + h.slice(1) + "$")) : s.names.push(new RegExp("^" + h + "$")));
+  }
+  function r() {
+    const h = [
+      ...s.names.map(c),
+      ...s.skips.map(c).map((l) => "-" + l)
+    ].join(",");
+    return s.enable(""), h;
+  }
+  function o(h) {
+    if (h[h.length - 1] === "*")
+      return !0;
+    let l, u;
+    for (l = 0, u = s.skips.length; l < u; l++)
+      if (s.skips[l].test(h))
+        return !1;
+    for (l = 0, u = s.names.length; l < u; l++)
+      if (s.names[l].test(h))
+        return !0;
+    return !1;
+  }
+  function c(h) {
+    return h.toString().substring(2, h.toString().length - 2).replace(/\.\*\?$/, "*");
+  }
+  function _(h) {
+    return h instanceof Error ? h.stack || h.message : h;
+  }
+  function d() {
+    console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+  }
+  return s.enable(s.load()), s;
+}
+var $t = Bt;
+(function(t, e) {
+  e.formatArgs = i, e.save = n, e.load = r, e.useColors = s, e.storage = o(), e.destroy = /* @__PURE__ */ (() => {
+    let _ = !1;
+    return () => {
+      _ || (_ = !0, console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."));
+    };
+  })(), e.colors = [
+    "#0000CC",
+    "#0000FF",
+    "#0033CC",
+    "#0033FF",
+    "#0066CC",
+    "#0066FF",
+    "#0099CC",
+    "#0099FF",
+    "#00CC00",
+    "#00CC33",
+    "#00CC66",
+    "#00CC99",
+    "#00CCCC",
+    "#00CCFF",
+    "#3300CC",
+    "#3300FF",
+    "#3333CC",
+    "#3333FF",
+    "#3366CC",
+    "#3366FF",
+    "#3399CC",
+    "#3399FF",
+    "#33CC00",
+    "#33CC33",
+    "#33CC66",
+    "#33CC99",
+    "#33CCCC",
+    "#33CCFF",
+    "#6600CC",
+    "#6600FF",
+    "#6633CC",
+    "#6633FF",
+    "#66CC00",
+    "#66CC33",
+    "#9900CC",
+    "#9900FF",
+    "#9933CC",
+    "#9933FF",
+    "#99CC00",
+    "#99CC33",
+    "#CC0000",
+    "#CC0033",
+    "#CC0066",
+    "#CC0099",
+    "#CC00CC",
+    "#CC00FF",
+    "#CC3300",
+    "#CC3333",
+    "#CC3366",
+    "#CC3399",
+    "#CC33CC",
+    "#CC33FF",
+    "#CC6600",
+    "#CC6633",
+    "#CC9900",
+    "#CC9933",
+    "#CCCC00",
+    "#CCCC33",
+    "#FF0000",
+    "#FF0033",
+    "#FF0066",
+    "#FF0099",
+    "#FF00CC",
+    "#FF00FF",
+    "#FF3300",
+    "#FF3333",
+    "#FF3366",
+    "#FF3399",
+    "#FF33CC",
+    "#FF33FF",
+    "#FF6600",
+    "#FF6633",
+    "#FF9900",
+    "#FF9933",
+    "#FFCC00",
+    "#FFCC33"
+  ];
+  function s() {
+    return typeof window < "u" && window.process && (window.process.type === "renderer" || window.process.__nwjs) ? !0 : typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/) ? !1 : typeof document < "u" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+    typeof window < "u" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+    typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+    typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+  }
+  function i(_) {
+    if (_[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + _[0] + (this.useColors ? "%c " : " ") + "+" + t.exports.humanize(this.diff), !this.useColors)
+      return;
+    const d = "color: " + this.color;
+    _.splice(1, 0, d, "color: inherit");
+    let h = 0, l = 0;
+    _[0].replace(/%[a-zA-Z%]/g, (u) => {
+      u !== "%%" && (h++, u === "%c" && (l = h));
+    }), _.splice(l, 0, d);
+  }
+  e.log = console.debug || console.log || (() => {
+  });
+  function n(_) {
+    try {
+      _ ? e.storage.setItem("debug", _) : e.storage.removeItem("debug");
+    } catch {
+    }
+  }
+  function r() {
+    let _;
+    try {
+      _ = e.storage.getItem("debug");
+    } catch {
+    }
+    return !_ && typeof process < "u" && "env" in process && (_ = process.env.DEBUG), _;
+  }
+  function o() {
+    try {
+      return localStorage;
+    } catch {
+    }
+  }
+  t.exports = $t(e);
+  const { formatters: c } = t.exports;
+  c.j = function(_) {
+    try {
+      return JSON.stringify(_);
+    } catch (d) {
+      return "[UnexpectedJSONParseError]: " + d.message;
+    }
+  };
+})(Ie, Ie.exports);
+var qt = Ie.exports, jt = function() {
+  if (typeof globalThis > "u") return null;
+  var e = {
+    RTCPeerConnection: globalThis.RTCPeerConnection || globalThis.mozRTCPeerConnection || globalThis.webkitRTCPeerConnection,
+    RTCSessionDescription: globalThis.RTCSessionDescription || globalThis.mozRTCSessionDescription || globalThis.webkitRTCSessionDescription,
+    RTCIceCandidate: globalThis.RTCIceCandidate || globalThis.mozRTCIceCandidate || globalThis.webkitRTCIceCandidate
+  };
+  return e.RTCPeerConnection ? e : null;
+}, Le = { exports: {} }, me = 65536, Ut = 4294967295;
+function Ht() {
+  throw new Error(`Secure random number generation is not supported by this browser.
+Use Chrome, Firefox or Internet Explorer 11`);
+}
+var Gt = Et.Buffer, de = ve.crypto || ve.msCrypto;
+de && de.getRandomValues ? Le.exports = zt : Le.exports = Ht;
+function zt(t, e) {
+  if (t > Ut) throw new RangeError("requested too many random bytes");
+  var s = Gt.allocUnsafe(t);
+  if (t > 0)
+    if (t > me)
+      for (var i = 0; i < t; i += me)
+        de.getRandomValues(s.slice(i, i + me));
+    else
+      de.getRandomValues(s);
+  return typeof e == "function" ? process.nextTick(function() {
+    e(null, s);
+  }) : s;
+}
+var Yt = Le.exports;
+/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+let Me;
+var Kt = typeof queueMicrotask == "function" ? queueMicrotask.bind(typeof window < "u" ? window : ve) : (t) => (Me || (Me = Promise.resolve())).then(t).catch((e) => setTimeout(() => {
+  throw e;
+}, 0));
+function Be(t, e) {
+  for (const s in e)
+    Object.defineProperty(t, s, {
+      value: e[s],
+      enumerable: !0,
+      configurable: !0
+    });
+  return t;
+}
+function Wt(t, e, s) {
+  if (!t || typeof t == "string")
+    throw new TypeError("Please pass an Error to err-code");
+  s || (s = {}), typeof e == "object" && (s = e, e = ""), e && (s.code = e);
+  try {
+    return Be(t, s);
+  } catch {
+    s.message = t.message, s.stack = t.stack;
+    const n = function() {
+    };
+    return n.prototype = Object.create(Object.getPrototypeOf(t)), Be(new n(), s);
+  }
+}
+var Xt = Wt;
+/*! simple-peer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+const Vt = qt("simple-peer"), _t = jt, $e = Yt, Zt = se, Ce = Kt, g = Xt, { Buffer: Jt } = It, we = 64 * 1024, Qt = 5 * 1e3, es = 5 * 1e3;
+function qe(t) {
+  return t.replace(/a=ice-options:trickle\s\n/g, "");
+}
+function ts(t) {
+  console.warn(t);
+}
+let _e = class Re extends Zt.Duplex {
+  constructor(e) {
+    if (e = Object.assign({
+      allowHalfOpen: !1
+    }, e), super(e), this._id = $e(4).toString("hex").slice(0, 7), this._debug("new peer %o", e), this.channelName = e.initiator ? e.channelName || $e(20).toString("hex") : null, this.initiator = e.initiator || !1, this.channelConfig = e.channelConfig || Re.channelConfig, this.channelNegotiated = this.channelConfig.negotiated, this.config = Object.assign({}, Re.config, e.config), this.offerOptions = e.offerOptions || {}, this.answerOptions = e.answerOptions || {}, this.sdpTransform = e.sdpTransform || ((s) => s), this.streams = e.streams || (e.stream ? [e.stream] : []), this.trickle = e.trickle !== void 0 ? e.trickle : !0, this.allowHalfTrickle = e.allowHalfTrickle !== void 0 ? e.allowHalfTrickle : !1, this.iceCompleteTimeout = e.iceCompleteTimeout || Qt, this.destroyed = !1, this.destroying = !1, this._connected = !1, this.remoteAddress = void 0, this.remoteFamily = void 0, this.remotePort = void 0, this.localAddress = void 0, this.localFamily = void 0, this.localPort = void 0, this._wrtc = e.wrtc && typeof e.wrtc == "object" ? e.wrtc : _t(), !this._wrtc)
+      throw g(typeof window > "u" ? new Error("No WebRTC support: Specify `opts.wrtc` option in this environment") : new Error("No WebRTC support: Not a supported browser"), "ERR_WEBRTC_SUPPORT");
+    this._pcReady = !1, this._channelReady = !1, this._iceComplete = !1, this._iceCompleteTimer = null, this._channel = null, this._pendingCandidates = [], this._isNegotiating = !1, this._firstNegotiation = !0, this._batchedNegotiation = !1, this._queuedNegotiation = !1, this._sendersAwaitingStable = [], this._senderMap = /* @__PURE__ */ new Map(), this._closingInterval = null, this._remoteTracks = [], this._remoteStreams = [], this._chunk = null, this._cb = null, this._interval = null;
+    try {
+      this._pc = new this._wrtc.RTCPeerConnection(this.config);
+    } catch (s) {
+      this.destroy(g(s, "ERR_PC_CONSTRUCTOR"));
+      return;
+    }
+    this._isReactNativeWebrtc = typeof this._pc._peerConnectionId == "number", this._pc.oniceconnectionstatechange = () => {
+      this._onIceStateChange();
+    }, this._pc.onicegatheringstatechange = () => {
+      this._onIceStateChange();
+    }, this._pc.onconnectionstatechange = () => {
+      this._onConnectionStateChange();
+    }, this._pc.onsignalingstatechange = () => {
+      this._onSignalingStateChange();
+    }, this._pc.onicecandidate = (s) => {
+      this._onIceCandidate(s);
+    }, typeof this._pc.peerIdentity == "object" && this._pc.peerIdentity.catch((s) => {
+      this.destroy(g(s, "ERR_PC_PEER_IDENTITY"));
+    }), this.initiator || this.channelNegotiated ? this._setupData({
+      channel: this._pc.createDataChannel(this.channelName, this.channelConfig)
+    }) : this._pc.ondatachannel = (s) => {
+      this._setupData(s);
+    }, this.streams && this.streams.forEach((s) => {
+      this.addStream(s);
+    }), this._pc.ontrack = (s) => {
+      this._onTrack(s);
+    }, this._debug("initial negotiation"), this._needsNegotiation(), this._onFinishBound = () => {
+      this._onFinish();
+    }, this.once("finish", this._onFinishBound);
+  }
+  get bufferSize() {
+    return this._channel && this._channel.bufferedAmount || 0;
+  }
+  // HACK: it's possible channel.readyState is "closing" before peer.destroy() fires
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=882743
+  get connected() {
+    return this._connected && this._channel.readyState === "open";
+  }
+  address() {
+    return { port: this.localPort, family: this.localFamily, address: this.localAddress };
+  }
+  signal(e) {
+    if (!this.destroying) {
+      if (this.destroyed) throw g(new Error("cannot signal after peer is destroyed"), "ERR_DESTROYED");
+      if (typeof e == "string")
+        try {
+          e = JSON.parse(e);
+        } catch {
+          e = {};
+        }
+      this._debug("signal()"), e.renegotiate && this.initiator && (this._debug("got request to renegotiate"), this._needsNegotiation()), e.transceiverRequest && this.initiator && (this._debug("got request for transceiver"), this.addTransceiver(e.transceiverRequest.kind, e.transceiverRequest.init)), e.candidate && (this._pc.remoteDescription && this._pc.remoteDescription.type ? this._addIceCandidate(e.candidate) : this._pendingCandidates.push(e.candidate)), e.sdp && this._pc.setRemoteDescription(new this._wrtc.RTCSessionDescription(e)).then(() => {
+        this.destroyed || (this._pendingCandidates.forEach((s) => {
+          this._addIceCandidate(s);
+        }), this._pendingCandidates = [], this._pc.remoteDescription.type === "offer" && this._createAnswer());
+      }).catch((s) => {
+        this.destroy(g(s, "ERR_SET_REMOTE_DESCRIPTION"));
+      }), !e.sdp && !e.candidate && !e.renegotiate && !e.transceiverRequest && this.destroy(g(new Error("signal() called with invalid signal data"), "ERR_SIGNALING"));
+    }
+  }
+  _addIceCandidate(e) {
+    const s = new this._wrtc.RTCIceCandidate(e);
+    this._pc.addIceCandidate(s).catch((i) => {
+      !s.address || s.address.endsWith(".local") ? ts("Ignoring unsupported ICE candidate.") : this.destroy(g(i, "ERR_ADD_ICE_CANDIDATE"));
+    });
+  }
+  /**
+   * Send text/binary data to the remote peer.
+   * @param {ArrayBufferView|ArrayBuffer|Buffer|string|Blob} chunk
+   */
+  send(e) {
+    if (!this.destroying) {
+      if (this.destroyed) throw g(new Error("cannot send after peer is destroyed"), "ERR_DESTROYED");
+      this._channel.send(e);
+    }
+  }
+  /**
+   * Add a Transceiver to the connection.
+   * @param {String} kind
+   * @param {Object} init
+   */
+  addTransceiver(e, s) {
+    if (!this.destroying) {
+      if (this.destroyed) throw g(new Error("cannot addTransceiver after peer is destroyed"), "ERR_DESTROYED");
+      if (this._debug("addTransceiver()"), this.initiator)
+        try {
+          this._pc.addTransceiver(e, s), this._needsNegotiation();
+        } catch (i) {
+          this.destroy(g(i, "ERR_ADD_TRANSCEIVER"));
+        }
+      else
+        this.emit("signal", {
+          // request initiator to renegotiate
+          type: "transceiverRequest",
+          transceiverRequest: { kind: e, init: s }
+        });
+    }
+  }
+  /**
+   * Add a MediaStream to the connection.
+   * @param {MediaStream} stream
+   */
+  addStream(e) {
+    if (!this.destroying) {
+      if (this.destroyed) throw g(new Error("cannot addStream after peer is destroyed"), "ERR_DESTROYED");
+      this._debug("addStream()"), e.getTracks().forEach((s) => {
+        this.addTrack(s, e);
+      });
+    }
+  }
+  /**
+   * Add a MediaStreamTrack to the connection.
+   * @param {MediaStreamTrack} track
+   * @param {MediaStream} stream
+   */
+  addTrack(e, s) {
+    if (this.destroying) return;
+    if (this.destroyed) throw g(new Error("cannot addTrack after peer is destroyed"), "ERR_DESTROYED");
+    this._debug("addTrack()");
+    const i = this._senderMap.get(e) || /* @__PURE__ */ new Map();
+    let n = i.get(s);
+    if (!n)
+      n = this._pc.addTrack(e, s), i.set(s, n), this._senderMap.set(e, i), this._needsNegotiation();
+    else throw n.removed ? g(new Error("Track has been removed. You should enable/disable tracks that you want to re-add."), "ERR_SENDER_REMOVED") : g(new Error("Track has already been added to that stream."), "ERR_SENDER_ALREADY_ADDED");
+  }
+  /**
+   * Replace a MediaStreamTrack by another in the connection.
+   * @param {MediaStreamTrack} oldTrack
+   * @param {MediaStreamTrack} newTrack
+   * @param {MediaStream} stream
+   */
+  replaceTrack(e, s, i) {
+    if (this.destroying) return;
+    if (this.destroyed) throw g(new Error("cannot replaceTrack after peer is destroyed"), "ERR_DESTROYED");
+    this._debug("replaceTrack()");
+    const n = this._senderMap.get(e), r = n ? n.get(i) : null;
+    if (!r)
+      throw g(new Error("Cannot replace track that was never added."), "ERR_TRACK_NOT_ADDED");
+    s && this._senderMap.set(s, n), r.replaceTrack != null ? r.replaceTrack(s) : this.destroy(g(new Error("replaceTrack is not supported in this browser"), "ERR_UNSUPPORTED_REPLACETRACK"));
+  }
+  /**
+   * Remove a MediaStreamTrack from the connection.
+   * @param {MediaStreamTrack} track
+   * @param {MediaStream} stream
+   */
+  removeTrack(e, s) {
+    if (this.destroying) return;
+    if (this.destroyed) throw g(new Error("cannot removeTrack after peer is destroyed"), "ERR_DESTROYED");
+    this._debug("removeSender()");
+    const i = this._senderMap.get(e), n = i ? i.get(s) : null;
+    if (!n)
+      throw g(new Error("Cannot remove track that was never added."), "ERR_TRACK_NOT_ADDED");
+    try {
+      n.removed = !0, this._pc.removeTrack(n);
+    } catch (r) {
+      r.name === "NS_ERROR_UNEXPECTED" ? this._sendersAwaitingStable.push(n) : this.destroy(g(r, "ERR_REMOVE_TRACK"));
+    }
+    this._needsNegotiation();
+  }
+  /**
+   * Remove a MediaStream from the connection.
+   * @param {MediaStream} stream
+   */
+  removeStream(e) {
+    if (!this.destroying) {
+      if (this.destroyed) throw g(new Error("cannot removeStream after peer is destroyed"), "ERR_DESTROYED");
+      this._debug("removeSenders()"), e.getTracks().forEach((s) => {
+        this.removeTrack(s, e);
+      });
+    }
+  }
+  _needsNegotiation() {
+    this._debug("_needsNegotiation"), !this._batchedNegotiation && (this._batchedNegotiation = !0, Ce(() => {
+      this._batchedNegotiation = !1, this.initiator || !this._firstNegotiation ? (this._debug("starting batched negotiation"), this.negotiate()) : this._debug("non-initiator initial negotiation request discarded"), this._firstNegotiation = !1;
+    }));
+  }
+  negotiate() {
+    if (!this.destroying) {
+      if (this.destroyed) throw g(new Error("cannot negotiate after peer is destroyed"), "ERR_DESTROYED");
+      this.initiator ? this._isNegotiating ? (this._queuedNegotiation = !0, this._debug("already negotiating, queueing")) : (this._debug("start negotiation"), setTimeout(() => {
+        this._createOffer();
+      }, 0)) : this._isNegotiating ? (this._queuedNegotiation = !0, this._debug("already negotiating, queueing")) : (this._debug("requesting negotiation from initiator"), this.emit("signal", {
+        // request initiator to renegotiate
+        type: "renegotiate",
+        renegotiate: !0
+      })), this._isNegotiating = !0;
+    }
+  }
+  // TODO: Delete this method once readable-stream is updated to contain a default
+  // implementation of destroy() that automatically calls _destroy()
+  // See: https://github.com/nodejs/readable-stream/issues/283
+  destroy(e) {
+    this._destroy(e, () => {
+    });
+  }
+  _destroy(e, s) {
+    this.destroyed || this.destroying || (this.destroying = !0, this._debug("destroying (error: %s)", e && (e.message || e)), Ce(() => {
+      if (this.destroyed = !0, this.destroying = !1, this._debug("destroy (error: %s)", e && (e.message || e)), this.readable = this.writable = !1, this._readableState.ended || this.push(null), this._writableState.finished || this.end(), this._connected = !1, this._pcReady = !1, this._channelReady = !1, this._remoteTracks = null, this._remoteStreams = null, this._senderMap = null, clearInterval(this._closingInterval), this._closingInterval = null, clearInterval(this._interval), this._interval = null, this._chunk = null, this._cb = null, this._onFinishBound && this.removeListener("finish", this._onFinishBound), this._onFinishBound = null, this._channel) {
+        try {
+          this._channel.close();
+        } catch {
+        }
+        this._channel.onmessage = null, this._channel.onopen = null, this._channel.onclose = null, this._channel.onerror = null;
+      }
+      if (this._pc) {
+        try {
+          this._pc.close();
+        } catch {
+        }
+        this._pc.oniceconnectionstatechange = null, this._pc.onicegatheringstatechange = null, this._pc.onsignalingstatechange = null, this._pc.onicecandidate = null, this._pc.ontrack = null, this._pc.ondatachannel = null;
+      }
+      this._pc = null, this._channel = null, e && this.emit("error", e), this.emit("close"), s();
+    }));
+  }
+  _setupData(e) {
+    if (!e.channel)
+      return this.destroy(g(new Error("Data channel event is missing `channel` property"), "ERR_DATA_CHANNEL"));
+    this._channel = e.channel, this._channel.binaryType = "arraybuffer", typeof this._channel.bufferedAmountLowThreshold == "number" && (this._channel.bufferedAmountLowThreshold = we), this.channelName = this._channel.label, this._channel.onmessage = (i) => {
+      this._onChannelMessage(i);
+    }, this._channel.onbufferedamountlow = () => {
+      this._onChannelBufferedAmountLow();
+    }, this._channel.onopen = () => {
+      this._onChannelOpen();
+    }, this._channel.onclose = () => {
+      this._onChannelClose();
+    }, this._channel.onerror = (i) => {
+      const n = i.error instanceof Error ? i.error : new Error(`Datachannel error: ${i.message} ${i.filename}:${i.lineno}:${i.colno}`);
+      this.destroy(g(n, "ERR_DATA_CHANNEL"));
+    };
+    let s = !1;
+    this._closingInterval = setInterval(() => {
+      this._channel && this._channel.readyState === "closing" ? (s && this._onChannelClose(), s = !0) : s = !1;
+    }, es);
+  }
+  _read() {
+  }
+  _write(e, s, i) {
+    if (this.destroyed) return i(g(new Error("cannot write after peer is destroyed"), "ERR_DATA_CHANNEL"));
+    if (this._connected) {
+      try {
+        this.send(e);
+      } catch (n) {
+        return this.destroy(g(n, "ERR_DATA_CHANNEL"));
+      }
+      this._channel.bufferedAmount > we ? (this._debug("start backpressure: bufferedAmount %d", this._channel.bufferedAmount), this._cb = i) : i(null);
+    } else
+      this._debug("write before connect"), this._chunk = e, this._cb = i;
+  }
+  // When stream finishes writing, close socket. Half open connections are not
+  // supported.
+  _onFinish() {
+    if (this.destroyed) return;
+    const e = () => {
+      setTimeout(() => this.destroy(), 1e3);
+    };
+    this._connected ? e() : this.once("connect", e);
+  }
+  _startIceCompleteTimeout() {
+    this.destroyed || this._iceCompleteTimer || (this._debug("started iceComplete timeout"), this._iceCompleteTimer = setTimeout(() => {
+      this._iceComplete || (this._iceComplete = !0, this._debug("iceComplete timeout completed"), this.emit("iceTimeout"), this.emit("_iceComplete"));
+    }, this.iceCompleteTimeout));
+  }
+  _createOffer() {
+    this.destroyed || this._pc.createOffer(this.offerOptions).then((e) => {
+      if (this.destroyed) return;
+      !this.trickle && !this.allowHalfTrickle && (e.sdp = qe(e.sdp)), e.sdp = this.sdpTransform(e.sdp);
+      const s = () => {
+        if (this.destroyed) return;
+        const r = this._pc.localDescription || e;
+        this._debug("signal"), this.emit("signal", {
+          type: r.type,
+          sdp: r.sdp
+        });
+      }, i = () => {
+        this._debug("createOffer success"), !this.destroyed && (this.trickle || this._iceComplete ? s() : this.once("_iceComplete", s));
+      }, n = (r) => {
+        this.destroy(g(r, "ERR_SET_LOCAL_DESCRIPTION"));
+      };
+      this._pc.setLocalDescription(e).then(i).catch(n);
+    }).catch((e) => {
+      this.destroy(g(e, "ERR_CREATE_OFFER"));
+    });
+  }
+  _requestMissingTransceivers() {
+    this._pc.getTransceivers && this._pc.getTransceivers().forEach((e) => {
+      !e.mid && e.sender.track && !e.requested && (e.requested = !0, this.addTransceiver(e.sender.track.kind));
+    });
+  }
+  _createAnswer() {
+    this.destroyed || this._pc.createAnswer(this.answerOptions).then((e) => {
+      if (this.destroyed) return;
+      !this.trickle && !this.allowHalfTrickle && (e.sdp = qe(e.sdp)), e.sdp = this.sdpTransform(e.sdp);
+      const s = () => {
+        if (this.destroyed) return;
+        const r = this._pc.localDescription || e;
+        this._debug("signal"), this.emit("signal", {
+          type: r.type,
+          sdp: r.sdp
+        }), this.initiator || this._requestMissingTransceivers();
+      }, i = () => {
+        this.destroyed || (this.trickle || this._iceComplete ? s() : this.once("_iceComplete", s));
+      }, n = (r) => {
+        this.destroy(g(r, "ERR_SET_LOCAL_DESCRIPTION"));
+      };
+      this._pc.setLocalDescription(e).then(i).catch(n);
+    }).catch((e) => {
+      this.destroy(g(e, "ERR_CREATE_ANSWER"));
+    });
+  }
+  _onConnectionStateChange() {
+    this.destroyed || this._pc.connectionState === "failed" && this.destroy(g(new Error("Connection failed."), "ERR_CONNECTION_FAILURE"));
+  }
+  _onIceStateChange() {
+    if (this.destroyed) return;
+    const e = this._pc.iceConnectionState, s = this._pc.iceGatheringState;
+    this._debug(
+      "iceStateChange (connection: %s) (gathering: %s)",
+      e,
+      s
+    ), this.emit("iceStateChange", e, s), (e === "connected" || e === "completed") && (this._pcReady = !0, this._maybeReady()), e === "failed" && this.destroy(g(new Error("Ice connection failed."), "ERR_ICE_CONNECTION_FAILURE")), e === "closed" && this.destroy(g(new Error("Ice connection closed."), "ERR_ICE_CONNECTION_CLOSED"));
+  }
+  getStats(e) {
+    const s = (i) => (Object.prototype.toString.call(i.values) === "[object Array]" && i.values.forEach((n) => {
+      Object.assign(i, n);
+    }), i);
+    this._pc.getStats.length === 0 || this._isReactNativeWebrtc ? this._pc.getStats().then((i) => {
+      const n = [];
+      i.forEach((r) => {
+        n.push(s(r));
+      }), e(null, n);
+    }, (i) => e(i)) : this._pc.getStats.length > 0 ? this._pc.getStats((i) => {
+      if (this.destroyed) return;
+      const n = [];
+      i.result().forEach((r) => {
+        const o = {};
+        r.names().forEach((c) => {
+          o[c] = r.stat(c);
+        }), o.id = r.id, o.type = r.type, o.timestamp = r.timestamp, n.push(s(o));
+      }), e(null, n);
+    }, (i) => e(i)) : e(null, []);
+  }
+  _maybeReady() {
+    if (this._debug("maybeReady pc %s channel %s", this._pcReady, this._channelReady), this._connected || this._connecting || !this._pcReady || !this._channelReady) return;
+    this._connecting = !0;
+    const e = () => {
+      this.destroyed || this.getStats((s, i) => {
+        if (this.destroyed) return;
+        s && (i = []);
+        const n = {}, r = {}, o = {};
+        let c = !1;
+        i.forEach((d) => {
+          (d.type === "remotecandidate" || d.type === "remote-candidate") && (n[d.id] = d), (d.type === "localcandidate" || d.type === "local-candidate") && (r[d.id] = d), (d.type === "candidatepair" || d.type === "candidate-pair") && (o[d.id] = d);
+        });
+        const _ = (d) => {
+          c = !0;
+          let h = r[d.localCandidateId];
+          h && (h.ip || h.address) ? (this.localAddress = h.ip || h.address, this.localPort = Number(h.port)) : h && h.ipAddress ? (this.localAddress = h.ipAddress, this.localPort = Number(h.portNumber)) : typeof d.googLocalAddress == "string" && (h = d.googLocalAddress.split(":"), this.localAddress = h[0], this.localPort = Number(h[1])), this.localAddress && (this.localFamily = this.localAddress.includes(":") ? "IPv6" : "IPv4");
+          let l = n[d.remoteCandidateId];
+          l && (l.ip || l.address) ? (this.remoteAddress = l.ip || l.address, this.remotePort = Number(l.port)) : l && l.ipAddress ? (this.remoteAddress = l.ipAddress, this.remotePort = Number(l.portNumber)) : typeof d.googRemoteAddress == "string" && (l = d.googRemoteAddress.split(":"), this.remoteAddress = l[0], this.remotePort = Number(l[1])), this.remoteAddress && (this.remoteFamily = this.remoteAddress.includes(":") ? "IPv6" : "IPv4"), this._debug(
+            "connect local: %s:%s remote: %s:%s",
+            this.localAddress,
+            this.localPort,
+            this.remoteAddress,
+            this.remotePort
+          );
+        };
+        if (i.forEach((d) => {
+          d.type === "transport" && d.selectedCandidatePairId && _(o[d.selectedCandidatePairId]), (d.type === "googCandidatePair" && d.googActiveConnection === "true" || (d.type === "candidatepair" || d.type === "candidate-pair") && d.selected) && _(d);
+        }), !c && (!Object.keys(o).length || Object.keys(r).length)) {
+          setTimeout(e, 100);
+          return;
+        } else
+          this._connecting = !1, this._connected = !0;
+        if (this._chunk) {
+          try {
+            this.send(this._chunk);
+          } catch (h) {
+            return this.destroy(g(h, "ERR_DATA_CHANNEL"));
+          }
+          this._chunk = null, this._debug('sent chunk from "write before connect"');
+          const d = this._cb;
+          this._cb = null, d(null);
+        }
+        typeof this._channel.bufferedAmountLowThreshold != "number" && (this._interval = setInterval(() => this._onInterval(), 150), this._interval.unref && this._interval.unref()), this._debug("connect"), this.emit("connect");
+      });
+    };
+    e();
+  }
+  _onInterval() {
+    !this._cb || !this._channel || this._channel.bufferedAmount > we || this._onChannelBufferedAmountLow();
+  }
+  _onSignalingStateChange() {
+    this.destroyed || (this._pc.signalingState === "stable" && (this._isNegotiating = !1, this._debug("flushing sender queue", this._sendersAwaitingStable), this._sendersAwaitingStable.forEach((e) => {
+      this._pc.removeTrack(e), this._queuedNegotiation = !0;
+    }), this._sendersAwaitingStable = [], this._queuedNegotiation ? (this._debug("flushing negotiation queue"), this._queuedNegotiation = !1, this._needsNegotiation()) : (this._debug("negotiated"), this.emit("negotiated"))), this._debug("signalingStateChange %s", this._pc.signalingState), this.emit("signalingStateChange", this._pc.signalingState));
+  }
+  _onIceCandidate(e) {
+    this.destroyed || (e.candidate && this.trickle ? this.emit("signal", {
+      type: "candidate",
+      candidate: {
+        candidate: e.candidate.candidate,
+        sdpMLineIndex: e.candidate.sdpMLineIndex,
+        sdpMid: e.candidate.sdpMid
+      }
+    }) : !e.candidate && !this._iceComplete && (this._iceComplete = !0, this.emit("_iceComplete")), e.candidate && this._startIceCompleteTimeout());
+  }
+  _onChannelMessage(e) {
+    if (this.destroyed) return;
+    let s = e.data;
+    s instanceof ArrayBuffer && (s = Jt.from(s)), this.push(s);
+  }
+  _onChannelBufferedAmountLow() {
+    if (this.destroyed || !this._cb) return;
+    this._debug("ending backpressure: bufferedAmount %d", this._channel.bufferedAmount);
+    const e = this._cb;
+    this._cb = null, e(null);
+  }
+  _onChannelOpen() {
+    this._connected || this.destroyed || (this._debug("on channel open"), this._channelReady = !0, this._maybeReady());
+  }
+  _onChannelClose() {
+    this.destroyed || (this._debug("on channel close"), this.destroy());
+  }
+  _onTrack(e) {
+    this.destroyed || e.streams.forEach((s) => {
+      this._debug("on track"), this.emit("track", e.track, s), this._remoteTracks.push({
+        track: e.track,
+        stream: s
+      }), !this._remoteStreams.some((i) => i.id === s.id) && (this._remoteStreams.push(s), Ce(() => {
+        this._debug("on stream"), this.emit("stream", s);
+      }));
+    });
+  }
+  _debug() {
+    const e = [].slice.call(arguments);
+    e[0] = "[" + this._id + "] " + e[0], Vt.apply(null, e);
+  }
+};
+_e.WEBRTC_SUPPORT = !!_t();
+_e.config = {
+  iceServers: [
+    {
+      urls: [
+        "stun:stun.l.google.com:19302",
+        "stun:global.stun.twilio.com:3478"
+      ]
+    }
+  ],
+  sdpSemantics: "unified-plan"
+};
+_e.channelConfig = {};
+var ss = _e;
+const je = /* @__PURE__ */ Lt(ss);
+var is = process.env.NODE_ENV === "production", ye = "Invariant failed";
+function ns(t, e) {
+  if (!t) {
+    if (is)
+      throw new Error(ye);
+    var s = typeof e == "function" ? e() : e, i = s ? "".concat(ye, ": ").concat(s) : ye;
+    throw new Error(i);
+  }
+}
+var K;
+(function(t) {
+  t[t.INVALID = 0] = "INVALID", t[t.CONNECTING = 1] = "CONNECTING", t[t.CONNECTED = 2] = "CONNECTED", t[t.CLOSED = 3] = "CLOSED";
+})(K || (K = {}));
+var rs = R;
+function R(t) {
+  if (t) return os(t);
+}
+function os(t) {
+  for (var e in R.prototype)
+    t[e] = R.prototype[e];
+  return t;
+}
+R.prototype.on = R.prototype.addEventListener = function(t, e) {
+  return this._callbacks = this._callbacks || {}, (this._callbacks[t] = this._callbacks[t] || []).push(e), this;
+};
+R.prototype.once = function(t, e) {
+  var s = this;
+  this._callbacks = this._callbacks || {};
+  function i() {
+    s.off(t, i), e.apply(this, arguments);
+  }
+  return i.fn = e, this.on(t, i), this;
+};
+R.prototype.off = R.prototype.removeListener = R.prototype.removeAllListeners = R.prototype.removeEventListener = function(t, e) {
+  if (this._callbacks = this._callbacks || {}, arguments.length == 0)
+    return this._callbacks = {}, this;
+  var s = this._callbacks[t];
+  if (!s) return this;
+  if (arguments.length == 1)
+    return delete this._callbacks[t], this;
+  for (var i, n = 0; n < s.length; n++)
+    if (i = s[n], i === e || i.fn === e) {
+      s.splice(n, 1);
+      break;
+    }
+  return this;
+};
+R.prototype.emit = function(t) {
+  this._callbacks = this._callbacks || {};
+  var e = [].slice.call(arguments, 1), s = this._callbacks[t];
+  if (s) {
+    s = s.slice(0);
+    for (var i = 0, n = s.length; i < n; ++i)
+      s[i].apply(this, e);
+  }
+  return this;
+};
+R.prototype.listeners = function(t) {
+  return this._callbacks = this._callbacks || {}, this._callbacks[t] || [];
+};
+R.prototype.hasListeners = function(t) {
+  return !!this.listeners(t).length;
+};
+var ft = rs;
+function te() {
+  ft.call(this);
+}
+te.prototype = new ft();
+var as = te;
+te.Stream = te;
+te.prototype.pipe = function(t, e) {
+  var s = this;
+  function i(h) {
+    t.writable && t.write(h) === !1 && s.pause && s.pause();
+  }
+  s.on("data", i);
+  function n() {
+    s.readable && s.resume && s.resume();
+  }
+  t.on("drain", n), !t._isStdio && (!e || e.end !== !1) && (s.on("end", o), s.on("close", c));
+  var r = !1;
+  function o() {
+    r || (r = !0, t.end());
+  }
+  function c() {
+    r || (r = !0, typeof t.destroy == "function" && t.destroy());
+  }
+  function _(h) {
+    if (d(), !this.hasListeners("error"))
+      throw h;
+  }
+  s.on("error", _), t.on("error", _);
+  function d() {
+    s.off("data", i), t.off("drain", n), s.off("end", o), s.off("close", c), s.off("error", _), t.off("error", _), s.off("end", d), s.off("close", d), t.off("end", d), t.off("close", d);
+  }
+  return s.on("end", d), s.on("close", d), t.on("end", d), t.on("close", d), t.emit("pipe", s), t;
+};
+var cs = Te, Ue = 128, hs = 127, ds = ~hs, ls = Math.pow(2, 31);
+function Te(t, e, s) {
+  if (Number.MAX_SAFE_INTEGER && t > Number.MAX_SAFE_INTEGER)
+    throw Te.bytes = 0, new RangeError("Could not encode varint");
+  e = e || [], s = s || 0;
+  for (var i = s; t >= ls; )
+    e[s++] = t & 255 | Ue, t /= 128;
+  for (; t & ds; )
+    e[s++] = t & 255 | Ue, t >>>= 7;
+  return e[s] = t | 0, Te.bytes = s - i + 1, e;
+}
+var _s = Fe, fs = 128, He = 127;
+function Fe(t, i) {
+  var s = 0, i = i || 0, n = 0, r = i, o, c = t.length;
+  do {
+    if (r >= c || n > 49)
+      throw Fe.bytes = 0, new RangeError("Could not decode varint");
+    o = t[r++], s += n < 28 ? (o & He) << n : (o & He) * Math.pow(2, n), n += 7;
+  } while (o >= fs);
+  return Fe.bytes = r - i, s;
+}
+var ps = Math.pow(2, 7), us = Math.pow(2, 14), gs = Math.pow(2, 21), ms = Math.pow(2, 28), Cs = Math.pow(2, 35), ws = Math.pow(2, 42), ys = Math.pow(2, 49), Ss = Math.pow(2, 56), bs = Math.pow(2, 63), vs = function(t) {
+  return t < ps ? 1 : t < us ? 2 : t < gs ? 3 : t < ms ? 4 : t < Cs ? 5 : t < ws ? 6 : t < ys ? 7 : t < Ss ? 8 : t < bs ? 9 : 10;
+}, M = {
+  encode: cs,
+  decode: _s,
+  encodingLength: vs
+}, V = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/control-extension.ts", Se = 1e4, Es = !1, Is = class {
+  constructor(t, e, s) {
+    this.opts = t, this.localPeerId = e, this.remotePeerId = s, this._ctx = new N({
+      onError: (i) => {
+        this._extensionContext.close(i);
+      }
+    }, {
+      F: V,
+      L: 30
+    }), this.onExtensionRegistered = new Tt();
+  }
+  async registerExtension(t) {
+    await this._rpc.rpc.Control.registerExtension({
+      name: t
+    });
+  }
+  async onOpen(t) {
+    this._extensionContext = t, this._rpc = Ft({
+      requested: {
+        Control: ce.getService("dxos.mesh.teleport.control.ControlService")
+      },
+      exposed: {
+        Control: ce.getService("dxos.mesh.teleport.control.ControlService")
+      },
+      handlers: {
+        Control: {
+          registerExtension: async (e) => {
+            this.onExtensionRegistered.call(e.name);
+          },
+          heartbeat: async (e) => ({
+            requestTimestamp: e.requestTimestamp
+          })
+        }
+      },
+      port: await t.createPort("rpc", {
+        contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
+      }),
+      timeout: this.opts.heartbeatTimeout
+    }), await this._rpc.open(), Ae(this._ctx, async () => {
+      const e = /* @__PURE__ */ new Date();
+      try {
+        const s = await nt(this._rpc.rpc.Control.heartbeat({
+          requestTimestamp: e
+        }), this.opts.heartbeatTimeout), i = Date.now();
+        s.requestTimestamp instanceof Date && i - s.requestTimestamp.getTime() > (Se < this.opts.heartbeatTimeout ? Se : this.opts.heartbeatTimeout / 2) && a.warn(`heartbeat RTT for Teleport > ${Se / 1e3}s`, {
+          rtt: i - s.requestTimestamp.getTime(),
+          localPeerId: this.localPeerId.truncate(),
+          remotePeerId: this.remotePeerId.truncate()
+        }, {
+          F: V,
+          L: 106,
+          S: this,
+          C: (n, r) => n(...r)
+        });
+      } catch (s) {
+        const i = Date.now();
+        if (s instanceof ht) {
+          a("ignoring RpcClosedError in heartbeat", void 0, {
+            F: V,
+            L: 125,
+            S: this,
+            C: (n, r) => n(...r)
+          }), this._extensionContext.close(s);
+          return;
+        }
+        s instanceof At ? (a("timeout waiting for heartbeat response", {
+          err: s,
+          delay: i - e.getTime()
+        }, {
+          F: V,
+          L: 130,
+          S: this,
+          C: (n, r) => n(...r)
+        }), this.opts.onTimeout(s)) : (a.info("other error waiting for heartbeat response", {
+          err: s,
+          delay: i - e.getTime()
+        }, {
+          F: V,
+          L: 133,
+          S: this,
+          C: (n, r) => n(...r)
+        }), this.opts.onTimeout(s));
+      }
+    }, this.opts.heartbeatInterval);
+  }
+  async onClose(t) {
+    await this._ctx.dispose(), await this._rpc.close();
+  }
+  async onAbort(t) {
+    await this._ctx.dispose(), await this._rpc.abort();
+  }
+}, ae = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/framer.ts", Q = 2, Ls = class {
+  constructor() {
+    this._messageCb = void 0, this._subscribeCb = void 0, this._buffer = void 0, this._sendCallbacks = [], this._bytesSent = 0, this._bytesReceived = 0, this._writable = !0, this.drain = new S(), this._stream = new se.Duplex({
+      objectMode: !1,
+      read: () => {
+        this._processResponseQueue();
+      },
+      write: (t, e, s) => {
+        f(!this._subscribeCb, "Internal Framer bug. Concurrent writes detected.", {
+          F: ae,
+          L: 40,
+          S: this,
+          A: [
+            "!this._subscribeCb",
+            "'Internal Framer bug. Concurrent writes detected.'"
+          ]
+        }), this._bytesReceived += t.length, this._buffer && this._buffer.length > 0 ? this._buffer = X.concat([
+          this._buffer,
+          t
+        ]) : this._buffer = t, this._messageCb ? (this._popFrames(), s()) : this._subscribeCb = () => {
+          this._popFrames(), this._subscribeCb = void 0, s();
+        };
+      }
+    }), this.port = {
+      send: (t) => new Promise((e) => {
+        const s = Ts(t);
+        this._bytesSent += s.length, this._writable = this._stream.push(s), this._writable ? e() : this._sendCallbacks.push(e);
+      }),
+      subscribe: (t) => {
+        var e;
+        return f(!this._messageCb, "Rpc port already has a message listener.", {
+          F: ae,
+          L: 79,
+          S: this,
+          A: [
+            "!this._messageCb",
+            "'Rpc port already has a message listener.'"
+          ]
+        }), this._messageCb = t, (e = this._subscribeCb) == null || e.call(this), () => {
+          this._messageCb = void 0;
+        };
+      }
+    };
+  }
+  get stream() {
+    return this._stream;
+  }
+  get bytesSent() {
+    return this._bytesSent;
+  }
+  get bytesReceived() {
+    return this._bytesReceived;
+  }
+  get writable() {
+    return this._writable;
+  }
+  _processResponseQueue() {
+    const t = this._sendCallbacks;
+    this._sendCallbacks = [], this._writable = !0, this.drain.emit(), t.forEach((e) => e());
+  }
+  /**
+  * Attempts to pop frames from the buffer and call the message callback.
+  */
+  _popFrames() {
+    let t = 0;
+    for (; t < this._buffer.length; ) {
+      const e = Rs(this._buffer, t);
+      if (!e)
+        break;
+      t += e.bytesConsumed, this._messageCb(e.payload);
+    }
+    t < this._buffer.length ? this._buffer = this._buffer.subarray(t) : this._buffer = void 0;
+  }
+  destroy() {
+    this._stream.readableLength > 0 && a("framer destroyed while there are still read bytes in the buffer.", void 0, {
+      F: ae,
+      L: 140,
+      S: this,
+      C: (t, e) => t(...e)
+    }), this._stream.writableLength > 0 && a.warn("framer destroyed while there are still write bytes in the buffer.", void 0, {
+      F: ae,
+      L: 143,
+      S: this,
+      C: (t, e) => t(...e)
+    }), this._stream.destroy();
+  }
+}, Rs = (t, e) => {
+  if (t.length < e + Q)
+    return;
+  const s = t.readUInt16BE(e), i = Q + s;
+  return t.length < e + i ? void 0 : {
+    payload: t.subarray(e + Q, e + i),
+    bytesConsumed: i
+  };
+}, Ts = (t) => {
+  const e = X.allocUnsafe(Q + t.length);
+  return e.writeUInt16BE(t.length, 0), e.set(t, Q), e;
+}, z = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/balancer.ts", Ge = 8192, Fs = class {
+  constructor(t) {
+    this._sysChannelId = t, this._lastCallerIndex = 0, this._channels = [], this._framer = new Ls(), this._sendBuffers = /* @__PURE__ */ new Map(), this._receiveBuffers = /* @__PURE__ */ new Map(), this._sending = !1, this.incomingData = new S(), this.stream = this._framer.stream, this._channels.push(t), this._framer.port.subscribe(this._processIncomingMessage.bind(this));
+  }
+  get bytesSent() {
+    return this._framer.bytesSent;
+  }
+  get bytesReceived() {
+    return this._framer.bytesReceived;
+  }
+  get buffersCount() {
+    return this._sendBuffers.size;
+  }
+  addChannel(t) {
+    this._channels.push(t);
+  }
+  pushData(t, e, s) {
+    this._enqueueChunk(t, e, s), this._sendChunks().catch((i) => a.catch(i, void 0, {
+      F: z,
+      L: 75,
+      S: this,
+      C: (n, r) => n(...r)
+    }));
+  }
+  destroy() {
+    this._sendBuffers.size !== 0 && a.info("destroying balancer with pending calls", void 0, {
+      F: z,
+      L: 80,
+      S: this,
+      C: (t, e) => t(...e)
+    }), this._sendBuffers.clear(), this._framer.destroy();
+  }
+  _processIncomingMessage(t) {
+    const { channelId: e, dataLength: s, chunk: i } = xs(t, (n) => !this._receiveBuffers.has(n));
+    if (!this._receiveBuffers.has(e))
+      i.length < s ? this._receiveBuffers.set(e, {
+        buffer: X.from(i),
+        msgLength: s
+      }) : this.incomingData.emit(i);
+    else {
+      const n = this._receiveBuffers.get(e);
+      if (n.buffer = X.concat([
+        n.buffer,
+        i
+      ]), n.buffer.length < n.msgLength)
+        return;
+      const r = n.buffer;
+      this._receiveBuffers.delete(e), this.incomingData.emit(r);
+    }
+  }
+  _getNextCallerId() {
+    if (this._sendBuffers.has(this._sysChannelId))
+      return this._sysChannelId;
+    const t = this._lastCallerIndex;
+    return this._lastCallerIndex = (this._lastCallerIndex + 1) % this._channels.length, this._channels[t];
+  }
+  _enqueueChunk(t, e, s) {
+    if (!this._channels.includes(s))
+      throw new Error(`Unknown channel ${s}`);
+    this._sendBuffers.has(s) || this._sendBuffers.set(s, []);
+    const i = this._sendBuffers.get(s), n = [];
+    for (let r = 0; r < t.length; r += Ge)
+      n.push(t.subarray(r, r + Ge));
+    n.forEach((r, o) => {
+      const c = As({
+        chunk: r,
+        channelId: s,
+        dataLength: o === 0 ? t.length : void 0
+      });
+      i.push({
+        msg: c,
+        trigger: o === n.length - 1 ? e : void 0
+      });
+    });
+  }
+  // get the next chunk or null if there are no chunks remaining
+  _getNextChunk() {
+    let t;
+    for (; this._sendBuffers.size > 0; ) {
+      const e = this._getNextCallerId(), s = this._sendBuffers.get(e);
+      if (s && (t = s.shift(), !!t))
+        return s.length === 0 && this._sendBuffers.delete(e), t;
+    }
+    return null;
+  }
+  async _sendChunks() {
+    var e, s;
+    if (this._sending)
+      return;
+    this._sending = !0;
+    let t;
+    for (t = this._getNextChunk(); t; ) {
+      this._framer.writable || (a("PAUSE for drain", void 0, {
+        F: z,
+        L: 179,
+        S: this,
+        C: (i, n) => i(...n)
+      }), await this._framer.drain.waitForCount(1), a("RESUME for drain", void 0, {
+        F: z,
+        L: 181,
+        S: this,
+        C: (i, n) => i(...n)
+      }));
+      try {
+        await this._framer.port.send(t.msg), (e = t.trigger) == null || e.wake();
+      } catch (i) {
+        a("Error sending chunk", {
+          err: i
+        }, {
+          F: z,
+          L: 187,
+          S: this,
+          C: (n, r) => n(...r)
+        }), (s = t.trigger) == null || s.throw(i);
+      }
+      t = this._getNextChunk();
+    }
+    f(this._sendBuffers.size === 0, "sendBuffers not empty", {
+      F: z,
+      L: 192,
+      S: this,
+      A: [
+        "this._sendBuffers.size === 0",
+        "'sendBuffers not empty'"
+      ]
+    }), this._sending = !1;
+  }
+}, As = ({ channelId: t, dataLength: e, chunk: s }) => {
+  const i = M.encodingLength(t), n = e ? M.encodingLength(e) : 0, r = X.allocUnsafe(i + n + s.length);
+  return M.encode(t, r), e && M.encode(e, r, i), r.set(s, i + n), r;
+}, xs = (t, e) => {
+  const s = M.decode(t);
+  let i, n = M.decode.bytes;
+  e(s) && (i = M.decode(t, n), n += M.decode.bytes);
+  const r = t.subarray(n);
+  return {
+    channelId: s,
+    dataLength: i,
+    chunk: r
+  };
+};
+function Ns(t, e, s, i) {
+  var n = arguments.length, r = n < 3 ? e : i === null ? i = Object.getOwnPropertyDescriptor(e, s) : i, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+    r = Reflect.decorate(t, e, s, i);
+  else
+    for (var c = t.length - 1; c >= 0; c--)
+      (o = t[c]) && (r = (n < 3 ? o(r) : n > 3 ? o(e, s, r) : o(e, s)) || r);
+  return n > 3 && r && Object.defineProperty(e, s, r), r;
+}
+var v = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/muxer.ts", ze = ce.getCodecForType("dxos.mesh.muxer.Command"), Os = 6e4, Ps = 5e3, Ds = 1e3, Ye = 1e6, Z = 0, ks = 3e3, pt = class {
+  constructor() {
+    this._balancer = new Fs(Z), this._channelsByLocalId = /* @__PURE__ */ new Map(), this._channelsByTag = /* @__PURE__ */ new Map(), this._ctx = new N(void 0, {
+      F: v,
+      L: 107
+    }), this._nextId = 1, this._closing = !1, this._destroying = !1, this._disposed = !1, this._lastStats = void 0, this._lastChannelStats = /* @__PURE__ */ new Map(), this.afterClosed = new S(), this.statsUpdated = new S(), this.stream = this._balancer.stream, this._balancer.incomingData.on(async (t) => {
+      await this._handleCommand(ze.decode(t));
+    });
+  }
+  setSessionId(t) {
+    this._sessionId = t;
+  }
+  get sessionIdString() {
+    return this._sessionId ? this._sessionId.truncate() : "none";
+  }
+  /**
+  * Creates a duplex Node.js-style stream.
+  * The remote peer is expected to call `createStream` with the same tag.
+  * The stream is immediately readable and writable.
+  * NOTE: The data will be buffered until the stream is opened remotely with the same tag (may cause a memory leak).
+  */
+  async createStream(t, e = {}) {
+    const s = this._getOrCreateStream({
+      tag: t,
+      contentType: e.contentType
+    });
+    f(!s.push, `Channel already open: ${t}`, {
+      F: v,
+      L: 151,
+      S: this,
+      A: [
+        "!channel.push",
+        "`Channel already open: ${tag}`"
+      ]
+    });
+    const i = new se.Duplex({
+      write: (n, r, o) => {
+        this._sendData(s, n).then(() => o()).catch(o);
+      },
+      read: () => {
+      }
+    });
+    s.push = (n) => {
+      s.stats.bytesReceived += n.length, i.push(n);
+    }, s.destroy = (n) => {
+      n && i.listeners("error").length > 0 ? i.destroy(n) : i.destroy();
+    };
+    try {
+      await this._sendCommand({
+        openChannel: {
+          id: s.id,
+          tag: s.tag,
+          contentType: s.contentType
+        }
+      }, Z);
+    } catch (n) {
+      throw this._destroyChannel(s, n), n;
+    }
+    return i;
+  }
+  /**
+  * Creates an RPC port.
+  * The remote peer is expected to call `createPort` with the same tag.
+  * The port is immediately usable.
+  * NOTE: The data will be buffered until the stream is opened remotely with the same tag (may cause a memory leak).
+  */
+  async createPort(t, e = {}) {
+    const s = this._getOrCreateStream({
+      tag: t,
+      contentType: e.contentType
+    });
+    f(!s.push, `Channel already open: ${t}`, {
+      F: v,
+      L: 211,
+      S: this,
+      A: [
+        "!channel.push",
+        "`Channel already open: ${tag}`"
+      ]
+    });
+    let i = [], n;
+    s.push = (o) => {
+      s.stats.bytesReceived += o.length, n ? n(o) : i.push(o);
+    };
+    const r = {
+      send: async (o, c) => {
+        await this._sendData(s, o, c);
+      },
+      subscribe: (o) => {
+        f(!n, "Only one subscriber is allowed", {
+          F: v,
+          L: 233,
+          S: this,
+          A: [
+            "!callback",
+            "'Only one subscriber is allowed'"
+          ]
+        }), n = o;
+        for (const c of i)
+          o(c);
+        i = [];
+      }
+    };
+    try {
+      await this._sendCommand({
+        openChannel: {
+          id: s.id,
+          tag: s.tag,
+          contentType: s.contentType
+        }
+      }, Z);
+    } catch (o) {
+      throw this._destroyChannel(s, o), o;
+    }
+    return r;
+  }
+  // initiate graceful close
+  async close(t) {
+    if (this._destroying) {
+      a("already destroying, ignoring graceful close request", void 0, {
+        F: v,
+        L: 266,
+        S: this,
+        C: (e, s) => e(...s)
+      });
+      return;
+    }
+    if (this._closing) {
+      a("already closing, ignoring graceful close request", void 0, {
+        F: v,
+        L: 270,
+        S: this,
+        C: (e, s) => e(...s)
+      });
+      return;
+    }
+    this._closing = !0, await this._sendCommand({
+      close: {
+        error: t == null ? void 0 : t.message
+      }
+    }, Z, Ps).catch(async (e) => {
+      a("error sending close command", {
+        err: e
+      }, {
+        F: v,
+        L: 285,
+        S: this,
+        C: (s, i) => s(...i)
+      }), await this._dispose(e);
+    }), await nt(this._dispose(t), ks, new le("gracefully closing muxer"));
+  }
+  // force close without confirmation
+  async destroy(t) {
+    if (this._destroying) {
+      a("already destroying, ignoring destroy request", void 0, {
+        F: v,
+        L: 298,
+        S: this,
+        C: (e, s) => e(...s)
+      });
+      return;
+    }
+    this._destroying = !0, this._ctx.dispose(), this._closing ? (a("destroy cancelling graceful close", void 0, {
+      F: v,
+      L: 304,
+      S: this,
+      C: (e, s) => e(...s)
+    }), this._closing = !1) : await this._sendCommand({
+      close: {
+        error: t == null ? void 0 : t.message
+      }
+    }, Z).catch(async (e) => {
+      a("error sending courtesy close command", {
+        err: e
+      }, {
+        F: v,
+        L: 317,
+        S: this,
+        C: (s, i) => s(...i)
+      });
+    }), this._dispose(t).catch((e) => {
+      a("error disposing after destroy", {
+        err: e
+      }, {
+        F: v,
+        L: 322,
+        S: this,
+        C: (s, i) => s(...i)
+      });
+    });
+  }
+  // complete the termination, graceful or otherwise
+  async _dispose(t) {
+    var e;
+    if (this._disposed) {
+      a("already destroyed, ignoring dispose request", void 0, {
+        F: v,
+        L: 330,
+        S: this,
+        C: (s, i) => s(...i)
+      });
+      return;
+    }
+    this._ctx.dispose(), await this._balancer.destroy();
+    for (const s of this._channelsByTag.values())
+      (e = s.destroy) == null || e.call(s, t);
+    this._disposed = !0, await this._emitStats(), this.afterClosed.emit(t), this._channelsByLocalId.clear(), this._channelsByTag.clear();
+  }
+  async _handleCommand(t) {
+    if (this._disposed) {
+      a.warn("Received command after disposed", {
+        cmd: t
+      }, {
+        F: v,
+        L: 353,
+        S: this,
+        C: (e, s) => e(...s)
+      });
+      return;
+    }
+    if (t.close) {
+      this._closing ? a("received close from peer, already closing", void 0, {
+        F: v,
+        L: 362,
+        S: this,
+        C: (e, s) => e(...s)
+      }) : (a("received peer close, initiating my own graceful close", void 0, {
+        F: v,
+        L: 359,
+        S: this,
+        C: (e, s) => e(...s)
+      }), await this.close(new Error("received peer close")));
+      return;
+    }
+    if (t.openChannel) {
+      const e = this._getOrCreateStream({
+        tag: t.openChannel.tag,
+        contentType: t.openChannel.contentType
+      });
+      e.remoteId = t.openChannel.id;
+      for (const s of e.buffer)
+        await this._sendCommand({
+          data: {
+            channelId: e.remoteId,
+            data: s
+          }
+        }, e.id);
+      e.buffer = [];
+    } else if (t.data) {
+      const e = this._channelsByLocalId.get(t.data.channelId) ?? rt();
+      if (!e.push) {
+        a.warn("Received data for channel before it was opened", {
+          tag: e.tag
+        }, {
+          F: v,
+          L: 391,
+          S: this,
+          C: (s, i) => s(...i)
+        });
+        return;
+      }
+      e.push(t.data.data);
+    }
+  }
+  async _sendCommand(t, e = -1, s = Os) {
+    if (!this._disposed)
+      try {
+        const i = new ee();
+        this._balancer.pushData(ze.encode(t), i, e), await i.wait({
+          timeout: s
+        });
+      } catch (i) {
+        await this.destroy(i);
+      }
+  }
+  _getOrCreateStream(t) {
+    this._channelsByTag.size === 0 && Ae(this._ctx, async () => this._emitStats(), Ds);
+    let e = this._channelsByTag.get(t.tag);
+    return e || (e = {
+      id: this._nextId++,
+      remoteId: null,
+      tag: t.tag,
+      contentType: t.contentType,
+      buffer: [],
+      push: null,
+      destroy: null,
+      stats: {
+        bytesSent: 0,
+        bytesReceived: 0
+      }
+    }, this._channelsByTag.set(e.tag, e), this._channelsByLocalId.set(e.id, e), this._balancer.addChannel(e.id)), e;
+  }
+  async _sendData(t, e, s) {
+    if (e.length > Ye && a.warn("frame size exceeds maximum safe value", {
+      size: e.length,
+      threshold: Ye
+    }, {
+      F: v,
+      L: 441,
+      S: this,
+      C: (i, n) => i(...n)
+    }), t.stats.bytesSent += e.length, t.remoteId === null) {
+      t.buffer.push(e);
+      return;
+    }
+    await this._sendCommand({
+      data: {
+        channelId: t.remoteId,
+        data: e
+      }
+    }, t.id, s);
+  }
+  _destroyChannel(t, e) {
+    t.destroy && t.destroy(e), this._channelsByLocalId.delete(t.id), this._channelsByTag.delete(t.tag);
+  }
+  async _emitStats() {
+    if (this._disposed || this._destroying) {
+      if (!this._lastStats)
+        return;
+      const r = this._lastStats;
+      this._lastStats = void 0, r.readBufferSize = 0, r.writeBufferSize = 0;
+      for (const o of r.channels)
+        o.writeBufferSize = 0;
+      this.statsUpdated.emit(r), this._lastChannelStats.clear();
+      return;
+    }
+    const t = this._balancer.bytesSent, e = this._balancer.bytesReceived, s = Date.now(), i = this._lastStats ? (s - this._lastStats.timestamp) / 1e3 : 0, n = (r, o) => o ? {
+      bytesSentRate: i ? (r.bytesSent - o.bytesSent) / i : void 0,
+      bytesReceivedRate: i ? (r.bytesReceived - o.bytesReceived) / i : void 0
+    } : {};
+    this._lastStats = {
+      timestamp: s,
+      channels: Array.from(this._channelsByTag.values()).map((r) => {
+        const o = {
+          id: r.id,
+          tag: r.tag,
+          contentType: r.contentType,
+          writeBufferSize: r.buffer.length,
+          bytesSent: r.stats.bytesSent,
+          bytesReceived: r.stats.bytesReceived,
+          ...n(r.stats, this._lastChannelStats.get(r.id))
+        };
+        return this._lastChannelStats.set(r.id, o), o;
+      }),
+      bytesSent: t,
+      bytesReceived: e,
+      ...n({
+        bytesSent: t,
+        bytesReceived: e
+      }, this._lastStats),
+      readBufferSize: this._balancer.stream.readableLength,
+      writeBufferSize: this._balancer.stream.writableLength
+    }, this.statsUpdated.emit(this._lastStats);
+  }
+};
+Ns([
+  q
+], pt.prototype, "sessionIdString", null);
+function Ne(t, e, s, i) {
+  var n = arguments.length, r = n < 3 ? e : i === null ? i = Object.getOwnPropertyDescriptor(e, s) : i, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+    r = Reflect.decorate(t, e, s, i);
+  else
+    for (var c = t.length - 1; c >= 0; c--)
+      (o = t[c]) && (r = (n < 3 ? o(r) : n > 3 ? o(e, s, r) : o(e, s)) || r);
+  return n > 3 && r && Object.defineProperty(e, s, r), r;
+}
+var y = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts", Ms = 1e4, Bs = 6e4, Oe = class {
+  constructor({ initiator: t, localPeerId: e, remotePeerId: s, ...i }) {
+    this._ctx = new N({
+      onError: (n) => {
+        this.destroy(n).catch(() => {
+          a.error("Error during destroy", n, {
+            F: y,
+            L: 41,
+            S: this,
+            C: (r, o) => r(...o)
+          });
+        });
+      }
+    }, {
+      F: y,
+      L: 38
+    }), this._muxer = new pt(), this._extensions = /* @__PURE__ */ new Map(), this._remoteExtensions = /* @__PURE__ */ new Set(), this._open = !1, this._destroying = !1, this._aborting = !1, f(typeof t == "boolean", void 0, {
+      F: y,
+      L: 62,
+      S: this,
+      A: [
+        "typeof initiator === 'boolean'",
+        ""
+      ]
+    }), f(m.isPublicKey(e), void 0, {
+      F: y,
+      L: 63,
+      S: this,
+      A: [
+        "PublicKey.isPublicKey(localPeerId)",
+        ""
+      ]
+    }), f(m.isPublicKey(s), void 0, {
+      F: y,
+      L: 64,
+      S: this,
+      A: [
+        "PublicKey.isPublicKey(remotePeerId)",
+        ""
+      ]
+    }), this.initiator = t, this.localPeerId = e, this.remotePeerId = s, this._control = new Is({
+      heartbeatInterval: i.controlHeartbeatInterval ?? Ms,
+      heartbeatTimeout: i.controlHeartbeatTimeout ?? Bs,
+      onTimeout: () => {
+        this._destroying || this._aborting || (a.info("abort teleport due to onTimeout in ControlExtension", void 0, {
+          F: y,
+          L: 77,
+          S: this,
+          C: (n, r) => n(...r)
+        }), this.abort(new le("control extension")).catch((n) => a.catch(n, void 0, {
+          F: y,
+          L: 78,
+          S: this,
+          C: (r, o) => r(...o)
+        })));
+      }
+    }, this.localPeerId, this.remotePeerId), this._control.onExtensionRegistered.set(async (n) => {
+      if (a("remote extension", {
+        name: n
+      }, {
+        F: y,
+        L: 86,
+        S: this,
+        C: (r, o) => r(...o)
+      }), f(!this._remoteExtensions.has(n), "Remote extension already exists", {
+        F: y,
+        L: 87,
+        S: this,
+        A: [
+          "!this._remoteExtensions.has(name)",
+          "'Remote extension already exists'"
+        ]
+      }), this._remoteExtensions.add(n), this._extensions.has(n))
+        try {
+          await this._openExtension(n);
+        } catch (r) {
+          await this.destroy(r);
+        }
+    }), this._muxer.stream.on("close", async () => {
+      if (this._destroying || this._aborting) {
+        a("destroy teleport due to muxer stream close, skipping due to already destroying/aborting", void 0, {
+          F: y,
+          L: 103,
+          S: this,
+          C: (n, r) => n(...r)
+        });
+        return;
+      }
+      await this.destroy();
+    }), this._muxer.stream.on("error", async (n) => {
+      await this.destroy(n);
+    }), this._muxer.statsUpdated.on((n) => {
+      a.trace("dxos.mesh.teleport.stats", {
+        localPeerId: e,
+        remotePeerId: s,
+        bytesSent: n.bytesSent,
+        bytesSentRate: n.bytesSentRate,
+        bytesReceived: n.bytesReceived,
+        bytesReceivedRate: n.bytesReceivedRate,
+        channels: n.channels
+      }, {
+        F: y,
+        L: 116,
+        S: this,
+        C: (r, o) => r(...o)
+      });
+    });
+  }
+  get isOpen() {
+    return this._open;
+  }
+  get sessionIdString() {
+    return this._sessionId ? this._sessionId.truncate() : "none";
+  }
+  get stream() {
+    return this._muxer.stream;
+  }
+  get stats() {
+    return this._muxer.statsUpdated;
+  }
+  /**
+  * Blocks until the handshake is complete.
+  */
+  async open(t = m.random()) {
+    this._sessionId = t, a("open", void 0, {
+      F: y,
+      L: 150,
+      S: this,
+      C: (e, s) => e(...s)
+    }), this._setExtension("dxos.mesh.teleport.control", this._control), await this._openExtension("dxos.mesh.teleport.control"), this._open = !0, this._muxer.setSessionId(t);
+  }
+  async close(t) {
+    await this.destroy(t);
+  }
+  async abort(t) {
+    if (!(this._aborting || this._destroying) && (this._aborting = !0, this._open = !1, !this._ctx.disposed)) {
+      await this._ctx.dispose();
+      for (const e of this._extensions.values())
+        try {
+          await e.onAbort(t);
+        } catch (s) {
+          a.catch(s, void 0, {
+            F: y,
+            L: 180,
+            S: this,
+            C: (i, n) => i(...n)
+          });
+        }
+      await this._muxer.destroy(t);
+    }
+  }
+  async destroy(t) {
+    if (!(this._destroying || this._aborting) && (a("destroying teleport...", {
+      extensionsCount: this._extensions.size
+    }, {
+      F: y,
+      L: 193,
+      S: this,
+      C: (e, s) => e(...s)
+    }), this._destroying = !0, this._open = !1, !this._ctx.disposed)) {
+      await this._ctx.dispose();
+      for (const e of this._extensions.values())
+        try {
+          a("destroying extension", {
+            name: e.constructor.name
+          }, {
+            F: y,
+            L: 205,
+            S: this,
+            C: (s, i) => s(...i)
+          }), await e.onClose(t), a("destroyed extension", {
+            name: e.constructor.name
+          }, {
+            F: y,
+            L: 207,
+            S: this,
+            C: (s, i) => s(...i)
+          });
+        } catch (s) {
+          a.catch(s, void 0, {
+            F: y,
+            L: 209,
+            S: this,
+            C: (i, n) => i(...n)
+          });
+        }
+      await this._muxer.close(), a("teleport destroyed", void 0, {
+        F: y,
+        L: 214,
+        S: this,
+        C: (e, s) => e(...s)
+      });
+    }
+  }
+  addExtension(t, e) {
+    if (!this._open)
+      throw new Error("Not open");
+    a("addExtension", {
+      name: t
+    }, {
+      F: y,
+      L: 222,
+      S: this,
+      C: (s, i) => s(...i)
+    }), this._setExtension(t, e), W(this._ctx, async () => {
+      try {
+        await this._control.registerExtension(t);
+      } catch (s) {
+        if (s instanceof ht)
+          return;
+        throw s;
+      }
+    }), this._remoteExtensions.has(t) && W(this._ctx, async () => {
+      await this._openExtension(t);
+    });
+  }
+  _setExtension(t, e) {
+    f(!t.includes("/"), "Invalid extension name", {
+      F: y,
+      L: 246,
+      S: this,
+      A: [
+        "!extensionName.includes('/')",
+        "'Invalid extension name'"
+      ]
+    }), f(!this._extensions.has(t), "Extension already exists", {
+      F: y,
+      L: 247,
+      S: this,
+      A: [
+        "!this._extensions.has(extensionName)",
+        "'Extension already exists'"
+      ]
+    }), this._extensions.set(t, e);
+  }
+  async _openExtension(t) {
+    a("open extension", {
+      extensionName: t
+    }, {
+      F: y,
+      L: 252,
+      S: this,
+      C: (i, n) => i(...n)
+    });
+    const e = this._extensions.get(t) ?? rt(), s = {
+      initiator: this.initiator,
+      localPeerId: this.localPeerId,
+      remotePeerId: this.remotePeerId,
+      createPort: async (i, n) => (f(!i.includes("/"), "Invalid channel name", {
+        F: y,
+        L: 260,
+        S: this,
+        A: [
+          "!channelName.includes('/')",
+          "'Invalid channel name'"
+        ]
+      }), this._muxer.createPort(`${t}/${i}`, n)),
+      createStream: async (i, n) => (f(!i.includes("/"), "Invalid channel name", {
+        F: y,
+        L: 264,
+        S: this,
+        A: [
+          "!channelName.includes('/')",
+          "'Invalid channel name'"
+        ]
+      }), this._muxer.createStream(`${t}/${i}`, n)),
+      close: (i) => {
+        Rt(this._ctx, async () => {
+          await this.close(i);
+        });
+      }
+    };
+    await e.onOpen(s), a("extension opened", {
+      extensionName: t
+    }, {
+      F: y,
+      L: 275,
+      S: this,
+      C: (i, n) => i(...n)
+    });
+  }
+};
+Ne([
+  q
+], Oe.prototype, "sessionIdString", null);
+Ne([
+  F
+], Oe.prototype, "abort", null);
+Ne([
+  F
+], Oe.prototype, "destroy", null);
+var $s = /* @__PURE__ */ ((t) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(t, {
+  get: (e, s) => (typeof require < "u" ? require : e)[s]
+}) : t)(function(t) {
+  if (typeof require < "u")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + t + '" is not supported');
+});
+function Pe(t, e, s, i) {
+  var n = arguments.length, r = n < 3 ? e : i === null ? i = Object.getOwnPropertyDescriptor(e, s) : i, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+    r = Reflect.decorate(t, e, s, i);
+  else
+    for (var c = t.length - 1; c >= 0; c--)
+      (o = t[c]) && (r = (n < 3 ? o(r) : n > 3 ? o(e, s, r) : o(e, s)) || r);
+  return n > 3 && r && Object.defineProperty(e, s, r), r;
+}
+var p = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts", qs = 10, be = 1e4, js = 5e3, Us = 300, P;
+(function(t) {
+  t.CREATED = "CREATED", t.INITIAL = "INITIAL", t.CONNECTING = "CONNECTING", t.CONNECTED = "CONNECTED", t.CLOSING = "CLOSING", t.CLOSED = "CLOSED", t.ABORTING = "ABORTING", t.ABORTED = "ABORTED";
+})(P || (P = {}));
+var fe = class {
+  constructor(t, e, s, i, n, r, o, c, _) {
+    this.topic = t, this.ownId = e, this.remoteId = s, this.sessionId = i, this.initiator = n, this._signalMessaging = r, this._protocol = o, this._transportFactory = c, this._callbacks = _, this._ctx = new N(void 0, {
+      F: p,
+      L: 100
+    }), this.connectedTimeoutContext = new N(void 0, {
+      F: p,
+      L: 101
+    }), this._protocolClosed = new ee(), this._transportClosed = new ee(), this._state = "CREATED", this._incomingSignalBuffer = [], this._outgoingSignalBuffer = [], this.stateChanged = new S(), this.errors = new ie(), this._instanceId = m.random().toHex(), this.transportStats = new S(), this._signalSendTask = new at(this._ctx, async () => {
+      await this._flushSignalBuffer();
+    }), this._signallingDelay = qs, a.trace("dxos.mesh.connection.construct", {
+      sessionId: this.sessionId,
+      topic: this.topic,
+      localPeerId: this.ownId,
+      remotePeerId: this.remoteId,
+      initiator: this.initiator
+    }, {
+      F: p,
+      L: 137,
+      S: this,
+      C: (d, h) => d(...h)
+    });
+  }
+  get sessionIdString() {
+    return this.sessionId.truncate();
+  }
+  get state() {
+    return this._state;
+  }
+  get transport() {
+    return this._transport;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  /**
+  * Create an underlying transport and prepares it for the connection.
+  */
+  async openConnection() {
+    f(this._state === "INITIAL", "Invalid state.", {
+      F: p,
+      L: 167,
+      S: this,
+      A: [
+        "this._state === ConnectionState.INITIAL",
+        "'Invalid state.'"
+      ]
+    }), a.trace("dxos.mesh.connection.open-connection", $.begin({
+      id: this._instanceId
+    }), {
+      F: p,
+      L: 168,
+      S: this,
+      C: (t, e) => t(...e)
+    }), a.trace("dxos.mesh.connection.open", {
+      sessionId: this.sessionId,
+      topic: this.topic,
+      localPeerId: this.ownId,
+      remotePeerId: this.remoteId,
+      initiator: this.initiator
+    }, {
+      F: p,
+      L: 169,
+      S: this,
+      C: (t, e) => t(...e)
+    }), this._changeState("CONNECTING"), this._protocol.open(this.sessionId).catch((t) => {
+      this.errors.raise(t);
+    }), this._protocol.stream.on("close", () => {
+      a("protocol stream closed", void 0, {
+        F: p,
+        L: 186,
+        S: this,
+        C: (t, e) => t(...e)
+      }), this._protocolClosed.wake(), this.close(new lt("protocol stream closed")).catch((t) => this.errors.raise(t));
+    }), W(this.connectedTimeoutContext, async () => {
+      a.info(`timeout waiting ${be / 1e3}s for transport to connect, aborting`, void 0, {
+        F: p,
+        L: 194,
+        S: this,
+        C: (t, e) => t(...e)
+      }), await this.abort(new le(`${be / 1e3}s for transport to connect`)).catch((t) => this.errors.raise(t));
+    }, be), f(!this._transport, void 0, {
+      F: p,
+      L: 202,
+      S: this,
+      A: [
+        "!this._transport",
+        ""
+      ]
+    }), this._transport = this._transportFactory.createTransport({
+      initiator: this.initiator,
+      stream: this._protocol.stream,
+      sendSignal: async (t) => this._sendSignal(t),
+      sessionId: this.sessionId
+    }), await this._transport.open(), this._transport.connected.once(async () => {
+      var t, e;
+      this._changeState("CONNECTED"), await this.connectedTimeoutContext.dispose(), (e = (t = this._callbacks) == null ? void 0 : t.onConnected) == null || e.call(t), Ae(this._ctx, async () => this._emitTransportStats(), js);
+    }), this._transport.closed.once(() => {
+      this._transport = void 0, this._transportClosed.wake(), a("abort triggered by transport close", void 0, {
+        F: p,
+        L: 223,
+        S: this,
+        C: (t, e) => t(...e)
+      }), this.abort().catch((t) => this.errors.raise(t));
+    }), this._transport.errors.handle(async (t) => {
+      a("transport error:", {
+        err: t
+      }, {
+        F: p,
+        L: 228,
+        S: this,
+        C: (e, s) => e(...s)
+      }), this.closeReason || (this.closeReason = t == null ? void 0 : t.message), t instanceof dt ? (a.info("aborting due to transport ConnectionResetError", void 0, {
+        F: p,
+        L: 235,
+        S: this,
+        C: (e, s) => e(...s)
+      }), this.abort().catch((e) => this.errors.raise(e))) : t instanceof he ? (a.info("aborting due to transport ConnectivityError", void 0, {
+        F: p,
+        L: 238,
+        S: this,
+        C: (e, s) => e(...s)
+      }), this.abort().catch((e) => this.errors.raise(e))) : t instanceof Ee && a.warn("unsure what to do with UnknownProtocolError, will keep on truckin", {
+        err: t
+      }, {
+        F: p,
+        L: 241,
+        S: this,
+        C: (e, s) => e(...s)
+      }), this._state !== "CLOSED" && this._state !== "CLOSING" && (await this.connectedTimeoutContext.dispose(), this.errors.raise(t));
+    });
+    for (const t of this._incomingSignalBuffer)
+      this._transport.onSignal(t);
+    this._incomingSignalBuffer = [], a.trace("dxos.mesh.connection.open-connection", $.end({
+      id: this._instanceId
+    }), {
+      F: p,
+      L: 257,
+      S: this,
+      C: (t, e) => t(...e)
+    });
+  }
+  async abort(t) {
+    var e, s;
+    if (a("aborting...", {
+      err: t
+    }, {
+      F: p,
+      L: 264,
+      S: this,
+      C: (i, n) => i(...n)
+    }), this._state === "CLOSED" || this._state === "ABORTED") {
+      a(`abort ignored: already ${this._state}`, this.closeReason, {
+        F: p,
+        L: 266,
+        S: this,
+        C: (i, n) => i(...n)
+      });
+      return;
+    }
+    await this.connectedTimeoutContext.dispose(), this._changeState("ABORTING"), this.closeReason || (this.closeReason = t == null ? void 0 : t.message), await this._ctx.dispose();
+    try {
+      await this._closeProtocol({
+        abort: !0
+      });
+    } catch (i) {
+      a.catch(i, void 0, {
+        F: p,
+        L: 282,
+        S: this,
+        C: (n, r) => n(...r)
+      });
+    }
+    try {
+      await this._closeTransport();
+    } catch (i) {
+      a.catch(i, void 0, {
+        F: p,
+        L: 289,
+        S: this,
+        C: (n, r) => n(...r)
+      });
+    }
+    try {
+      (s = (e = this._callbacks) == null ? void 0 : e.onClosed) == null || s.call(e, t);
+    } catch (i) {
+      a.catch(i, void 0, {
+        F: p,
+        L: 295,
+        S: this,
+        C: (n, r) => n(...r)
+      });
+    }
+    this._changeState("ABORTED");
+  }
+  async close(t) {
+    var i, n;
+    if (this.closeReason ? this.closeReason += `; ${t == null ? void 0 : t.message}` : this.closeReason = t == null ? void 0 : t.message, this._state === "CLOSED" || this._state === "ABORTING" || this._state === "ABORTED")
+      return;
+    const e = this._state;
+    this._changeState("CLOSING"), await this.connectedTimeoutContext.dispose(), await this._ctx.dispose(), a("closing...", {
+      peerId: this.ownId
+    }, {
+      F: p,
+      L: 320,
+      S: this,
+      C: (r, o) => r(...o)
+    });
+    let s = !1;
+    e !== "CONNECTED" && (a(`graceful close requested when we were in ${e} state? aborting`, void 0, {
+      F: p,
+      L: 324,
+      S: this,
+      C: (r, o) => r(...o)
+    }), s = !0);
+    try {
+      await this._closeProtocol({
+        abort: s
+      });
+    } catch (r) {
+      a.catch(r, void 0, {
+        F: p,
+        L: 330,
+        S: this,
+        C: (o, c) => o(...c)
+      });
+    }
+    try {
+      await this._closeTransport();
+    } catch (r) {
+      a.catch(r, void 0, {
+        F: p,
+        L: 336,
+        S: this,
+        C: (o, c) => o(...c)
+      });
+    }
+    a("closed", {
+      peerId: this.ownId
+    }, {
+      F: p,
+      L: 339,
+      S: this,
+      C: (r, o) => r(...o)
+    }), this._changeState("CLOSED"), (n = (i = this._callbacks) == null ? void 0 : i.onClosed) == null || n.call(i, t);
+  }
+  async _closeProtocol(t) {
+    a("closing protocol", t, {
+      F: p,
+      L: 345,
+      S: this,
+      C: (e, s) => e(...s)
+    }), await Promise.race([
+      t != null && t.abort ? this._protocol.abort() : this._protocol.close(),
+      this._protocolClosed.wait()
+    ]), a("protocol closed", t, {
+      F: p,
+      L: 347,
+      S: this,
+      C: (e, s) => e(...s)
+    });
+  }
+  async _closeTransport() {
+    var t;
+    a("closing transport", void 0, {
+      F: p,
+      L: 351,
+      S: this,
+      C: (e, s) => e(...s)
+    }), await Promise.race([
+      (t = this._transport) == null ? void 0 : t.close(),
+      this._transportClosed.wait()
+    ]), a("transport closed", void 0, {
+      F: p,
+      L: 353,
+      S: this,
+      C: (e, s) => e(...s)
+    });
+  }
+  _sendSignal(t) {
+    this._outgoingSignalBuffer.push(t), this._signalSendTask.schedule();
+  }
+  async _flushSignalBuffer() {
+    var t;
+    if (this._outgoingSignalBuffer.length !== 0)
+      try {
+        await Nt(this._ctx, ct(this._signallingDelay)), this._signallingDelay = Math.min(this._signallingDelay * 2, Us);
+        const e = [
+          ...this._outgoingSignalBuffer
+        ];
+        this._outgoingSignalBuffer.length = 0, await this._signalMessaging.signal({
+          author: this.ownId,
+          recipient: this.remoteId,
+          sessionId: this.sessionId,
+          topic: this.topic,
+          data: {
+            signalBatch: {
+              signals: e
+            }
+          }
+        });
+      } catch (e) {
+        if (e instanceof xe || e instanceof Error && ((t = e.message) != null && t.includes("CANCELLED")))
+          return;
+        a.info("signal message failed to deliver", {
+          err: e
+        }, {
+          F: p,
+          L: 389,
+          S: this,
+          C: (s, i) => s(...i)
+        }), await this.close(new he("signal message failed to deliver", e));
+      }
+  }
+  /**
+  * Receive a signal from the remote peer.
+  */
+  async signal(t) {
+    var s, i;
+    if (f(t.sessionId, void 0, {
+      F: p,
+      L: 398,
+      S: this,
+      A: [
+        "msg.sessionId",
+        ""
+      ]
+    }), !t.sessionId.equals(this.sessionId)) {
+      a("dropping signal for incorrect session id", void 0, {
+        F: p,
+        L: 400,
+        S: this,
+        C: (n, r) => n(...r)
+      });
+      return;
+    }
+    f(t.data.signal || t.data.signalBatch, void 0, {
+      F: p,
+      L: 403,
+      S: this,
+      A: [
+        "msg.data.signal || msg.data.signalBatch",
+        ""
+      ]
+    }), f((s = t.author) == null ? void 0 : s.equals(this.remoteId), void 0, {
+      F: p,
+      L: 404,
+      S: this,
+      A: [
+        "msg.author?.equals(this.remoteId)",
+        ""
+      ]
+    }), f((i = t.recipient) == null ? void 0 : i.equals(this.ownId), void 0, {
+      F: p,
+      L: 405,
+      S: this,
+      A: [
+        "msg.recipient?.equals(this.ownId)",
+        ""
+      ]
+    });
+    const e = t.data.signalBatch ? t.data.signalBatch.signals ?? [] : [
+      t.data.signal
+    ];
+    for (const n of e)
+      n && ([
+        "CREATED",
+        "INITIAL"
+      ].includes(this.state) ? (a("buffered signal", {
+        peerId: this.ownId,
+        remoteId: this.remoteId,
+        msg: t.data
+      }, {
+        F: p,
+        L: 414,
+        S: this,
+        C: (r, o) => r(...o)
+      }), this._incomingSignalBuffer.push(n)) : (f(this._transport, "Connection not ready to accept signals.", {
+        F: p,
+        L: 417,
+        S: this,
+        A: [
+          "this._transport",
+          "'Connection not ready to accept signals.'"
+        ]
+      }), a("received signal", {
+        peerId: this.ownId,
+        remoteId: this.remoteId,
+        msg: t.data
+      }, {
+        F: p,
+        L: 418,
+        S: this,
+        C: (r, o) => r(...o)
+      }), await this._transport.onSignal(n)));
+  }
+  initiate() {
+    this._changeState("INITIAL");
+  }
+  _changeState(t) {
+    a("stateChanged", {
+      from: this._state,
+      to: t,
+      peerId: this.ownId
+    }, {
+      F: p,
+      L: 429,
+      S: this,
+      C: (e, s) => e(...s)
+    }), f(t !== this._state, "Already in this state.", {
+      F: p,
+      L: 430,
+      S: this,
+      A: [
+        "state !== this._state",
+        "'Already in this state.'"
+      ]
+    }), this._state = t, this.stateChanged.emit(t);
+  }
+  async _emitTransportStats() {
+    var e;
+    const t = await ((e = this.transport) == null ? void 0 : e.getStats());
+    t && this.transportStats.emit(t);
+  }
+};
+Pe([
+  q
+], fe.prototype, "sessionIdString", null);
+Pe([
+  F
+], fe.prototype, "abort", null);
+Pe([
+  F
+], fe.prototype, "close", null);
+var E = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/signal/swarm-messenger.ts", Ke = ce.getCodecForType("dxos.mesh.swarm.SwarmMessage"), Hs = class {
+  constructor({ sendMessage: t, onSignal: e, onOffer: s, topic: i }) {
+    this._ctx = new N(void 0, {
+      F: E,
+      L: 33
+    }), this._offerRecords = new O((n) => n.toHex()), this._sendMessage = t, this._onSignal = e, this._onOffer = s, this._topic = i;
+  }
+  async receiveMessage({ author: t, recipient: e, payload: s }) {
+    var n, r, o, c;
+    if (s.type_url !== "dxos.mesh.swarm.SwarmMessage")
+      return;
+    const i = Ke.decode(s.value);
+    this._topic.equals(i.topic) && (a("received", {
+      from: t,
+      to: e,
+      msg: i
+    }, {
+      F: E,
+      L: 69,
+      S: this,
+      C: (_, d) => _(...d)
+    }), (n = i.data) != null && n.offer ? await this._handleOffer({
+      author: t,
+      recipient: e,
+      message: i
+    }) : (r = i.data) != null && r.answer ? await this._resolveAnswers(i) : (o = i.data) != null && o.signal ? await this._handleSignal({
+      author: t,
+      recipient: e,
+      message: i
+    }) : (c = i.data) != null && c.signalBatch ? await this._handleSignal({
+      author: t,
+      recipient: e,
+      message: i
+    }) : a.warn("unknown message", {
+      message: i
+    }, {
+      F: E,
+      L: 80,
+      S: this,
+      C: (_, d) => _(...d)
+    }));
+  }
+  async signal(t) {
+    var e, s;
+    f(((e = t.data) == null ? void 0 : e.signal) || ((s = t.data) == null ? void 0 : s.signalBatch), "Invalid message", {
+      F: E,
+      L: 85,
+      S: this,
+      A: [
+        "message.data?.signal || message.data?.signalBatch",
+        "'Invalid message'"
+      ]
+    }), await this._sendReliableMessage({
+      author: t.author,
+      recipient: t.recipient,
+      message: t
+    });
+  }
+  async offer(t) {
+    const e = {
+      ...t,
+      messageId: m.random()
+    };
+    return new Promise((s, i) => {
+      this._offerRecords.set(e.messageId, {
+        resolve: s
+      }), this._sendReliableMessage({
+        author: t.author,
+        recipient: t.recipient,
+        message: e
+      }).catch((n) => i(n));
+    });
+  }
+  async _sendReliableMessage({ author: t, recipient: e, message: s }) {
+    const i = {
+      ...s,
+      // Setting unique message_id if it not specified yet.
+      messageId: s.messageId ?? m.random()
+    };
+    a("sending", {
+      from: t,
+      to: e,
+      msg: i
+    }, {
+      F: E,
+      L: 123,
+      S: this,
+      C: (n, r) => n(...r)
+    }), await this._sendMessage({
+      author: t,
+      recipient: e,
+      payload: {
+        type_url: "dxos.mesh.swarm.SwarmMessage",
+        value: Ke.encode(i)
+      }
+    });
+  }
+  async _resolveAnswers(t) {
+    var s, i, n;
+    f((i = (s = t.data) == null ? void 0 : s.answer) == null ? void 0 : i.offerMessageId, "No offerMessageId", {
+      F: E,
+      L: 135,
+      S: this,
+      A: [
+        "message.data?.answer?.offerMessageId",
+        "'No offerMessageId'"
+      ]
+    });
+    const e = this._offerRecords.get(t.data.answer.offerMessageId);
+    e && (this._offerRecords.delete(t.data.answer.offerMessageId), f((n = t.data) == null ? void 0 : n.answer, "No answer", {
+      F: E,
+      L: 139,
+      S: this,
+      A: [
+        "message.data?.answer",
+        "'No answer'"
+      ]
+    }), a("resolving", {
+      answer: t.data.answer
+    }, {
+      F: E,
+      L: 140,
+      S: this,
+      C: (r, o) => r(...o)
+    }), e.resolve(t.data.answer));
+  }
+  async _handleOffer({ author: t, recipient: e, message: s }) {
+    f(s.data.offer, "No offer", {
+      F: E,
+      L: 154,
+      S: this,
+      A: [
+        "message.data.offer",
+        "'No offer'"
+      ]
+    });
+    const i = {
+      author: t,
+      recipient: e,
+      ...s,
+      data: {
+        offer: s.data.offer
+      }
+    }, n = await this._onOffer(i);
+    n.offerMessageId = s.messageId;
+    try {
+      await this._sendReliableMessage({
+        author: e,
+        recipient: t,
+        message: {
+          topic: s.topic,
+          sessionId: s.sessionId,
+          data: {
+            answer: n
+          }
+        }
+      });
+    } catch (r) {
+      r instanceof le ? a.info("timeout sending answer to offer", {
+        err: r
+      }, {
+        F: E,
+        L: 175,
+        S: this,
+        C: (o, c) => o(...c)
+      }) : a.info("error sending answer to offer", {
+        err: r
+      }, {
+        F: E,
+        L: 177,
+        S: this,
+        C: (o, c) => o(...c)
+      });
+    }
+  }
+  async _handleSignal({ author: t, recipient: e, message: s }) {
+    f(s.messageId, void 0, {
+      F: E,
+      L: 191,
+      S: this,
+      A: [
+        "message.messageId",
+        ""
+      ]
+    }), f(s.data.signal || s.data.signalBatch, "Invalid message", {
+      F: E,
+      L: 192,
+      S: this,
+      A: [
+        "message.data.signal || message.data.signalBatch",
+        "'Invalid message'"
+      ]
+    });
+    const i = {
+      author: t,
+      recipient: e,
+      ...s,
+      data: {
+        signal: s.data.signal,
+        signalBatch: s.data.signalBatch
+      }
+    };
+    await this._onSignal(i);
+  }
+};
+function Gs(t, e, s, i) {
+  var n = arguments.length, r = n < 3 ? e : i === null ? i = Object.getOwnPropertyDescriptor(e, s) : i, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+    r = Reflect.decorate(t, e, s, i);
+  else
+    for (var c = t.length - 1; c >= 0; c--)
+      (o = t[c]) && (r = (n < 3 ? o(r) : n > 3 ? o(e, s, r) : o(e, s)) || r);
+  return n > 3 && r && Object.defineProperty(e, s, r), r;
+}
+var w = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts", We = class extends Dt {
+  constructor() {
+    super("Connection displaced by remote initiator.");
+  }
+}, zs = 5e3, ut = class {
+  constructor(t, e, s, i, n, r, o, c) {
+    this.id = t, this.topic = e, this.localPeerId = s, this._signalMessaging = i, this._protocolProvider = n, this._transportFactory = r, this._connectionLimiter = o, this._callbacks = c, this._availableAfter = 0, this.availableToConnect = !0, this._ctx = new N(void 0, {
+      F: w,
+      L: 79
+    }), this.advertizing = !1, this.initiating = !1, this.connectionDisplaced = new S();
+  }
+  /**
+  * Respond to remote offer.
+  */
+  async onOffer(t) {
+    var s;
+    const e = t.author;
+    if (this.connection && ![
+      P.CREATED,
+      P.INITIAL,
+      P.CONNECTING
+    ].includes(this.connection.state))
+      return a.info(`received offer when connection already in ${this.connection.state} state`, void 0, {
+        F: w,
+        L: 114,
+        S: this,
+        C: (i, n) => i(...n)
+      }), {
+        accept: !1
+      };
+    if (this.connection || this.initiating)
+      if (e.toHex() < this.localPeerId.toHex())
+        a("close local connection", {
+          localPeerId: this.id,
+          topic: this.topic,
+          remotePeerId: this.localPeerId,
+          sessionId: (s = this.connection) == null ? void 0 : s.sessionId
+        }, {
+          F: w,
+          L: 123,
+          S: this,
+          C: (i, n) => i(...n)
+        }), this.connection && await this.closeConnection(new We());
+      else
+        return {
+          accept: !1
+        };
+    if (await this._callbacks.onOffer(e) && !this.connection) {
+      f(t.sessionId, void 0, {
+        F: w,
+        L: 143,
+        S: this,
+        A: [
+          "message.sessionId",
+          ""
+        ]
+      });
+      const i = this._createConnection(!1, t.sessionId);
+      try {
+        await this._connectionLimiter.connecting(t.sessionId), i.initiate(), await i.openConnection();
+      } catch (n) {
+        n instanceof xe || a.info("connection error", {
+          topic: this.topic,
+          peerId: this.localPeerId,
+          remoteId: this.id,
+          err: n
+        }, {
+          F: w,
+          L: 153,
+          S: this,
+          C: (r, o) => r(...o)
+        }), await this.closeConnection(n);
+      }
+      return {
+        accept: !0
+      };
+    }
+    return {
+      accept: !1
+    };
+  }
+  /**
+  * Initiate a connection to the remote peer.
+  */
+  async initiateConnection() {
+    f(!this.initiating, "Initiation in progress.", {
+      F: w,
+      L: 170,
+      S: this,
+      A: [
+        "!this.initiating",
+        "'Initiation in progress.'"
+      ]
+    }), f(!this.connection, "Already connected.", {
+      F: w,
+      L: 171,
+      S: this,
+      A: [
+        "!this.connection",
+        "'Already connected.'"
+      ]
+    });
+    const t = m.random();
+    a("initiating...", {
+      ownPeerId: this.localPeerId,
+      topic: this.topic,
+      remotePeerId: this.id,
+      sessionId: t
+    }, {
+      F: w,
+      L: 173,
+      S: this,
+      C: (i, n) => i(...n)
+    });
+    const e = this._createConnection(!0, t);
+    this.initiating = !0;
+    let s;
+    try {
+      if (await this._connectionLimiter.connecting(t), e.initiate(), s = await this._signalMessaging.offer({
+        author: this.localPeerId,
+        recipient: this.id,
+        sessionId: t,
+        topic: this.topic,
+        data: {
+          offer: {}
+        }
+      }), a("received", {
+        answer: s,
+        topic: this.topic,
+        ownId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        F: w,
+        L: 190,
+        S: this,
+        C: (i, n) => i(...n)
+      }), e.state !== P.INITIAL) {
+        a("ignoring response", void 0, {
+          F: w,
+          L: 192,
+          S: this,
+          C: (i, n) => i(...n)
+        });
+        return;
+      }
+    } catch (i) {
+      throw a("initiation error: send offer", {
+        err: i,
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        F: w,
+        L: 196,
+        S: this,
+        C: (n, r) => n(...r)
+      }), await e.abort(i), i;
+    } finally {
+      this.initiating = !1;
+    }
+    try {
+      if (!s.accept) {
+        this._callbacks.onRejected();
+        return;
+      }
+    } catch (i) {
+      throw a("initiation error: accept answer", {
+        err: i,
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        F: w,
+        L: 209,
+        S: this,
+        C: (n, r) => n(...r)
+      }), await e.abort(i), i;
+    } finally {
+      this.initiating = !1;
+    }
+    try {
+      a("opening connection as initiator", void 0, {
+        F: w,
+        L: 222,
+        S: this,
+        C: (i, n) => i(...n)
+      }), await e.openConnection(), this._callbacks.onAccepted();
+    } catch (i) {
+      throw a("initiation error: open connection", {
+        err: i,
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id
+      }, {
+        F: w,
+        L: 226,
+        S: this,
+        C: (n, r) => n(...r)
+      }), a.warn("closing connection due to unhandled error on openConnection", {
+        err: i
+      }, {
+        F: w,
+        L: 233,
+        S: this,
+        C: (n, r) => n(...r)
+      }), await this.closeConnection(i), i;
+    } finally {
+      this.initiating = !1;
+    }
+  }
+  /**
+  * Create new connection.
+  * Either we're initiating a connection or creating one in response to an offer from the other peer.
+  */
+  _createConnection(t, e) {
+    var i;
+    a("creating connection", {
+      topic: this.topic,
+      peerId: this.localPeerId,
+      remoteId: this.id,
+      initiator: t,
+      sessionId: e
+    }, {
+      F: w,
+      L: 247,
+      S: this,
+      C: (n, r) => n(...r)
+    }), f(!this.connection, "Already connected.", {
+      F: w,
+      L: 254,
+      S: this,
+      A: [
+        "!this.connection",
+        "'Already connected.'"
+      ]
+    });
+    const s = new fe(
+      this.topic,
+      this.localPeerId,
+      this.id,
+      e,
+      t,
+      this._signalMessaging,
+      // TODO(dmaretskyi): Init only when connection is established.
+      this._protocolProvider({
+        initiator: t,
+        localPeerId: this.localPeerId,
+        remotePeerId: this.id,
+        topic: this.topic
+      }),
+      this._transportFactory,
+      {
+        onConnected: () => {
+          this.availableToConnect = !0, this._lastConnectionTime = Date.now(), this._callbacks.onConnected(), this._connectionLimiter.doneConnecting(e), a.trace("dxos.mesh.connection.connected", {
+            topic: this.topic,
+            localPeerId: this.localPeerId,
+            remotePeerId: this.id,
+            sessionId: e,
+            initiator: t
+          }, {
+            F: w,
+            L: 273,
+            S: this,
+            C: (n, r) => n(...r)
+          });
+        },
+        onClosed: (n) => {
+          a("connection closed", {
+            topic: this.topic,
+            peerId: this.localPeerId,
+            remoteId: this.id,
+            initiator: t
+          }, {
+            F: w,
+            L: 282,
+            S: this,
+            C: (r, o) => r(...o)
+          }), this._connectionLimiter.doneConnecting(e), f(this.connection === s, "Connection mismatch (race condition).", {
+            F: w,
+            L: 287,
+            S: this,
+            A: [
+              "this.connection === connection",
+              "'Connection mismatch (race condition).'"
+            ]
+          }), a.trace("dxos.mesh.connection.closed", {
+            topic: this.topic,
+            localPeerId: this.localPeerId,
+            remotePeerId: this.id,
+            sessionId: e,
+            initiator: t
+          }, {
+            F: w,
+            L: 289,
+            S: this,
+            C: (r, o) => r(...o)
+          }), n instanceof We ? this.connectionDisplaced.emit(this.connection) : (this._lastConnectionTime && this._lastConnectionTime + zs < Date.now() ? this._availableAfter = 0 : (this.availableToConnect = !1, this._availableAfter = Ys(this._availableAfter)), this._callbacks.onDisconnected(), W(this._connectionCtx, () => {
+            this.availableToConnect = !0, this._callbacks.onPeerAvailable();
+          }, this._availableAfter)), this.connection = void 0;
+        }
+      }
+    );
+    return this._callbacks.onInitiated(s), (i = this._connectionCtx) == null || i.dispose(), this._connectionCtx = this._ctx.derive(), s.errors.handle((n) => {
+      a.info("connection error, closing", {
+        topic: this.topic,
+        peerId: this.localPeerId,
+        remoteId: this.id,
+        initiator: t,
+        err: n
+      }, {
+        F: w,
+        L: 329,
+        S: this,
+        C: (r, o) => r(...o)
+      }), a.trace("dxos.mesh.connection.error", {
+        topic: this.topic,
+        localPeerId: this.localPeerId,
+        remotePeerId: this.id,
+        sessionId: e,
+        initiator: t,
+        err: n
+      }, {
+        F: w,
+        L: 336,
+        S: this,
+        C: (r, o) => r(...o)
+      }), this.closeConnection(n);
+    }), this.connection = s, s;
+  }
+  async closeConnection(t) {
+    if (!this.connection)
+      return;
+    const e = this.connection;
+    a("closing...", {
+      peerId: this.id,
+      sessionId: e.sessionId
+    }, {
+      F: w,
+      L: 361,
+      S: this,
+      C: (s, i) => s(...i)
+    }), await e.close(t), a("closed", {
+      peerId: this.id,
+      sessionId: e.sessionId
+    }, {
+      F: w,
+      L: 367,
+      S: this,
+      C: (s, i) => s(...i)
+    });
+  }
+  async onSignal(t) {
+    if (!this.connection) {
+      a("dropping signal message for non-existent connection", {
+        message: t
+      }, {
+        F: w,
+        L: 372,
+        S: this,
+        C: (e, s) => e(...s)
+      });
+      return;
+    }
+    await this.connection.signal(t);
+  }
+  async safeDestroy(t) {
+    var e;
+    await this._ctx.dispose(), a("Destroying peer", {
+      peerId: this.id,
+      topic: this.topic
+    }, {
+      F: w,
+      L: 382,
+      S: this,
+      C: (s, i) => s(...i)
+    }), await ((e = this == null ? void 0 : this.connection) == null ? void 0 : e.close(t));
+  }
+};
+Gs([
+  F
+], ut.prototype, "safeDestroy", null);
+var Ys = (t) => t === 0 ? 50 : t < 500 ? 500 : t < 1e3 ? 1e3 : t < 5e3 ? 5e3 : 1e4;
+function G(t, e, s, i) {
+  var n = arguments.length, r = n < 3 ? e : i === null ? i = Object.getOwnPropertyDescriptor(e, s) : i, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+    r = Reflect.decorate(t, e, s, i);
+  else
+    for (var c = t.length - 1; c >= 0; c--)
+      (o = t[c]) && (r = (n < 3 ? o(r) : n > 3 ? o(e, s, r) : o(e, s)) || r);
+  return n > 3 && r && Object.defineProperty(e, s, r), r;
+}
+var C = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts", Ks = 100, Xe = (t) => Object.getPrototypeOf(t).constructor.name, j = class {
+  // TODO(burdon): Swarm => Peer.create/destroy =< Connection.open/close
+  // TODO(burdon): Pass in object.
+  constructor(t, e, s, i, n, r, o, c, _ = Ks) {
+    this._topic = t, this._ownPeerId = e, this._topology = s, this._protocolProvider = i, this._messenger = n, this._transportFactory = r, this._label = o, this._connectionLimiter = c, this._initiationDelay = _, this._ctx = new N(void 0, {
+      F: C,
+      L: 39
+    }), this._listeningHandle = void 0, this._peers = new O(m.hash), this._instanceId = m.random().toHex(), this.connectionAdded = new S(), this.disconnected = new S(), this.connected = new S(), this.errors = new ie(), a.trace("dxos.mesh.swarm.constructor", $.begin({
+      id: this._instanceId,
+      data: {
+        topic: this._topic.toHex(),
+        peerId: this._ownPeerId.toHex()
+      }
+    }), {
+      F: C,
+      L: 89,
+      S: this,
+      C: (d, h) => d(...h)
+    }), a("creating swarm", {
+      peerId: e
+    }, {
+      F: C,
+      L: 93,
+      S: this,
+      C: (d, h) => d(...h)
+    }), s.init(this._getSwarmController()), this._swarmMessenger = new Hs({
+      sendMessage: async (d) => await this._messenger.sendMessage(d),
+      onSignal: async (d) => await this.onSignal(d),
+      onOffer: async (d) => await this.onOffer(d),
+      topic: this._topic
+    }), a.trace("dxos.mesh.swarm.constructor", $.end({
+      id: this._instanceId
+    }), {
+      F: C,
+      L: 102,
+      S: this,
+      C: (d, h) => d(...h)
+    });
+  }
+  get connections() {
+    return Array.from(this._peers.values()).map((t) => t.connection).filter(Ot);
+  }
+  get ownPeerId() {
+    return this._ownPeerId;
+  }
+  /**
+  * Custom label assigned to this swarm. Used in devtools to display human-readable names for swarms.
+  */
+  get label() {
+    return this._label;
+  }
+  get topic() {
+    return this._topic;
+  }
+  async open() {
+    f(!this._listeningHandle, void 0, {
+      F: C,
+      L: 129,
+      S: this,
+      A: [
+        "!this._listeningHandle",
+        ""
+      ]
+    }), this._listeningHandle = await this._messenger.listen({
+      peerId: this._ownPeerId,
+      payloadType: "dxos.mesh.swarm.SwarmMessage",
+      onMessage: async (t) => {
+        await this._swarmMessenger.receiveMessage(t).catch((e) => a.info("Error while receiving message", {
+          err: e
+        }, {
+          F: C,
+          L: 137,
+          S: this,
+          C: (s, i) => s(...i)
+        }));
+      }
+    });
+  }
+  async destroy() {
+    var t;
+    a("destroying...", void 0, {
+      F: C,
+      L: 143,
+      S: this,
+      C: (e, s) => e(...s)
+    }), await ((t = this._listeningHandle) == null ? void 0 : t.unsubscribe()), this._listeningHandle = void 0, await this._ctx.dispose(), await this._topology.destroy(), await Promise.all(Array.from(this._peers.keys()).map((e) => this._destroyPeer(e, "swarm destroyed"))), a("destroyed", void 0, {
+      F: C,
+      L: 150,
+      S: this,
+      C: (e, s) => e(...s)
+    });
+  }
+  async setTopology(t) {
+    f(!this._ctx.disposed, "Swarm is offline", {
+      F: C,
+      L: 154,
+      S: this,
+      A: [
+        "!this._ctx.disposed",
+        "'Swarm is offline'"
+      ]
+    }), t !== this._topology && (a("setting topology", {
+      previous: Xe(this._topology),
+      topology: Xe(t)
+    }, {
+      F: C,
+      L: 158,
+      S: this,
+      C: (e, s) => e(...s)
+    }), await this._topology.destroy(), this._topology = t, this._topology.init(this._getSwarmController()), this._topology.update());
+  }
+  onSwarmEvent(t) {
+    var e;
+    if (a("swarm event", {
+      swarmEvent: t
+    }, {
+      F: C,
+      L: 171,
+      S: this,
+      C: (s, i) => s(...i)
+    }), this._ctx.disposed) {
+      a("swarm event ignored for disposed swarm", void 0, {
+        F: C,
+        L: 174,
+        S: this,
+        C: (s, i) => s(...i)
+      });
+      return;
+    }
+    if (t.peerAvailable) {
+      const s = m.from(t.peerAvailable.peer);
+      if (!s.equals(this._ownPeerId)) {
+        a("new peer", {
+          peerId: s
+        }, {
+          F: C,
+          L: 181,
+          S: this,
+          C: (n, r) => n(...r)
+        });
+        const i = this._getOrCreatePeer(s);
+        i.advertizing = !0;
+      }
+    } else if (t.peerLeft) {
+      const s = this._peers.get(m.from(t.peerLeft.peer));
+      s ? (s.advertizing = !1, ((e = s.connection) == null ? void 0 : e.state) !== P.CONNECTED && this._destroyPeer(s.id, "peer left").catch((i) => a.catch(i, void 0, {
+        F: C,
+        L: 191,
+        S: this,
+        C: (n, r) => n(...r)
+      }))) : a("received peerLeft but no peer found", {
+        peer: t.peerLeft.peer
+      }, {
+        F: C,
+        L: 194,
+        S: this,
+        C: (i, n) => i(...n)
+      });
+    }
+    this._topology.update();
+  }
+  async onOffer(t) {
+    var i, n;
+    if (a("offer", {
+      message: t
+    }, {
+      F: C,
+      L: 203,
+      S: this,
+      C: (r, o) => r(...o)
+    }), this._ctx.disposed)
+      return a("ignored for disposed swarm", void 0, {
+        F: C,
+        L: 205,
+        S: this,
+        C: (r, o) => r(...o)
+      }), {
+        accept: !1
+      };
+    if (f(t.author, void 0, {
+      F: C,
+      L: 210,
+      S: this,
+      A: [
+        "message.author",
+        ""
+      ]
+    }), !((i = t.recipient) != null && i.equals(this._ownPeerId)))
+      return a("rejecting offer with incorrect peerId", {
+        message: t
+      }, {
+        F: C,
+        L: 212,
+        S: this,
+        C: (r, o) => r(...o)
+      }), {
+        accept: !1
+      };
+    if (!((n = t.topic) != null && n.equals(this._topic)))
+      return a("rejecting offer with incorrect topic", {
+        message: t
+      }, {
+        F: C,
+        L: 216,
+        S: this,
+        C: (r, o) => r(...o)
+      }), {
+        accept: !1
+      };
+    const s = await this._getOrCreatePeer(t.author).onOffer(t);
+    return this._topology.update(), s;
+  }
+  async onSignal(t) {
+    var s, i;
+    if (a("signal", {
+      message: t
+    }, {
+      F: C,
+      L: 227,
+      S: this,
+      C: (n, r) => n(...r)
+    }), this._ctx.disposed) {
+      a.info("ignored for offline swarm", void 0, {
+        F: C,
+        L: 229,
+        S: this,
+        C: (n, r) => n(...r)
+      });
+      return;
+    }
+    f((s = t.recipient) == null ? void 0 : s.equals(this._ownPeerId), `Invalid signal peer id expected=${this.ownPeerId}, actual=${t.recipient}`, {
+      F: C,
+      L: 232,
+      S: this,
+      A: [
+        "message.recipient?.equals(this._ownPeerId)",
+        "`Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`"
+      ]
+    }), f((i = t.topic) == null ? void 0 : i.equals(this._topic), void 0, {
+      F: C,
+      L: 236,
+      S: this,
+      A: [
+        "message.topic?.equals(this._topic)",
+        ""
+      ]
+    }), f(t.author, void 0, {
+      F: C,
+      L: 237,
+      S: this,
+      A: [
+        "message.author",
+        ""
+      ]
+    }), await this._getOrCreatePeer(t.author).onSignal(t);
+  }
+  // For debug purposes
+  async goOffline() {
+    await this._ctx.dispose(), await Promise.all([
+      ...this._peers.keys()
+    ].map((t) => this._destroyPeer(t, "goOffline")));
+  }
+  // For debug purposes
+  async goOnline() {
+    this._ctx = new N(void 0, {
+      F: C,
+      L: 253
+    });
+  }
+  _getOrCreatePeer(t) {
+    let e = this._peers.get(t);
+    return e || (e = new ut(t, this._topic, this._ownPeerId, this._swarmMessenger, this._protocolProvider, this._transportFactory, this._connectionLimiter, {
+      onInitiated: (s) => {
+        this.connectionAdded.emit(s);
+      },
+      onConnected: () => {
+        this.connected.emit(t);
+      },
+      onDisconnected: async () => {
+        this._isUnregistered(e) || (e.advertizing || await this._destroyPeer(e.id, "peer disconnected"), this.disconnected.emit(t), this._topology.update());
+      },
+      onRejected: () => {
+        this._isUnregistered(e) || (a("peer rejected connection", {
+          peerId: t
+        }, {
+          F: C,
+          L: 289,
+          S: this,
+          C: (s, i) => s(...i)
+        }), this._destroyPeer(t, "peer rejected connection"));
+      },
+      onAccepted: () => {
+        this._topology.update();
+      },
+      onOffer: (s) => this._topology.onOffer(s),
+      onPeerAvailable: () => {
+        this._topology.update();
+      }
+    }), this._peers.set(t, e)), e;
+  }
+  async _destroyPeer(t, e) {
+    const s = this._peers.get(t);
+    f(s, void 0, {
+      F: C,
+      L: 312,
+      S: this,
+      A: [
+        "peer",
+        ""
+      ]
+    }), this._peers.delete(t), await s.safeDestroy(new Error(e));
+  }
+  _getSwarmController() {
+    return {
+      getState: () => ({
+        ownPeerId: this._ownPeerId,
+        connected: Array.from(this._peers.values()).filter((t) => t.connection).map((t) => t.id),
+        candidates: Array.from(this._peers.values()).filter((t) => !t.connection && t.advertizing && t.availableToConnect).map((t) => t.id),
+        allPeers: Array.from(this._peers.values()).map((t) => t.id)
+      }),
+      connect: (t) => {
+        this._ctx.disposed || W(this._ctx, async () => {
+          try {
+            await this._initiateConnection(t);
+          } catch (e) {
+            a("initiation error", e, {
+              F: C,
+              L: 339,
+              S: this,
+              C: (s, i) => s(...i)
+            });
+          }
+        });
+      },
+      disconnect: async (t) => {
+        this._ctx.disposed || W(this._ctx, async () => {
+          await this._closeConnection(t), this._topology.update();
+        });
+      }
+    };
+  }
+  /**
+  * Creates a connection then sends message over signal network.
+  */
+  async _initiateConnection(t) {
+    const e = this._ctx, s = this._getOrCreatePeer(t);
+    if (t.toHex() < this._ownPeerId.toHex() && (a("initiation delay", {
+      remoteId: t
+    }, {
+      F: C,
+      L: 367,
+      S: this,
+      C: (i, n) => i(...n)
+    }), await ct(this._initiationDelay)), !e.disposed) {
+      if (this._isUnregistered(s))
+        throw new Error("Peer left during initiation delay");
+      s.connection || (a("initiating connection...", {
+        remoteId: t
+      }, {
+        F: C,
+        L: 383,
+        S: this,
+        C: (i, n) => i(...n)
+      }), await s.initiateConnection(), this._topology.update(), a("initiated", {
+        remoteId: t
+      }, {
+        F: C,
+        L: 386,
+        S: this,
+        C: (i, n) => i(...n)
+      }));
+    }
+  }
+  async _closeConnection(t) {
+    const e = this._peers.get(t);
+    e && await e.closeConnection();
+  }
+  _isUnregistered(t) {
+    return !t || this._peers.get(t.id) !== t;
+  }
+};
+G([
+  q
+], j.prototype, "_instanceId", void 0);
+G([
+  q
+], j.prototype, "ownPeerId", null);
+G([
+  q
+], j.prototype, "topic", null);
+G([
+  F
+], j.prototype, "onSwarmEvent", null);
+G([
+  F
+], j.prototype, "onOffer", null);
+G([
+  F
+], j.prototype, "goOffline", null);
+G([
+  F
+], j.prototype, "goOnline", null);
+var Ve = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts", Ws = class {
+  get peers() {
+    return Array.from(this._peers.values());
+  }
+  constructor(t) {
+    this._swarm = t, this._subscriptions = new Pt(), this._connectionSubscriptions = new O(m.hash), this._peers = new O(m.hash), this.mapUpdated = new S(), this._subscriptions.add(t.connectionAdded.on((e) => {
+      this._update(), this._connectionSubscriptions.set(e.remoteId, e.stateChanged.on(() => {
+        this._update();
+      }));
+    })), this._subscriptions.add(t.disconnected.on((e) => {
+      var s;
+      (s = this._connectionSubscriptions.get(e)) == null || s(), this._connectionSubscriptions.delete(e), this._update();
+    })), this._update();
+  }
+  _update() {
+    a("updating swarm", void 0, {
+      F: Ve,
+      L: 72,
+      S: this,
+      C: (t, e) => t(...e)
+    }), this._peers.clear(), this._peers.set(this._swarm.ownPeerId, {
+      id: this._swarm.ownPeerId,
+      state: "ME",
+      connections: []
+    });
+    for (const t of this._swarm.connections)
+      this._peers.set(t.remoteId, {
+        id: t.remoteId,
+        state: t.state,
+        connections: [
+          this._swarm.ownPeerId
+        ]
+      });
+    a("graph changed", {
+      directConnections: this._swarm.connections.length,
+      totalPeersInSwarm: this._peers.size
+    }, {
+      F: Ve,
+      L: 113,
+      S: this,
+      C: (t, e) => t(...e)
+    }), this.mapUpdated.emit(Array.from(this._peers.values()));
+  }
+  // TODO(burdon): Async open/close.
+  destroy() {
+    Array.from(this._connectionSubscriptions.values()).forEach((t) => t()), this._subscriptions.clear();
+  }
+}, J = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection-limiter.ts", Xs = 50, Vs = class {
+  constructor({ maxConcurrentInitConnections: t = Xs } = {}) {
+    this._ctx = new N(void 0, {
+      F: J,
+      L: 23
+    }), this._waitingPromises = new O(m.hash), this.resolveWaitingPromises = new at(this._ctx, async () => {
+      Array.from(this._waitingPromises.values()).slice(0, this._maxConcurrentInitConnections).forEach(({ resolve: e }) => {
+        e();
+      });
+    }), this._maxConcurrentInitConnections = t;
+  }
+  /**
+  * @returns Promise that resolves in queue when connections amount with 'CONNECTING' state is below the limit.
+  */
+  async connecting(t) {
+    f(!this._waitingPromises.has(t), "Peer is already waiting for connection", {
+      F: J,
+      L: 48,
+      S: this,
+      A: [
+        "!this._waitingPromises.has(sessionId)",
+        "'Peer is already waiting for connection'"
+      ]
+    }), a("waiting", {
+      sessionId: t
+    }, {
+      F: J,
+      L: 49,
+      S: this,
+      C: (e, s) => e(...s)
+    }), await new Promise((e, s) => {
+      this._waitingPromises.set(t, {
+        resolve: e,
+        reject: s
+      }), this.resolveWaitingPromises.schedule();
+    }), a("allow", {
+      sessionId: t
+    }, {
+      F: J,
+      L: 57,
+      S: this,
+      C: (e, s) => e(...s)
+    });
+  }
+  /**
+  * Rejects promise returned by `connecting` method.
+  */
+  doneConnecting(t) {
+    a("done", {
+      sessionId: t
+    }, {
+      F: J,
+      L: 64,
+      S: this,
+      C: (e, s) => e(...s)
+    }), this._waitingPromises.has(t) && (this._waitingPromises.get(t).reject(new xe()), this._waitingPromises.delete(t), this.resolveWaitingPromises.schedule());
+  }
+}, Zs = 1e3 * 60 * 15, Ze;
+(function(t) {
+  t.CONNECTION_STATE_CHANGED = "CONNECTION_STATE_CHANGED", t.PROTOCOL_ERROR = "PROTOCOL_ERROR", t.PROTOCOL_EXTENSIONS_INITIALIZED = "PROTOCOL_EXTENSIONS_INITIALIZED", t.PROTOCOL_EXTENSIONS_HANDSHAKE = "PROTOCOL_EXTENSIONS_HANDSHAKE", t.PROTOCOL_HANDSHAKE = "PROTOCOL_HANDSHAKE";
+})(Ze || (Ze = {}));
+var Js = class {
+  constructor() {
+    this._swarms = new O(m.hash), this.update = new S();
+  }
+  getSwarmInfo(t) {
+    return this._swarms.get(t) ?? ot(new Error(`Swarm not found: ${t}`));
+  }
+  get swarms() {
+    return Array.from(this._swarms.values());
+  }
+  joinedSwarm(t) {
+    const e = {
+      id: m.from(t._instanceId),
+      topic: t.topic,
+      isActive: !0,
+      label: t.label,
+      connections: []
+    };
+    this._swarms.set(m.from(t._instanceId), e), this.update.emit(), t.connectionAdded.on((s) => {
+      var n, r, o;
+      const i = {
+        state: P.CREATED,
+        closeReason: s.closeReason,
+        remotePeerId: s.remoteId,
+        sessionId: s.sessionId,
+        transport: s.transport && Object.getPrototypeOf(s.transport).constructor.name,
+        protocolExtensions: [],
+        events: [],
+        lastUpdate: /* @__PURE__ */ new Date()
+      };
+      e.connections.push(i), this.update.emit(), s.stateChanged.on(async (c) => {
+        var _;
+        if (i.state = c, i.closeReason = s.closeReason, i.lastUpdate = /* @__PURE__ */ new Date(), i.events.push({
+          type: "CONNECTION_STATE_CHANGED",
+          newState: c
+        }), c === P.CONNECTED) {
+          const d = await ((_ = s.transport) == null ? void 0 : _.getDetails());
+          i.transportDetails = d;
+        }
+        this.update.emit();
+      }), (r = (n = s.protocol) == null ? void 0 : n.stats) == null || r.on((c) => {
+        i.readBufferSize = c.readBufferSize, i.writeBufferSize = c.writeBufferSize, i.streams = c.channels, i.lastUpdate = /* @__PURE__ */ new Date(), this.update.emit();
+      }), (o = s.transportStats) == null || o.on((c) => {
+        i.transportBytesSent = c.bytesSent, i.transportBytesReceived = c.bytesReceived, i.transportPacketsSent = c.packetsSent, i.transportPacketsReceived = c.packetsReceived;
+      }), Qs(e);
+    });
+  }
+  leftSwarm(t) {
+    this.getSwarmInfo(m.from(t._instanceId)).isActive = !1, this.update.emit();
+  }
+}, Qs = (t) => {
+  var e;
+  t.connections = (e = t.connections) == null ? void 0 : e.filter((s) => s.lastUpdate ? Date.now() - s.lastUpdate.getTime() < Zs : !0);
+};
+function gt(t, e, s, i) {
+  var n = arguments.length, r = n < 3 ? e : i === null ? i = Object.getOwnPropertyDescriptor(e, s) : i, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+    r = Reflect.decorate(t, e, s, i);
+  else
+    for (var c = t.length - 1; c >= 0; c--)
+      (o = t[c]) && (r = (n < 3 ? o(r) : n > 3 ? o(e, s, r) : o(e, s)) || r);
+  return n > 3 && r && Object.defineProperty(e, s, r), r;
+}
+var I = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts", mt = class {
+  constructor({ transportFactory: t, signalManager: e, log: s }) {
+    this._swarms = new O(m.hash), this._mappers = new O(m.hash), this._instanceId = m.random().toHex(), this._connectionState = ue.ONLINE, this.connectionStateChanged = new S(), this.topicsUpdated = new S(), this._transportFactory = t, this._signalManager = e, this._signalManager.swarmEvent.on(({ topic: i, swarmEvent: n }) => {
+      var r;
+      return (r = this._swarms.get(i)) == null ? void 0 : r.onSwarmEvent(n);
+    }), this._messenger = new kt({
+      signalManager: this._signalManager
+    }), this._signalConnection = {
+      join: (i) => this._signalManager.join(i),
+      leave: (i) => this._signalManager.leave(i)
+    }, this._connectionLimiter = new Vs(), s && (this._connectionLog = new Js());
+  }
+  // TODO(burdon): Remove access (Devtools only).
+  get connectionLog() {
+    return this._connectionLog;
+  }
+  get connectionState() {
+    return this._connectionState;
+  }
+  // TODO(burdon): Reconcile with "discovery_key".
+  get topics() {
+    return Array.from(this._swarms.keys());
+  }
+  getSwarmMap(t) {
+    return this._mappers.get(t);
+  }
+  getSwarm(t) {
+    return this._swarms.get(t);
+  }
+  async open() {
+    a.trace("dxos.mesh.network-manager.open", $.begin({
+      id: this._instanceId
+    }), {
+      F: I,
+      L: 126,
+      S: this,
+      C: (t, e) => t(...e)
+    }), await this._messenger.open(), await this._signalManager.open(), a.trace("dxos.mesh.network-manager.open", $.end({
+      id: this._instanceId
+    }), {
+      F: I,
+      L: 129,
+      S: this,
+      C: (t, e) => t(...e)
+    });
+  }
+  async close() {
+    for (const t of this._swarms.keys())
+      await this.leaveSwarm(t).catch((e) => {
+        a(e, void 0, {
+          F: I,
+          L: 135,
+          S: this,
+          C: (s, i) => s(...i)
+        });
+      });
+    await this._messenger.close(), await this._signalManager.close();
+  }
+  /**
+  * Join the swarm.
+  */
+  async joinSwarm({ topic: t, peerId: e, topology: s, protocolProvider: i, label: n }) {
+    var o;
+    if (f(m.isPublicKey(t), void 0, {
+      F: I,
+      L: 154,
+      S: this,
+      A: [
+        "PublicKey.isPublicKey(topic)",
+        ""
+      ]
+    }), f(m.isPublicKey(e), void 0, {
+      F: I,
+      L: 155,
+      S: this,
+      A: [
+        "PublicKey.isPublicKey(peerId)",
+        ""
+      ]
+    }), f(s, void 0, {
+      F: I,
+      L: 156,
+      S: this,
+      A: [
+        "topology",
+        ""
+      ]
+    }), f(typeof i == "function", void 0, {
+      F: I,
+      L: 157,
+      S: this,
+      A: [
+        "typeof protocol === 'function'",
+        ""
+      ]
+    }), this._swarms.has(t))
+      throw new Error(`Already connected to swarm: ${m.from(t)}`);
+    a("joining", {
+      topic: m.from(t),
+      peerId: e,
+      topology: s.toString()
+    }, {
+      F: I,
+      L: 162,
+      S: this,
+      C: (c, _) => c(..._)
+    });
+    const r = new j(t, e, s, i, this._messenger, this._transportFactory, n, this._connectionLimiter);
+    return r.errors.handle((c) => {
+      a("swarm error", {
+        error: c
+      }, {
+        F: I,
+        L: 175,
+        S: this,
+        C: (_, d) => _(...d)
+      });
+    }), this._swarms.set(t, r), this._mappers.set(t, new Ws(r)), await r.open(), this._signalConnection.join({
+      topic: t,
+      peerId: e
+    }).catch((c) => a.catch(c, void 0, {
+      F: I,
+      L: 184,
+      S: this,
+      C: (_, d) => _(...d)
+    })), this.topicsUpdated.emit(), (o = this._connectionLog) == null || o.joinedSwarm(r), a("joined", {
+      topic: m.from(t),
+      count: this._swarms.size
+    }, {
+      F: I,
+      L: 188,
+      S: this,
+      C: (c, _) => c(..._)
+    }), {
+      close: () => this.leaveSwarm(t)
+    };
+  }
+  /**
+  * Close the connection.
+  */
+  async leaveSwarm(t) {
+    var i;
+    if (!this._swarms.has(t))
+      return;
+    a("leaving", {
+      topic: m.from(t)
+    }, {
+      F: I,
+      L: 205,
+      S: this,
+      C: (n, r) => n(...r)
+    });
+    const e = this._swarms.get(t);
+    await this._signalConnection.leave({
+      topic: t,
+      peerId: e.ownPeerId
+    }), this._mappers.get(t).destroy(), this._mappers.delete(t), (i = this._connectionLog) == null || i.leftSwarm(e), await e.destroy(), this._swarms.delete(t), this.topicsUpdated.emit(), a("left", {
+      topic: m.from(t),
+      count: this._swarms.size
+    }, {
+      F: I,
+      L: 219,
+      S: this,
+      C: (n, r) => n(...r)
+    });
+  }
+  async setConnectionState(t) {
+    if (t !== this._connectionState) {
+      switch (t) {
+        case ue.OFFLINE: {
+          this._connectionState = t, await Promise.all([
+            ...this._swarms.values()
+          ].map((e) => e.goOffline())), await this._messenger.close(), await this._signalManager.close();
+          break;
+        }
+        case ue.ONLINE: {
+          this._connectionState = t, this._messenger.open(), await Promise.all([
+            ...this._swarms.values()
+          ].map((e) => e.goOnline())), await this._signalManager.open();
+          break;
+        }
+      }
+      this.connectionStateChanged.emit(this._connectionState);
+    }
+  }
+};
+gt([
+  F
+], mt.prototype, "joinSwarm", null);
+gt([
+  F
+], mt.prototype, "leaveSwarm", null);
+function Ct(t, e, s, i) {
+  var n = arguments.length, r = n < 3 ? e : i === null ? i = Object.getOwnPropertyDescriptor(e, s) : i, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+    r = Reflect.decorate(t, e, s, i);
+  else
+    for (var c = t.length - 1; c >= 0; c--)
+      (o = t[c]) && (r = (n < 3 ? o(r) : n > 3 ? o(e, s, r) : o(e, s)) || r);
+  return n > 3 && r && Object.defineProperty(e, s, r), r;
+}
+var k = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts", Je = 1, Qe = (t) => new se.Transform({
+  objectMode: !0,
+  transform: (e, s, i) => {
+    setTimeout(() => i(null, e), t);
+  }
+}), A, wt = (A = class {
+  constructor(e) {
+    this._options = e, this._instanceId = m.random(), this._remote = new ee(), this._outgoingDelay = Qe(Je), this._incomingDelay = Qe(Je), this._closed = !1, this.closed = new S(), this.connected = new S(), this.errors = new ie(), f(!A._connections.has(this._instanceId), "Duplicate memory connection", {
+      F: k,
+      L: 64,
+      S: this,
+      A: [
+        "!MemoryTransport._connections.has(this._instanceId)",
+        "'Duplicate memory connection'"
+      ]
+    }), A._connections.set(this._instanceId, this);
+  }
+  get isOpen() {
+    return !this._closed;
+  }
+  async open() {
+    if (a("opening...", void 0, {
+      F: k,
+      L: 74,
+      S: this,
+      C: (e, s) => e(...s)
+    }), this._options.initiator) {
+      a("sending signal", void 0, {
+        F: k,
+        L: 78,
+        S: this,
+        C: (e, s) => e(...s)
+      });
+      try {
+        await this._options.sendSignal({
+          payload: {
+            transportId: this._instanceId.toHex()
+          }
+        });
+      } catch (e) {
+        this._closed || this.errors.raise(ei(e));
+      }
+    } else
+      this._remote.wait({
+        timeout: this._options.timeout ?? 1e3
+      }).then((e) => {
+        if (!this._closed) {
+          if (this._remoteInstanceId = e, this._remoteConnection = A._connections.get(this._remoteInstanceId), !this._remoteConnection) {
+            this._closed = !0, this.closed.emit();
+            return;
+          }
+          f(!this._remoteConnection._remoteConnection, `Remote already connected: ${this._remoteInstanceId}`, {
+            F: k,
+            L: 104,
+            S: this,
+            A: [
+              "!this._remoteConnection._remoteConnection",
+              "`Remote already connected: ${this._remoteInstanceId}`"
+            ]
+          }), this._remoteConnection._remoteConnection = this, this._remoteConnection._remoteInstanceId = this._instanceId, a("connected", void 0, {
+            F: k,
+            L: 108,
+            S: this,
+            C: (s, i) => s(...i)
+          }), this._options.stream.pipe(this._outgoingDelay).pipe(this._remoteConnection._options.stream).pipe(this._incomingDelay).pipe(this._options.stream), this.connected.emit(), this._remoteConnection.connected.emit();
+        }
+      }).catch((e) => {
+        this._closed || this.errors.raise(e);
+      });
+  }
+  async close() {
+    a("closing...", void 0, {
+      F: k,
+      L: 129,
+      S: this,
+      C: (e, s) => e(...s)
+    }), this._closed = !0, A._connections.delete(this._instanceId), this._remoteConnection && (this._remoteConnection._closed = !0, A._connections.delete(this._remoteInstanceId), this._options.stream.unpipe(this._incomingDelay), this._incomingDelay.unpipe(this._remoteConnection._options.stream), this._remoteConnection._options.stream.unpipe(this._outgoingDelay), this._outgoingDelay.unpipe(this._options.stream), this._options.stream.unpipe(this._outgoingDelay), this._remoteConnection.closed.emit(), this._remoteConnection._remoteConnection = void 0, this._remoteConnection = void 0), this.closed.emit(), a("closed", void 0, {
+      F: k,
+      L: 157,
+      S: this,
+      C: (e, s) => e(...s)
+    });
+  }
+  async onSignal({ payload: e }) {
+    if (a("received signal", {
+      payload: e
+    }, {
+      F: k,
+      L: 161,
+      S: this,
+      C: (i, n) => i(...n)
+    }), !(e != null && e.transportId))
+      return;
+    const s = e.transportId;
+    if (s) {
+      const i = m.fromHex(s);
+      this._remote.wake(i);
+    }
+  }
+  async getDetails() {
+    return this._instanceId.toHex();
+  }
+  async getStats() {
+    return {
+      bytesSent: 0,
+      bytesReceived: 0,
+      packetsSent: 0,
+      packetsReceived: 0
+    };
+  }
+}, A._connections = new O(m.hash), A);
+Ct([
+  q
+], wt.prototype, "_instanceId", void 0);
+Ct([
+  q
+], wt.prototype, "_remoteInstanceId", void 0);
+var ei = (t) => t instanceof Error ? t : new Error(String(t)), et;
+(function(t) {
+  t.SIMPLE_PEER = "SIMPLE_PEER", t.SIMPLE_PEER_PROXY = "SIMPLE_PEER_PROXY", t.LIBDATACHANNEL = "LIBDATACHANNEL", t.MEMORY = "MEMORY", t.TCP = "TCP";
+})(et || (et = {}));
+var yt = null;
+try {
+  yt = $s("@koush/wrtc");
+} catch {
+}
+var L = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport.ts", ti = class {
+  get isOpen() {
+    return this._piped && !this._closed;
+  }
+  /**
+  * @params opts.config formatted as per https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/RTCPeerConnection
+  */
+  constructor(t) {
+    this._params = t, this._closed = !1, this._piped = !1, this.closed = new S(), this.connected = new S(), this.errors = new ie(), this._instanceId = m.random().toHex(), a.trace("dxos.mesh.webrtc-transport.constructor", $.begin({
+      id: this._instanceId
+    }), {
+      F: L,
+      L: 50,
+      S: this,
+      C: (e, s) => e(...s)
+    }), a("created connection", t, {
+      F: L,
+      L: 51,
+      S: this,
+      C: (e, s) => e(...s)
+    }), this._peer = new je({
+      channelName: "dxos.mesh.transport",
+      initiator: this._params.initiator,
+      wrtc: je.WEBRTC_SUPPORT ? void 0 : yt ?? ot(new Error("wrtc not available")),
+      config: this._params.webrtcConfig
+    }), this._peer.on("signal", async (e) => {
+      a("signal", e, {
+        F: L,
+        L: 60,
+        S: this,
+        C: (s, i) => s(...i)
+      }), await this._params.sendSignal({
+        payload: {
+          data: e
+        }
+      });
+    }), this._peer.on("connect", () => {
+      a("connected", void 0, {
+        F: L,
+        L: 65,
+        S: this,
+        C: (e, s) => e(...s)
+      }), this._params.stream.pipe(this._peer).pipe(this._params.stream), this._piped = !0, this.connected.emit();
+    }), this._peer.on("close", async () => {
+      a("closed", void 0, {
+        F: L,
+        L: 72,
+        S: this,
+        C: (e, s) => e(...s)
+      }), await this.close();
+    }), this._peer.on("error", async (e) => {
+      var s, i;
+      if (typeof RTCError < "u" && e instanceof RTCError)
+        e.errorDetail === "sctp-failure" ? this.errors.raise(new dt("sctp-failure from RTCError", e)) : (a.info("unknown RTCError", {
+          err: e
+        }, {
+          F: L,
+          L: 83,
+          S: this,
+          C: (n, r) => n(...r)
+        }), this.errors.raise(new Ee("unknown RTCError", e)));
+      else if ("code" in e)
+        switch (a.info("simple-peer error", e, {
+          F: L,
+          L: 88,
+          S: this,
+          C: (n, r) => n(...r)
+        }), e.code) {
+          case "ERR_WEBRTC_SUPPORT":
+            this.errors.raise(new lt("WebRTC not supported", e));
+            break;
+          case "ERR_SIGNALING":
+            this.errors.raise(new he("signaling failure", e));
+            break;
+          case "ERR_ICE_CONNECTION_FAILURE":
+          case "ERR_DATA_CHANNEL":
+          case "ERR_CONNECTION_FAILURE":
+            this.errors.raise(new he("unknown communication failure", e));
+            break;
+          case "ERR_CREATE_OFFER":
+          case "ERR_CREATE_ANSWER":
+          case "ERR_SET_LOCAL_DESCRIPTION":
+          case "ERR_SET_REMOTE_DESCRIPTION":
+          case "ERR_ADD_ICE_CANDIDATE":
+            this.errors.raise(new Ee("unknown simple-peer library failure", e));
+            break;
+          default:
+            this.errors.raise(new Error("unknown simple-peer error"));
+            break;
+        }
+      else
+        a.info("unknown peer connection error", e, {
+          F: L,
+          L: 114,
+          S: this,
+          C: (n, r) => n(...r)
+        }), this.errors.raise(e);
+      try {
+        typeof ((i = (s = this._peer) == null ? void 0 : s._pc) == null ? void 0 : i.getStats) == "function" && this._peer._pc.getStats().then((n) => {
+          a.info("report after webrtc error", {
+            config: this._params.webrtcConfig,
+            stats: Object.fromEntries(n.entries())
+          }, {
+            F: L,
+            L: 122,
+            S: this,
+            C: (r, o) => r(...o)
+          });
+        });
+      } catch (n) {
+        a.catch(n, void 0, {
+          F: L,
+          L: 129,
+          S: this,
+          C: (r, o) => r(...o)
+        });
+      }
+      await this.close();
+    }), a.trace("dxos.mesh.webrtc-transport.constructor", $.end({
+      id: this._instanceId
+    }), {
+      F: L,
+      L: 135,
+      S: this,
+      C: (e, s) => e(...s)
+    });
+  }
+  async getStats() {
+    const t = await this._getStats();
+    return t ? {
+      bytesSent: t.transport.bytesSent,
+      bytesReceived: t.transport.bytesReceived,
+      packetsSent: t.transport.packetsSent,
+      packetsReceived: t.transport.packetsReceived,
+      rawStats: t.raw
+    } : {
+      bytesSent: 0,
+      bytesReceived: 0,
+      packetsSent: 0,
+      packetsReceived: 0,
+      rawStats: {}
+    };
+  }
+  async _getStats() {
+    var t, e;
+    return typeof ((e = (t = this._peer) == null ? void 0 : t._pc) == null ? void 0 : e.getStats) != "function" ? null : await this._peer._pc.getStats().then((s) => {
+      const i = Array.from(s.entries()), n = i.filter((_) => _[1].type === "transport")[0][1], r = i.filter((_) => _[0] === n.selectedCandidatePairId);
+      let o, c;
+      return r.length > 0 && (o = r[0][1], c = i.filter((_) => _[0] === o.remoteCandidateId)[0][1]), {
+        datachannel: i.filter((_) => _[1].type === "data-channel")[0][1],
+        transport: n,
+        selectedCandidatePair: o,
+        remoteCandidate: c,
+        raw: Object.fromEntries(s.entries())
+      };
+    });
+  }
+  async getDetails() {
+    const t = await this._getStats(), e = t == null ? void 0 : t.remoteCandidate;
+    return e ? e.candidateType === "relay" ? `${e.ip}:${e.port}/${e.protocol} relay for ${e.relatedAddress}:${e.relatedPort}` : `${e.ip}:${e.port}/${e.protocol} ${e.candidateType}` : "unavailable";
+  }
+  async open() {
+  }
+  async close() {
+    a("closing...", void 0, {
+      F: L,
+      L: 200,
+      S: this,
+      C: (t, e) => t(...e)
+    }), !this._closed && (this._disconnectStreams(), this._peer.destroy(), this._closed = !0, this.closed.emit(), a("closed", void 0, {
+      F: L,
+      L: 208,
+      S: this,
+      C: (t, e) => t(...e)
+    }));
+  }
+  async onSignal(t) {
+    this._closed || (ns(t.payload.data, "Signal message must contain signal data."), this._peer.signal(t.payload.data));
+  }
+  _disconnectStreams() {
+    var t, e, s, i;
+    this._piped && ((i = (s = (e = (t = this._params.stream).unpipe) == null ? void 0 : e.call(t, this._peer)) == null ? void 0 : s.unpipe) == null || i.call(s, this._params.stream));
+  }
+}, Y = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/simplepeer-transport-service.ts", hi = class {
+  constructor(t) {
+    this._webrtcConfig = t, this.transports = new O(m.hash);
+  }
+  open(t) {
+    return new xt(({ ready: s, next: i, close: n }) => {
+      const r = new se.Duplex({
+        read: () => {
+          const _ = [
+            ...c.writeCallbacks
+          ];
+          c.writeCallbacks.length = 0;
+          for (const d of _)
+            d();
+        },
+        write: function(_, d, h) {
+          i({
+            data: {
+              payload: _
+            }
+          }), h();
+        }
+      }), o = new ti({
+        initiator: t.initiator,
+        stream: r,
+        webrtcConfig: this._webrtcConfig,
+        sendSignal: async (_) => {
+          i({
+            signal: {
+              payload: _
+            }
+          });
+        }
+      });
+      o.open(), i({
+        connection: {
+          state: K.CONNECTING
+        }
+      }), o.connected.on(() => {
+        i({
+          connection: {
+            state: K.CONNECTED
+          }
+        });
+      }), o.errors.handle((_) => {
+        i({
+          connection: {
+            state: K.CLOSED,
+            error: _.toString()
+          }
+        }), n(_);
+      }), o.closed.on(() => {
+        i({
+          connection: {
+            state: K.CLOSED
+          }
+        }), n();
+      });
+      const c = {
+        transport: o,
+        stream: r,
+        writeCallbacks: [],
+        state: "OPEN"
+      };
+      s(), this.transports.set(t.proxyId, c);
+    });
+  }
+  async sendSignal({ proxyId: t, signal: e }) {
+    f(this.transports.has(t), void 0, {
+      F: Y,
+      L: 119,
+      S: this,
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
+    }), await this.transports.get(t).transport.onSignal(e);
+  }
+  async getDetails({ proxyId: t }) {
+    return f(this.transports.has(t), void 0, {
+      F: Y,
+      L: 124,
+      S: this,
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
+    }), {
+      details: await this.transports.get(t).transport.getDetails()
+    };
+  }
+  async getStats({ proxyId: t }) {
+    return f(this.transports.has(t), void 0, {
+      F: Y,
+      L: 129,
+      S: this,
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
+    }), {
+      stats: await this.transports.get(t).transport.getStats()
+    };
+  }
+  async sendData({ proxyId: t, payload: e }) {
+    var n;
+    ((n = this.transports.get(t)) == null ? void 0 : n.state) !== "OPEN" && a.debug("transport is closed", void 0, {
+      F: Y,
+      L: 135,
+      S: this,
+      C: (r, o) => r(...o)
+    }), f(this.transports.has(t), void 0, {
+      F: Y,
+      L: 137,
+      S: this,
+      A: [
+        "this.transports.has(proxyId)",
+        ""
+      ]
+    });
+    const s = this.transports.get(t);
+    s.stream.push(e) || await new Promise((r) => {
+      s.writeCallbacks.push(r);
+    });
+  }
+  async close({ proxyId: t }) {
+    var e, s;
+    await ((e = this.transports.get(t)) == null ? void 0 : e.transport.close()), await ((s = this.transports.get(t)) == null ? void 0 : s.stream.end()), this.transports.get(t) && (this.transports.get(t).state = "CLOSED"), a("Closed.", void 0, {
+      F: Y,
+      L: 153,
+      S: this,
+      C: (i, n) => i(...n)
+    });
+  }
+};
+function si(t, e, s, i) {
+  var n = arguments.length, r = n < 3 ? e : i === null ? i = Object.getOwnPropertyDescriptor(e, s) : i, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+    r = Reflect.decorate(t, e, s, i);
+  else
+    for (var c = t.length - 1; c >= 0; c--)
+      (o = t[c]) && (r = (n < 3 ? o(r) : n > 3 ? o(e, s, r) : o(e, s)) || r);
+  return n > 3 && r && Object.defineProperty(e, s, r), r;
+}
+var b = "/home/runner/work/dxos/dxos/packages/core/mesh/network-manager/src/transport/libdatachannel-transport.ts", tt = "dxos.mesh.transport", ii = 64 * 1024, st = 64 * 1024, B, ni = (B = class {
+  constructor(e) {
+    this._options = e, this._closed = !1, this._connected = !1, this._writeCallback = null, this._readyForCandidates = new ee(), this.closed = new S(), this.connected = new S(), this.errors = new ie();
+  }
+  get isOpen() {
+    return !!this._peer && !this._closed;
+  }
+  async open() {
+    this._closed && this.errors.raise(new Error("connection already closed"));
+    const { RTCPeerConnection: e } = (await it("node-datachannel/polyfill")).default;
+    this._options.webrtcConfig ? this._options.webrtcConfig.iceServers = this._options.webrtcConfig.iceServers ?? [] : this._options.webrtcConfig = {
+      iceServers: []
+    }, this._peer = new e(this._options.webrtcConfig), this._peer.onicecandidateerror = (s) => {
+      a.error("peer.onicecandidateerror", {
+        event: s
+      }, {
+        F: b,
+        L: 77,
+        S: this,
+        C: (i, n) => i(...n)
+      });
+    }, this._peer.onconnectionstatechange = (s) => {
+      var i;
+      a.debug("peer.onconnectionstatechange", {
+        event: s,
+        peerConnectionState: (i = this._peer) == null ? void 0 : i.connectionState,
+        transportConnectionState: this._connected
+      }, {
+        F: b,
+        L: 81,
+        S: this,
+        C: (n, r) => n(...r)
+      });
+    }, this._peer.onicecandidate = async (s) => {
+      if (a.debug("peer.onicecandidate", {
+        event: s
+      }, {
+        F: b,
+        L: 91,
+        S: this,
+        C: (i, n) => i(...n)
+      }), s.candidate)
+        try {
+          await this._options.sendSignal({
+            payload: {
+              data: {
+                type: "candidate",
+                candidate: {
+                  candidate: s.candidate.candidate,
+                  // These fields never seem to be not null, but connecting to Chrome doesn't work if they are.
+                  sdpMLineIndex: s.candidate.sdpMLineIndex ?? 0,
+                  sdpMid: s.candidate.sdpMid ?? 0
+                }
+              }
+            }
+          });
+        } catch (i) {
+          a.info("signaling error", {
+            err: i
+          }, {
+            F: b,
+            L: 108,
+            S: this,
+            C: (n, r) => n(...r)
+          });
+        }
+    }, this._options.initiator ? (f(this._peer, "not open", {
+      F: b,
+      L: 114,
+      S: this,
+      A: [
+        "this._peer",
+        "'not open'"
+      ]
+    }), this._peer.createOffer().then(async (s) => {
+      var i;
+      this._closed || (((i = this._peer) == null ? void 0 : i.connectionState) !== "connecting" && (a.error("peer not connecting", {
+        peer: this._peer
+      }, {
+        F: b,
+        L: 125,
+        S: this,
+        C: (n, r) => n(...r)
+      }), this.errors.raise(new Error("invalid state: peer is initiator, but other peer not in state connecting"))), a.debug("creating offer", {
+        peer: this._peer,
+        offer: s
+      }, {
+        F: b,
+        L: 129,
+        S: this,
+        C: (n, r) => n(...r)
+      }), await this._peer.setLocalDescription(s), await this._options.sendSignal({
+        payload: {
+          data: {
+            type: s.type,
+            sdp: s.sdp
+          }
+        }
+      }));
+    }).catch((s) => {
+      this.errors.raise(s);
+    }), this._handleChannel(this._peer.createDataChannel(tt)), a.debug("created data channel", void 0, {
+      F: b,
+      L: 139,
+      S: this,
+      C: (s, i) => s(...i)
+    }), this._peer.ondatachannel = () => {
+      this.errors.raise(new Error("unexpected ondatachannel event for initiator"));
+    }) : this._peer.ondatachannel = (s) => {
+      a.debug("peer.ondatachannel (non-initiator)", {
+        event: s
+      }, {
+        F: b,
+        L: 145,
+        S: this,
+        C: (i, n) => i(...n)
+      }), s.channel.label !== tt && this.errors.raise(new Error(`unexpected channel label ${s.channel.label}`)), this._handleChannel(s.channel);
+    }, B._instanceCount++;
+  }
+  async close() {
+    await this._close(), --B._instanceCount === 0 && (await it("node-datachannel")).cleanup();
+  }
+  async _close() {
+    var e;
+    if (!this._closed) {
+      await this._disconnectStreams();
+      try {
+        (e = this._peer) == null || e.close();
+      } catch (s) {
+        this.errors.raise(s);
+      }
+      this._peer = void 0, this._closed = !0, this.closed.emit();
+    }
+  }
+  /**
+  * Handle data channel events.
+  */
+  _handleChannel(e) {
+    this._channel = e, this._channel.onopen = () => {
+      a.debug("channel.onopen", void 0, {
+        F: b,
+        L: 190,
+        S: this,
+        C: (i, n) => i(...n)
+      });
+      const s = new as.Duplex({
+        read: () => {
+        },
+        write: async (i, n, r) => {
+          i.length > st && this.errors.raise(new Error(`message too large: ${i.length} > ${st}`));
+          try {
+            e.send(i);
+          } catch (o) {
+            this.errors.raise(o), await this._close();
+          }
+          this._channel.bufferedAmount > ii ? (this._writeCallback !== null && a.error("consumer trying to write before we are ready for more data", void 0, {
+            F: b,
+            L: 207,
+            S: this,
+            C: (o, c) => o(...c)
+          }), this._writeCallback = r) : r();
+        }
+      });
+      s.pipe(this._options.stream).pipe(s), this._stream = s, this._connected = !0, this.connected.emit();
+    }, this._channel.onclose = async (s) => {
+      a.info("channel.onclose", {
+        err: s
+      }, {
+        F: b,
+        L: 223,
+        S: this,
+        C: (i, n) => i(...n)
+      }), await this._close();
+    }, this._channel.onerror = async (s) => {
+      this.errors.raise(new Error("channel error: " + s.toString())), await this._close();
+    }, this._channel.onbufferedamountlow = () => {
+      const s = this._writeCallback;
+      this._writeCallback = null, s == null || s();
+    }, this._channel.onmessage = (s) => {
+      let i = s.data;
+      i instanceof ArrayBuffer && (i = X.from(i)), this._stream.push(i);
+    };
+  }
+  async onSignal(e) {
+    f(this._peer, "not open", {
+      F: b,
+      L: 249,
+      S: this,
+      A: [
+        "this._peer",
+        "'not open'"
+      ]
+    });
+    try {
+      const s = e.payload.data;
+      switch (s.type) {
+        case "offer": {
+          if (this._peer.connectionState !== "new") {
+            a.error("received offer but peer not in state new", {
+              peer: this._peer
+            }, {
+              F: b,
+              L: 256,
+              S: this,
+              C: (i, n) => i(...n)
+            }), this.errors.raise(new Error("invalid signalling state: received offer when peer is not in state new"));
+            break;
+          }
+          try {
+            await this._peer.setRemoteDescription({
+              type: s.type,
+              sdp: s.sdp
+            });
+            const i = await this._peer.createAnswer();
+            await this._peer.setLocalDescription(i), await this._options.sendSignal({
+              payload: {
+                data: {
+                  type: i.type,
+                  sdp: i.sdp
+                }
+              }
+            }), this._readyForCandidates.wake();
+          } catch (i) {
+            a.error("cannot handle offer from signalling server", {
+              err: i
+            }, {
+              F: b,
+              L: 268,
+              S: this,
+              C: (n, r) => n(...r)
+            }), this.errors.raise(new Error("error handling offer"));
+          }
+          break;
+        }
+        case "answer":
+          try {
+            await this._peer.setRemoteDescription({
+              type: s.type,
+              sdp: s.sdp
+            }), this._readyForCandidates.wake();
+          } catch (i) {
+            a.error("cannot handle answer from signalling server", {
+              err: i
+            }, {
+              F: b,
+              L: 279,
+              S: this,
+              C: (n, r) => n(...r)
+            }), this.errors.raise(new Error("error handling answer"));
+          }
+          break;
+        case "candidate":
+          await this._readyForCandidates.wait(), await this._peer.addIceCandidate({
+            candidate: s.candidate.candidate
+          });
+          break;
+        default:
+          a.error("unhandled signal type", {
+            type: s.type,
+            signal: e
+          }, {
+            F: b,
+            L: 290,
+            S: this,
+            C: (i, n) => i(...n)
+          }), this.errors.raise(new Error(`unhandled signal type ${s.type}`));
+      }
+    } catch (s) {
+      a.catch(s, void 0, {
+        F: b,
+        L: 294,
+        S: this,
+        C: (i, n) => i(...n)
+      });
+    }
+  }
+  async getDetails() {
+    const e = await this._getStats(), s = e == null ? void 0 : e.remoteCandidate;
+    return s ? s.candidateType === "relay" ? `${s.ip}:${s.port} relay for ${s.relatedAddress}:${s.relatedPort}` : `${s.ip}:${s.port} ${s.candidateType}` : "unavailable";
+  }
+  async getStats() {
+    const e = await this._getStats();
+    return e ? {
+      bytesSent: e.transport.bytesSent,
+      bytesReceived: e.transport.bytesReceived,
+      packetsSent: 0,
+      packetsReceived: 0,
+      rawStats: e.raw
+    } : {
+      bytesSent: 0,
+      bytesReceived: 0,
+      packetsSent: 0,
+      packetsReceived: 0,
+      rawStats: {}
+    };
+  }
+  async _getStats() {
+    f(this._peer, "not open", {
+      F: b,
+      L: 334,
+      S: this,
+      A: [
+        "this._peer",
+        "'not open'"
+      ]
+    });
+    const e = await this._peer.getStats(), s = Array.from(e.entries()), i = s.filter((c) => c[1].type === "transport")[0][1], n = s.filter((c) => c[0] === i.selectedCandidatePairId);
+    let r, o;
+    return n.length > 0 && (r = n[0][1], o = s.filter((c) => c[0] === r.remoteCandidateId)[0][1]), {
+      transport: i,
+      selectedCandidatePair: r,
+      remoteCandidate: o,
+      raw: Object.fromEntries(e)
+    };
+  }
+  async _disconnectStreams() {
+    var e, s, i, n;
+    (n = (i = (s = (e = this._options.stream).unpipe) == null ? void 0 : s.call(e, this._stream)) == null ? void 0 : i.unpipe) == null || n.call(i, this._options.stream);
+  }
+}, B._instanceCount = 0, B);
+si([
+  F
+], ni.prototype, "_close", null);
+var it = Function("path", "return import(path)");
+export {
+  fe as Connection,
+  Vs as ConnectionLimiter,
+  Js as ConnectionLog,
+  P as ConnectionState,
+  Ze as EventType,
+  ni as LibDataChannelTransport,
+  Xs as MAX_CONCURRENT_INITIATING_CONNECTIONS,
+  wt as MemoryTransport,
+  ti as SimplePeerTransport,
+  hi as SimplePeerTransportService,
+  j as Swarm,
+  Ws as SwarmMapper,
+  Hs as SwarmMessenger,
+  mt as SwarmNetworkManager,
+  et as TransportKind
+};
+//# sourceMappingURL=index-DXRmq0_o.mjs.map