@dxos/network-manager 0.10.0 → 0.11.1

package/dist/lib/browser/chunk-ERB3AQAF.mjs

@@ -1,3095 +0,0 @@
-import "@dxos/node-std/globals";
-
-// src/swarm/connection.ts
-import { DeferredTask, Event, Trigger, scheduleTask, scheduleTaskInterval, sleep, synchronized } from "@dxos/async";
-import { Context, ContextDisposedError, cancelWithContext } from "@dxos/context";
-import { ErrorStream } from "@dxos/debug";
-import { invariant } from "@dxos/invariant";
-import { log, logInfo } from "@dxos/log";
-import { CancelledError, ConnectionResetError, ConnectivityError, ProtocolError, TimeoutError } from "@dxos/protocols";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var STARTING_SIGNALLING_DELAY = 10;
-var TRANSPORT_CONNECTION_TIMEOUT = 1e4;
-var TRANSPORT_STATS_INTERVAL = 5e3;
-var MAX_SIGNALLING_DELAY = 300;
-var ConnectionState = /* @__PURE__ */ (function(ConnectionState5) {
-  ConnectionState5["CREATED"] = "CREATED";
-  ConnectionState5["INITIAL"] = "INITIAL";
-  ConnectionState5["CONNECTING"] = "CONNECTING";
-  ConnectionState5["CONNECTED"] = "CONNECTED";
-  ConnectionState5["CLOSING"] = "CLOSING";
-  ConnectionState5["CLOSED"] = "CLOSED";
-  ConnectionState5["ABORTING"] = "ABORTING";
-  ConnectionState5["ABORTED"] = "ABORTED";
-  return ConnectionState5;
-})({});
-var Connection = class {
-  topic;
-  localInfo;
-  remoteInfo;
-  sessionId;
-  initiator;
-  _signalMessaging;
-  _protocol;
-  _transportFactory;
-  _callbacks;
-  _ctx = new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 66 });
-  connectedTimeoutContext = new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 67 });
-  _protocolClosed = new Trigger();
-  _transportClosed = new Trigger();
-  _state = "CREATED";
-  _transport;
-  closeReason;
-  _incomingSignalBuffer = [];
-  _outgoingSignalBuffer = [];
-  stateChanged = new Event();
-  errors = new ErrorStream();
-  transportStats = new Event();
-  _signalSendTask = new DeferredTask(this._ctx, async () => {
-    await this._flushSignalBuffer(this._ctx);
-  });
-  _signallingDelay = STARTING_SIGNALLING_DELAY;
-  constructor(topic, localInfo, remoteInfo, sessionId, initiator, _signalMessaging, _protocol, _transportFactory, _callbacks) {
-    this.topic = topic;
-    this.localInfo = localInfo;
-    this.remoteInfo = remoteInfo;
-    this.sessionId = sessionId;
-    this.initiator = initiator;
-    this._signalMessaging = _signalMessaging;
-    this._protocol = _protocol;
-    this._transportFactory = _transportFactory;
-    this._callbacks = _callbacks;
-    log.trace("dxos.mesh.connection.construct", {
-      sessionId: this.sessionId,
-      topic: this.topic,
-      localPeer: this.localInfo,
-      remotePeer: this.remoteInfo,
-      initiator: this.initiator
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 92, S: this });
-  }
-  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() {
-    invariant(this._state === "INITIAL", "Invalid state.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 115, S: this, A: ['this._state === "INITIAL"', "'Invalid state.'"] });
-    log("opening connection", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 116, S: this });
-    log.trace("dxos.mesh.connection.open", {
-      sessionId: this.sessionId,
-      topic: this.topic,
-      localPeerId: this.localInfo,
-      remotePeerId: this.remoteInfo,
-      initiator: this.initiator
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 117, S: this });
-    this._changeState("CONNECTING");
-    this._protocol.open(this.sessionId).catch((err) => {
-      this.errors.raise(err);
-    });
-    this._protocol.stream.on("close", () => {
-      log("protocol stream closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 131, S: this });
-      this._protocolClosed.wake();
-      this.close({
-        error: new ProtocolError({
-          message: "protocol stream closed"
-        })
-      }).catch((err) => this.errors.raise(err));
-    });
-    scheduleTask(this.connectedTimeoutContext, async () => {
-      log.info(`timeout waiting ${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect, aborting`, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 140, S: this });
-      await this.abort(new TimeoutError({
-        message: `${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect`
-      })).catch((err) => this.errors.raise(err));
-    }, TRANSPORT_CONNECTION_TIMEOUT);
-    invariant(!this._transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 145, S: this, A: ["!this._transport", ""] });
-    this._transport = this._transportFactory.createTransport({
-      ownPeerKey: this.localInfo.peerKey,
-      remotePeerKey: this.remoteInfo.peerKey,
-      topic: this.topic.toHex(),
-      initiator: this.initiator,
-      stream: this._protocol.stream,
-      sendSignal: async (signal) => this._sendSignal(signal),
-      sessionId: this.sessionId
-    });
-    this._transport.connected.once(async () => {
-      this._changeState("CONNECTED");
-      await this.connectedTimeoutContext.dispose();
-      this._callbacks?.onConnected?.();
-      scheduleTaskInterval(this._ctx, async () => this._emitTransportStats(), TRANSPORT_STATS_INTERVAL);
-    });
-    this._transport.closed.once(() => {
-      this._transport = void 0;
-      this._transportClosed.wake();
-      log("abort triggered by transport close", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 164, S: this });
-      this.abort().catch((err) => this.errors.raise(err));
-    });
-    this._transport.errors.handle(async (err) => {
-      log("transport error:", {
-        err
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 168, S: this });
-      if (!this.closeReason) {
-        this.closeReason = err?.message;
-      }
-      if (err instanceof ConnectionResetError) {
-        log.info("aborting due to transport ConnectionResetError", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 176, S: this });
-        this.abort(err).catch((err2) => this.errors.raise(err2));
-      } else if (err instanceof ConnectivityError) {
-        log.info("aborting due to transport ConnectivityError", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 179, S: this });
-        this.abort(err).catch((err2) => this.errors.raise(err2));
-      }
-      if (this._state !== "CLOSED" && this._state !== "CLOSING") {
-        await this.connectedTimeoutContext.dispose();
-        this.errors.raise(err);
-      }
-    });
-    await this._transport.open();
-    for (const signal of this._incomingSignalBuffer) {
-      void this._transport.onSignal(signal);
-    }
-    this._incomingSignalBuffer = [];
-    log("opened connection", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 193, S: this });
-  }
-  async abort(err) {
-    log("abort", {
-      err
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 196, S: this });
-    if (this._state === "CLOSED" || this._state === "ABORTED") {
-      log(`abort ignored: already ${this._state}`, this.closeReason, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 200, S: this });
-      return;
-    }
-    await this.connectedTimeoutContext.dispose();
-    this._changeState("ABORTING");
-    if (!this.closeReason) {
-      this.closeReason = err?.message;
-    }
-    await this._ctx.dispose();
-    log("aborting...", {
-      peerId: this.localInfo,
-      err
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 209, S: this });
-    try {
-      await this._closeProtocol({
-        abort: true
-      });
-    } catch (err2) {
-      log.catch(err2, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 219, S: this });
-    }
-    try {
-      await this._closeTransport();
-    } catch (err2) {
-      log.catch(err2, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 225, S: this });
-    }
-    try {
-      this._callbacks?.onClosed?.(err);
-    } catch (err2) {
-      log.catch(err2, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 230, S: this });
-    }
-    this._changeState("ABORTED");
-  }
-  async close({ error, reason } = {}) {
-    log("close", {
-      error
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 235, S: this });
-    if (!this.closeReason) {
-      this.closeReason = reason ?? error?.message;
-    } else {
-      this.closeReason += `; ${reason ?? error?.message}`;
-    }
-    if (this._state === "CLOSED" || this._state === "ABORTING" || this._state === "ABORTED") {
-      log("close ignored: already in progress", {
-        state: this._state,
-        error
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 244, S: this });
-      return;
-    }
-    const lastState = this._state;
-    this._changeState("CLOSING");
-    await this.connectedTimeoutContext.dispose();
-    await this._ctx.dispose();
-    let abortProtocol = false;
-    if (lastState !== "CONNECTED" || error != null) {
-      log(`graceful close requested when we were in ${lastState} state? aborting`, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 256, S: this });
-      abortProtocol = true;
-    }
-    log("closing...", {
-      peerId: this.localInfo,
-      abortProtocol,
-      error
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 259, S: this });
-    try {
-      await this._closeProtocol({
-        abort: abortProtocol
-      });
-    } catch (err) {
-      log.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 269, S: this });
-    }
-    try {
-      await this._closeTransport();
-    } catch (err) {
-      log.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 275, S: this });
-    }
-    log("closed", {
-      peerId: this.localInfo
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 277, S: this });
-    this._changeState("CLOSED");
-    this._callbacks?.onClosed?.(error);
-  }
-  async _closeProtocol(options) {
-    log("closing protocol", options, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 284, S: this });
-    await Promise.race([
-      options?.abort ? this._protocol.abort() : this._protocol.close(),
-      this._protocolClosed.wait()
-    ]);
-    log("protocol closed", options, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 289, S: this });
-  }
-  async _closeTransport() {
-    log("closing transport", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 292, S: this });
-    await Promise.race([
-      this._transport?.close(),
-      this._transportClosed.wait()
-    ]);
-    log("transport closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 297, S: this });
-  }
-  _sendSignal(signal) {
-    this._outgoingSignalBuffer.push(signal);
-    this._signalSendTask.schedule();
-  }
-  async _flushSignalBuffer(ctx) {
-    if (this._outgoingSignalBuffer.length === 0) {
-      return;
-    }
-    try {
-      if (true) {
-        await cancelWithContext(ctx, sleep(this._signallingDelay));
-        this._signallingDelay = Math.min(this._signallingDelay * 2, MAX_SIGNALLING_DELAY);
-      }
-      const signals = [
-        ...this._outgoingSignalBuffer
-      ];
-      this._outgoingSignalBuffer.length = 0;
-      await this._signalMessaging.signal(ctx, {
-        author: this.localInfo,
-        recipient: this.remoteInfo,
-        sessionId: this.sessionId,
-        topic: this.topic,
-        data: {
-          signalBatch: {
-            signals
-          }
-        }
-      });
-    } catch (err) {
-      if (err instanceof CancelledError || err instanceof ContextDisposedError || err instanceof Error && err.message?.includes("CANCELLED")) {
-        return;
-      }
-      log.info("signal message failed to deliver", {
-        err
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 333, S: this });
-      await this.close({
-        error: new ConnectivityError({
-          message: "signal message failed to deliver",
-          cause: err
-        })
-      });
-    }
-  }
-  /**
-  * Receive a signal from the remote peer.
-  */
-  async signal(_ctx, msg) {
-    invariant(msg.sessionId, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 347, S: this, A: ["msg.sessionId", ""] });
-    if (!msg.sessionId.equals(this.sessionId)) {
-      log("dropping signal for incorrect session id", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 349, S: this });
-      return;
-    }
-    invariant(msg.data.signal || msg.data.signalBatch, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 352, S: this, A: ["msg.data.signal || msg.data.signalBatch", ""] });
-    invariant(msg.author.peerKey === this.remoteInfo.peerKey, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 353, S: this, A: ["msg.author.peerKey === this.remoteInfo.peerKey", ""] });
-    invariant(msg.recipient.peerKey === this.localInfo.peerKey, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 354, S: this, A: ["msg.recipient.peerKey === this.localInfo.peerKey", ""] });
-    const signals = msg.data.signalBatch ? msg.data.signalBatch.signals ?? [] : [
-      msg.data.signal
-    ];
-    for (const signal of signals) {
-      if (!signal) {
-        continue;
-      }
-      if ([
-        "CREATED",
-        "INITIAL"
-      ].includes(this.state)) {
-        log("buffered signal", {
-          peerId: this.localInfo,
-          remoteId: this.remoteInfo,
-          msg: msg.data
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 366, S: this });
-        this._incomingSignalBuffer.push(signal);
-      } else {
-        invariant(this._transport, "Connection not ready to accept signals.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 373, S: this, A: ["this._transport", "'Connection not ready to accept signals.'"] });
-        log("received signal", {
-          peerId: this.localInfo,
-          remoteId: this.remoteInfo,
-          msg: msg.data
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 374, S: this });
-        await this._transport.onSignal(signal);
-      }
-    }
-  }
-  initiate() {
-    this._changeState("INITIAL");
-  }
-  _changeState(state) {
-    log("stateChanged", {
-      from: this._state,
-      to: state,
-      peerId: this.localInfo
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 387, S: this });
-    invariant(state !== this._state, "Already in this state.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 392, S: this, A: ["state !== this._state", "'Already in this state.'"] });
-    this._state = state;
-    this.stateChanged.emit(state);
-  }
-  async _emitTransportStats() {
-    const stats = await this.transport?.getStats();
-    if (stats) {
-      this.transportStats.emit(stats);
-    }
-  }
-};
-_ts_decorate([
-  logInfo
-], Connection.prototype, "sessionIdString", null);
-_ts_decorate([
-  synchronized
-], Connection.prototype, "abort", null);
-_ts_decorate([
-  synchronized
-], Connection.prototype, "close", null);
-
-// src/signal/swarm-messenger.ts
-import { invariant as invariant2 } from "@dxos/invariant";
-import { PublicKey } from "@dxos/keys";
-import { log as log2 } from "@dxos/log";
-import { TimeoutError as TimeoutError2 } from "@dxos/protocols";
-import { schema } from "@dxos/protocols/proto";
-import { ComplexMap } from "@dxos/util";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/signal/swarm-messenger.ts";
-var SwarmMessage = schema.getCodecForType("dxos.mesh.swarm.SwarmMessage");
-var SwarmMessenger = class {
-  _sendMessage;
-  _onSignal;
-  _onOffer;
-  _topic;
-  _offerRecords = new ComplexMap((key) => key.toHex());
-  constructor({ sendMessage, onSignal, onOffer, topic }) {
-    this._sendMessage = sendMessage;
-    this._onSignal = onSignal;
-    this._onOffer = onOffer;
-    this._topic = topic;
-  }
-  async receiveMessage(ctx, { author, recipient, payload }) {
-    if (payload.type_url !== "dxos.mesh.swarm.SwarmMessage") {
-      return;
-    }
-    const message = SwarmMessage.decode(payload.value);
-    if (!this._topic.equals(message.topic)) {
-      return;
-    }
-    log2("received", {
-      from: author,
-      to: recipient,
-      msg: message
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 35, S: this });
-    if (message.data?.offer) {
-      await this._handleOffer(ctx, {
-        author,
-        recipient,
-        message
-      });
-    } else if (message.data?.answer) {
-      await this._resolveAnswers(message);
-    } else if (message.data?.signal) {
-      await this._handleSignal(ctx, {
-        author,
-        recipient,
-        message
-      });
-    } else if (message.data?.signalBatch) {
-      await this._handleSignal(ctx, {
-        author,
-        recipient,
-        message
-      });
-    } else {
-      log2.warn("unknown message", {
-        message
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 61, S: this });
-    }
-  }
-  async signal(ctx, message) {
-    invariant2(message.data?.signal || message.data?.signalBatch, "Invalid message", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 67, S: this, A: ["message.data?.signal || message.data?.signalBatch", "'Invalid message'"] });
-    await this._sendReliableMessage(ctx, {
-      author: message.author,
-      recipient: message.recipient,
-      message
-    });
-  }
-  async offer(ctx, message) {
-    const networkMessage = {
-      ...message,
-      messageId: PublicKey.random()
-    };
-    return new Promise((resolve, reject) => {
-      this._offerRecords.set(networkMessage.messageId, {
-        resolve
-      });
-      this._sendReliableMessage(ctx, {
-        author: message.author,
-        recipient: message.recipient,
-        message: networkMessage
-      }).catch((err) => reject(err));
-    });
-  }
-  async _sendReliableMessage(ctx, { author, recipient, message }) {
-    const networkMessage = {
-      ...message,
-      // Setting unique message_id if it not specified yet.
-      messageId: message.messageId ?? PublicKey.random()
-    };
-    log2("sending", {
-      from: author,
-      to: recipient,
-      msg: networkMessage
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 96, S: this });
-    await this._sendMessage(ctx, {
-      author,
-      recipient,
-      payload: {
-        type_url: "dxos.mesh.swarm.SwarmMessage",
-        value: SwarmMessage.encode(networkMessage)
-      }
-    });
-  }
-  async _resolveAnswers(message) {
-    invariant2(message.data?.answer?.offerMessageId, "No offerMessageId", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 111, S: this, A: ["message.data?.answer?.offerMessageId", "'No offerMessageId'"] });
-    const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
-    if (offerRecord) {
-      this._offerRecords.delete(message.data.answer.offerMessageId);
-      invariant2(message.data?.answer, "No answer", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 115, S: this, A: ["message.data?.answer", "'No answer'"] });
-      log2("resolving", {
-        answer: message.data.answer
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 116, S: this });
-      offerRecord.resolve(message.data.answer);
-    }
-  }
-  async _handleOffer(ctx, { author, recipient, message }) {
-    invariant2(message.data.offer, "No offer", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 123, S: this, A: ["message.data.offer", "'No offer'"] });
-    const offerMessage = {
-      author,
-      recipient,
-      ...message,
-      data: {
-        offer: message.data.offer
-      }
-    };
-    const answer = await this._onOffer(ctx, offerMessage);
-    answer.offerMessageId = message.messageId;
-    try {
-      await this._sendReliableMessage(ctx, {
-        author: recipient,
-        recipient: author,
-        message: {
-          topic: message.topic,
-          sessionId: message.sessionId,
-          data: {
-            answer
-          }
-        }
-      });
-    } catch (err) {
-      if (err instanceof TimeoutError2) {
-        log2.info("timeout sending answer to offer", {
-          err
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 148, S: this });
-      } else {
-        log2.info("error sending answer to offer", {
-          err
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 152, S: this });
-      }
-    }
-  }
-  async _handleSignal(ctx, { author, recipient, message }) {
-    invariant2(message.messageId, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 159, S: this, A: ["message.messageId", ""] });
-    invariant2(message.data.signal || message.data.signalBatch, "Invalid message", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 160, S: this, A: ["message.data.signal || message.data.signalBatch", "'Invalid message'"] });
-    const signalMessage = {
-      author,
-      recipient,
-      ...message,
-      data: {
-        signal: message.data.signal,
-        signalBatch: message.data.signalBatch
-      }
-    };
-    await this._onSignal(ctx, signalMessage);
-  }
-};
-
-// src/swarm/swarm.ts
-import { Event as Event3, scheduleTask as scheduleTask3, sleep as sleep2, synchronized as synchronized3 } from "@dxos/async";
-import { Context as Context3 } from "@dxos/context";
-import { ErrorStream as ErrorStream2 } from "@dxos/debug";
-import { invariant as invariant4 } from "@dxos/invariant";
-import { PublicKey as PublicKey3 } from "@dxos/keys";
-import { log as log4, logInfo as logInfo2 } from "@dxos/log";
-import { PeerInfoHash } from "@dxos/messaging";
-import { ComplexMap as ComplexMap2, isNonNullable } from "@dxos/util";
-
-// src/swarm/peer.ts
-import { Event as Event2, scheduleTask as scheduleTask2, synchronized as synchronized2 } from "@dxos/async";
-import { Context as Context2 } from "@dxos/context";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
-import { log as log3 } from "@dxos/log";
-import { CancelledError as CancelledError2, SystemError } from "@dxos/protocols";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts";
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var ConnectionDisplacedError = class extends SystemError {
-  constructor() {
-    super({
-      message: "Connection displaced by remote initiator."
-    });
-  }
-};
-var CONNECTION_COUNTS_STABLE_AFTER = 5e3;
-var Peer = class {
-  remoteInfo;
-  topic;
-  localInfo;
-  _signalMessaging;
-  _protocolProvider;
-  _transportFactory;
-  _connectionLimiter;
-  _callbacks;
-  /**
-  * Will be available to connect after this time.
-  */
-  _availableAfter = 0;
-  availableToConnect = true;
-  _lastConnectionTime;
-  _ctx = new Context2(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 44 });
-  _connectionCtx;
-  connection;
-  /**
-  * Whether the peer is currently advertizing itself on the signal-network.
-  */
-  advertizing = false;
-  initiating = false;
-  connectionDisplaced = new Event2();
-  constructor(remoteInfo, topic, localInfo, _signalMessaging, _protocolProvider, _transportFactory, _connectionLimiter, _callbacks) {
-    this.remoteInfo = remoteInfo;
-    this.topic = topic;
-    this.localInfo = localInfo;
-    this._signalMessaging = _signalMessaging;
-    this._protocolProvider = _protocolProvider;
-    this._transportFactory = _transportFactory;
-    this._connectionLimiter = _connectionLimiter;
-    this._callbacks = _callbacks;
-  }
-  /**
-  * Respond to remote offer.
-  */
-  async onOffer(_ctx, message) {
-    const remote = message.author;
-    if (this.connection && ![
-      ConnectionState.CREATED,
-      ConnectionState.INITIAL,
-      ConnectionState.CONNECTING
-    ].includes(this.connection.state)) {
-      log3.info(`received offer when connection already in ${this.connection.state} state`, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 71, S: this });
-      return {
-        accept: false
-      };
-    }
-    if (this.connection || this.initiating) {
-      if (remote.peerKey < this.localInfo.peerKey) {
-        log3("close local connection", {
-          localPeer: this.localInfo,
-          topic: this.topic,
-          remotePeer: this.remoteInfo,
-          sessionId: this.connection?.sessionId
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 82, S: this });
-        if (this.connection) {
-          await this.closeConnection(new ConnectionDisplacedError());
-        }
-      } else {
-        return {
-          accept: false
-        };
-      }
-    }
-    if (await this._callbacks.onOffer(remote)) {
-      if (!this.connection) {
-        invariant3(message.sessionId, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 102, S: this, A: ["message.sessionId", ""] });
-        const connection = this._createConnection(false, message.sessionId);
-        try {
-          await this._connectionLimiter.connecting(message.sessionId);
-          connection.initiate();
-          await connection.openConnection();
-        } catch (err) {
-          if (!(err instanceof CancelledError2)) {
-            log3.info("connection error", {
-              topic: this.topic,
-              peerId: this.localInfo,
-              remoteId: this.remoteInfo,
-              err
-            }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 110, S: this });
-          }
-          await this.closeConnection(err);
-        }
-        return {
-          accept: true
-        };
-      }
-    }
-    return {
-      accept: false
-    };
-  }
-  /**
-  * Initiate a connection to the remote peer.
-  */
-  async initiateConnection(ctx) {
-    invariant3(!this.initiating, "Initiation in progress.", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 132, S: this, A: ["!this.initiating", "'Initiation in progress.'"] });
-    invariant3(!this.connection, "Already connected.", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 133, S: this, A: ["!this.connection", "'Already connected.'"] });
-    const sessionId = PublicKey2.random();
-    log3("initiating...", {
-      local: this.localInfo,
-      topic: this.topic,
-      remote: this.remoteInfo,
-      sessionId
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 135, S: this });
-    const connection = this._createConnection(true, sessionId);
-    this.initiating = true;
-    let answer;
-    try {
-      await this._connectionLimiter.connecting(sessionId);
-      connection.initiate();
-      answer = await this._signalMessaging.offer(ctx, {
-        author: this.localInfo,
-        recipient: this.remoteInfo,
-        sessionId,
-        topic: this.topic,
-        data: {
-          offer: {}
-        }
-      });
-      log3("received", {
-        answer,
-        topic: this.topic,
-        local: this.localInfo,
-        remote: this.remoteInfo
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 156, S: this });
-      if (connection.state !== ConnectionState.INITIAL) {
-        log3("ignoring response", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 163, S: this });
-        return;
-      }
-    } catch (err) {
-      log3("initiation error: send offer", {
-        err,
-        topic: this.topic,
-        local: this.localInfo,
-        remote: this.remoteInfo
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 167, S: this });
-      await connection.abort(err);
-      throw err;
-    } finally {
-      this.initiating = false;
-    }
-    try {
-      if (!answer.accept) {
-        this._callbacks.onRejected();
-        return;
-      }
-    } catch (err) {
-      log3("initiation error: accept answer", {
-        err,
-        topic: this.topic,
-        local: this.localInfo,
-        remote: this.remoteInfo
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 184, S: this });
-      await connection.abort(err);
-      throw err;
-    } finally {
-      this.initiating = false;
-    }
-    try {
-      log3("opening connection as initiator", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 196, S: this });
-      await connection.openConnection();
-      this._callbacks.onAccepted();
-    } catch (err) {
-      log3("initiation error: open connection", {
-        err,
-        topic: this.topic,
-        local: this.localInfo,
-        remote: this.remoteInfo
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 200, S: this });
-      log3.warn("closing connection due to unhandled error on openConnection", {
-        err
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 207, S: this });
-      await this.closeConnection(err);
-      throw err;
-    } finally {
-      this.initiating = false;
-    }
-  }
-  /**
-  * Create new connection.
-  * Either we're initiating a connection or creating one in response to an offer from the other peer.
-  */
-  _createConnection(initiator, sessionId) {
-    log3("creating connection", {
-      topic: this.topic,
-      peerId: this.localInfo,
-      remoteId: this.remoteInfo,
-      initiator,
-      sessionId
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 221, S: this });
-    invariant3(!this.connection, "Already connected.", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 228, S: this, A: ["!this.connection", "'Already connected.'"] });
-    const connection = new Connection(
-      this.topic,
-      this.localInfo,
-      this.remoteInfo,
-      sessionId,
-      initiator,
-      this._signalMessaging,
-      // TODO(dmaretskyi): Init only when connection is established.
-      this._protocolProvider({
-        initiator,
-        localPeerId: PublicKey2.from(this.localInfo.peerKey),
-        remotePeerId: PublicKey2.from(this.remoteInfo.peerKey),
-        topic: this.topic
-      }),
-      this._transportFactory,
-      {
-        onConnected: () => {
-          this.availableToConnect = true;
-          this._lastConnectionTime = Date.now();
-          this._callbacks.onConnected();
-          this._connectionLimiter.doneConnecting(sessionId);
-          log3.trace("dxos.mesh.connection.connected", {
-            topic: this.topic,
-            localPeerId: this.localInfo,
-            remotePeerId: this.remoteInfo,
-            sessionId,
-            initiator
-          }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 241, S: this });
-        },
-        onClosed: (err) => {
-          const logMeta = {
-            topic: this.topic,
-            peerId: this.localInfo,
-            remoteId: this.remoteInfo,
-            initiator
-          };
-          log3("connection closed", logMeta, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 256, S: this });
-          this._connectionLimiter.doneConnecting(sessionId);
-          invariant3(this.connection === connection, "Connection mismatch (race condition).", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 259, S: this, A: ["this.connection === connection", "'Connection mismatch (race condition).'"] });
-          log3.trace("dxos.mesh.connection.closed", {
-            topic: this.topic,
-            localPeerId: this.localInfo,
-            remotePeerId: this.remoteInfo,
-            sessionId,
-            initiator
-          }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 260, S: this });
-          if (err instanceof ConnectionDisplacedError) {
-            this.connectionDisplaced.emit(this.connection);
-          } else {
-            if (this._lastConnectionTime && this._lastConnectionTime + CONNECTION_COUNTS_STABLE_AFTER < Date.now()) {
-              this._availableAfter = 0;
-            } else {
-              this.availableToConnect = false;
-              this._availableAfter = increaseInterval(this._availableAfter);
-            }
-            this._callbacks.onDisconnected();
-            scheduleTask2(this._connectionCtx, () => {
-              log3("peer became available", logMeta, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 279, S: this });
-              this.availableToConnect = true;
-              this._callbacks.onPeerAvailable();
-            }, this._availableAfter);
-          }
-          this.connection = void 0;
-        }
-      }
-    );
-    this._callbacks.onInitiated(connection);
-    void this._connectionCtx?.dispose();
-    this._connectionCtx = this._ctx.derive();
-    connection.errors.handle((err) => {
-      log3.info("connection error, closing", {
-        topic: this.topic,
-        peerId: this.localInfo,
-        remoteId: this.remoteInfo,
-        initiator,
-        err
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 291, S: this });
-      log3.trace("dxos.mesh.connection.error", {
-        topic: this.topic,
-        localPeerId: this.localInfo,
-        remotePeerId: this.remoteInfo,
-        sessionId,
-        initiator,
-        err
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 298, S: this });
-      void this.closeConnection(err);
-    });
-    this.connection = connection;
-    return connection;
-  }
-  async closeConnection(err) {
-    if (!this.connection) {
-      return;
-    }
-    const connection = this.connection;
-    log3("closing...", {
-      peerId: this.remoteInfo,
-      sessionId: connection.sessionId
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 317, S: this });
-    await connection.close({
-      error: err
-    });
-    log3("closed", {
-      peerId: this.remoteInfo,
-      sessionId: connection.sessionId
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 326, S: this });
-  }
-  async onSignal(ctx, message) {
-    if (!this.connection) {
-      log3("dropping signal message for non-existent connection", {
-        message
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 333, S: this });
-      return;
-    }
-    await this.connection.signal(ctx, message);
-  }
-  async safeDestroy(reason) {
-    await this._ctx.dispose();
-    log3("Destroying peer", {
-      peerId: this.remoteInfo,
-      topic: this.topic
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 342, S: this });
-    await this?.connection?.close({
-      reason
-    });
-  }
-};
-_ts_decorate2([
-  synchronized2
-], Peer.prototype, "safeDestroy", null);
-var increaseInterval = (interval) => {
-  if (interval === 0) {
-    return 50;
-  } else if (interval < 500) {
-    return 500;
-  } else if (interval < 1e3) {
-    return 1e3;
-  } else if (interval < 5e3) {
-    return 5e3;
-  }
-  return 1e4;
-};
-
-// src/swarm/swarm.ts
-var __dxlog_file4 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts";
-function _ts_decorate3(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var INITIATION_DELAY = 100;
-var getClassName = (obj) => Object.getPrototypeOf(obj).constructor.name;
-var Swarm = class {
-  _topic;
-  _ownPeer;
-  _topology;
-  _protocolProvider;
-  _messenger;
-  _transportFactory;
-  _label;
-  _connectionLimiter;
-  _initiationDelay;
-  _swarmMessenger;
-  _ctx = new Context3(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 39 });
-  _listeningHandle = void 0;
-  /**
-  * PeerInfo -> Peer.
-  * @internal
-  */
-  _peers = new ComplexMap2(PeerInfoHash);
-  /**
-  * Unique id of the swarm, local to the current peer, generated when swarm is joined.
-  */
-  _instanceId = PublicKey3.random().toHex();
-  /**
-  * New connection to a peer is started.
-  * @internal
-  */
-  connectionAdded = new Event3();
-  /**
-  * Connection to a peer is dropped.
-  * @internal
-  */
-  disconnected = new Event3();
-  /**
-  * Connection is established to a new peer.
-  * @internal
-  */
-  connected = new Event3();
-  errors = new ErrorStream2();
-  // TODO(burdon): Swarm => Peer.create/destroy =< Connection.open/close
-  // TODO(burdon): Pass in object.
-  constructor(_topic, _ownPeer, _topology, _protocolProvider, _messenger, _transportFactory, _label, _connectionLimiter, _initiationDelay = INITIATION_DELAY) {
-    this._topic = _topic;
-    this._ownPeer = _ownPeer;
-    this._topology = _topology;
-    this._protocolProvider = _protocolProvider;
-    this._messenger = _messenger;
-    this._transportFactory = _transportFactory;
-    this._label = _label;
-    this._connectionLimiter = _connectionLimiter;
-    this._initiationDelay = _initiationDelay;
-    log4("creating swarm", {
-      topic: this._topic.toHex(),
-      peer: this._ownPeer
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 73, S: this });
-    _topology.init(this._getSwarmController());
-    this._swarmMessenger = new SwarmMessenger({
-      sendMessage: async (ctx, msg) => await this._messenger.sendMessage(ctx, msg),
-      onSignal: async (ctx, msg) => await this.onSignal(ctx, msg),
-      onOffer: async (ctx, msg) => await this.onOffer(ctx, msg),
-      topic: this._topic
-    });
-  }
-  get connections() {
-    return Array.from(this._peers.values()).map((peer) => peer.connection).filter(isNonNullable);
-  }
-  get ownPeerId() {
-    return PublicKey3.from(this._ownPeer.peerKey);
-  }
-  get ownPeer() {
-    return this._ownPeer;
-  }
-  /**
-  * 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() {
-    invariant4(!this._listeningHandle, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 103, S: this, A: ["!this._listeningHandle", ""] });
-    this._listeningHandle = await this._messenger.listen({
-      peer: this._ownPeer,
-      payloadType: "dxos.mesh.swarm.SwarmMessage",
-      onMessage: async (message) => {
-        await this._swarmMessenger.receiveMessage(this._ctx, message).catch((err) => log4.info("Error while receiving message", {
-          err
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 109, S: this }));
-      }
-    });
-  }
-  async destroy() {
-    log4("destroying...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 116, S: this });
-    await this._listeningHandle?.unsubscribe();
-    this._listeningHandle = void 0;
-    await this._ctx.dispose();
-    await this._topology.destroy();
-    await Promise.all(Array.from(this._peers.keys()).map((key) => this._destroyPeer(key, "swarm destroyed")));
-    log4("destroyed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 122, S: this });
-  }
-  async setTopology(topology) {
-    invariant4(!this._ctx.disposed, "Swarm is offline", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 125, S: this, A: ["!this._ctx.disposed", "'Swarm is offline'"] });
-    if (topology === this._topology) {
-      return;
-    }
-    log4("setting topology", {
-      previous: getClassName(this._topology),
-      topology: getClassName(topology)
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 129, S: this });
-    await this._topology.destroy();
-    this._topology = topology;
-    this._topology.init(this._getSwarmController());
-    this._topology.update();
-  }
-  async onSwarmEvent(swarmEvent) {
-    log4("swarm event", {
-      swarmEvent
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 139, S: this });
-    if (this._ctx.disposed) {
-      log4("swarm event ignored for disposed swarm", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 143, S: this });
-      return;
-    }
-    if (swarmEvent.peerAvailable) {
-      const peerId = swarmEvent.peerAvailable.peer.peerKey;
-      if (peerId !== this._ownPeer.peerKey) {
-        log4("new peer", {
-          peerId
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 149, S: this });
-        const peer = this._getOrCreatePeer(swarmEvent.peerAvailable.peer);
-        peer.advertizing = true;
-      }
-    } else if (swarmEvent.peerLeft) {
-      const peer = this._peers.get(swarmEvent.peerLeft.peer);
-      if (peer) {
-        peer.advertizing = false;
-        if (this._isConnectionEstablishmentInProgress(peer)) {
-          log4(`destroying peer, state: ${peer.connection?.state}`, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 162, S: this });
-          void this._destroyPeer(swarmEvent.peerLeft.peer, "peer left").catch((err) => log4.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 163, S: this }));
-        }
-      } else {
-        log4("received peerLeft but no peer found", {
-          peer: swarmEvent.peerLeft.peer.peerKey
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 166, S: this });
-      }
-    }
-    this._topology.update();
-  }
-  async onOffer(ctx, message) {
-    log4("offer", {
-      message
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 174, S: this });
-    if (this._ctx.disposed) {
-      log4("ignored for disposed swarm", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 178, S: this });
-      return {
-        accept: false
-      };
-    }
-    invariant4(message.author, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 184, S: this, A: ["message.author", ""] });
-    if (message.recipient.peerKey !== this._ownPeer.peerKey) {
-      log4("rejecting offer with incorrect peerId", {
-        message
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 186, S: this });
-      return {
-        accept: false
-      };
-    }
-    if (!message.topic?.equals(this._topic)) {
-      log4("rejecting offer with incorrect topic", {
-        message
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 194, S: this });
-      return {
-        accept: false
-      };
-    }
-    const peer = this._getOfferSenderPeer(message.author);
-    const answer = await peer.onOffer(ctx, message);
-    this._topology.update();
-    return answer;
-  }
-  _getOfferSenderPeer(senderInfo) {
-    const peer = this._getOrCreatePeer(senderInfo);
-    const connectionState = peer.connection?.state;
-    if (connectionState === ConnectionState.CLOSING || connectionState === ConnectionState.ABORTING) {
-      this._peers.delete(peer.remoteInfo);
-      this.disconnected.emit(peer.remoteInfo);
-      return this._getOrCreatePeer(peer.remoteInfo);
-    }
-    return peer;
-  }
-  async onSignal(ctx, message) {
-    log4("signal", {
-      message
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 218, S: this });
-    if (this._ctx.disposed) {
-      log4.info("ignored for offline swarm", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 222, S: this });
-      return;
-    }
-    invariant4(message.recipient.peerKey === this._ownPeer.peerKey, `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 225, S: this, A: ["message.recipient.peerKey === this._ownPeer.peerKey", "`Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`"] });
-    invariant4(message.topic?.equals(this._topic), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 226, S: this, A: ["message.topic?.equals(this._topic)", ""] });
-    invariant4(message.author, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 227, S: this, A: ["message.author", ""] });
-    const peer = this._getOrCreatePeer(message.author);
-    await peer.onSignal(ctx, message);
-  }
-  // For debug purposes
-  async goOffline() {
-    await this._ctx.dispose();
-    await Promise.all([
-      ...this._peers.keys()
-    ].map((peerId) => this._destroyPeer(peerId, "goOffline")));
-  }
-  // For debug purposes
-  async goOnline() {
-    this._ctx = new Context3(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 240 });
-  }
-  _getOrCreatePeer(peerInfo) {
-    invariant4(peerInfo.peerKey, "PeerInfo.peerKey is required", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 243, S: this, A: ["peerInfo.peerKey", "'PeerInfo.peerKey is required'"] });
-    let peer = this._peers.get(peerInfo);
-    if (!peer) {
-      peer = new Peer(peerInfo, this._topic, this._ownPeer, this._swarmMessenger, this._protocolProvider, this._transportFactory, this._connectionLimiter, {
-        onInitiated: (connection) => {
-          this.connectionAdded.emit(connection);
-        },
-        onConnected: () => {
-          this.connected.emit(peerInfo);
-        },
-        onDisconnected: async () => {
-          if (this._isUnregistered(peer)) {
-            log4.verbose("ignored onDisconnected for unregistered peer", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 255, S: this });
-            return;
-          }
-          if (!peer.advertizing) {
-            await this._destroyPeer(peerInfo, "peer disconnected");
-          }
-          this.disconnected.emit(peerInfo);
-          this._topology.update();
-        },
-        onRejected: () => {
-          if (!this._isUnregistered(peer)) {
-            log4("peer rejected connection", {
-              peerInfo
-            }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 268, S: this });
-            void this._destroyPeer(peerInfo, "peer rejected connection");
-          }
-        },
-        onAccepted: () => {
-          this._topology.update();
-        },
-        onOffer: (remoteId) => {
-          return this._topology.onOffer(PublicKey3.from(remoteId.peerKey));
-        },
-        onPeerAvailable: () => {
-          this._topology.update();
-        }
-      });
-      this._peers.set(peerInfo, peer);
-    }
-    return peer;
-  }
-  async _destroyPeer(peerInfo, reason) {
-    log4("destroy peer", {
-      peerKey: peerInfo.peerKey,
-      reason
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 289, S: this });
-    const peer = this._peers.get(peerInfo);
-    invariant4(peer, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 294, S: this, A: ["peer", ""] });
-    this._peers.delete(peerInfo);
-    await peer.safeDestroy(reason);
-  }
-  _getSwarmController() {
-    return {
-      getState: () => ({
-        ownPeerId: PublicKey3.from(this._ownPeer.peerKey),
-        connected: Array.from(this._peers.entries()).filter(([_, peer]) => peer.connection).map(([info]) => PublicKey3.from(info.peerKey)),
-        candidates: Array.from(this._peers.entries()).filter(([_, peer]) => !peer.connection && peer.advertizing && peer.availableToConnect).map(([info]) => PublicKey3.from(info.peerKey)),
-        allPeers: Array.from(this._peers.keys()).map((info) => PublicKey3.from(info.peerKey))
-      }),
-      connect: (peer) => {
-        if (this._ctx.disposed) {
-          return;
-        }
-        scheduleTask3(this._ctx, async () => {
-          try {
-            await this._initiateConnection({
-              peerKey: peer.toHex()
-            });
-          } catch (err) {
-            log4("initiation error", err, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 317, S: this });
-          }
-        });
-      },
-      disconnect: async (peer) => {
-        if (this._ctx.disposed) {
-          return;
-        }
-        scheduleTask3(this._ctx, async () => {
-          await this._closeConnection({
-            peerKey: peer.toHex()
-          });
-          this._topology.update();
-        });
-      }
-    };
-  }
-  /**
-  * Creates a connection then sends message over signal network.
-  */
-  async _initiateConnection(remotePeer) {
-    const ctx = this._ctx;
-    const peer = this._getOrCreatePeer(remotePeer);
-    if (remotePeer.peerKey < this._ownPeer.peerKey) {
-      log4("initiation delay", {
-        remotePeer
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 343, S: this });
-      await sleep2(this._initiationDelay);
-    }
-    if (ctx.disposed) {
-      return;
-    }
-    if (this._isUnregistered(peer)) {
-      throw new Error("Peer left during initiation delay");
-    }
-    if (peer.connection) {
-      return;
-    }
-    log4("initiating connection...", {
-      remotePeer
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 358, S: this });
-    await peer.initiateConnection(ctx);
-    this._topology.update();
-    log4("initiated", {
-      remotePeer
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 363, S: this });
-  }
-  async _closeConnection(peerInfo) {
-    const peer = this._peers.get(peerInfo);
-    if (!peer) {
-      return;
-    }
-    await peer.closeConnection();
-  }
-  _isConnectionEstablishmentInProgress(peer) {
-    if (!peer.connection) {
-      return true;
-    }
-    return [
-      ConnectionState.INITIAL,
-      ConnectionState.CREATED,
-      ConnectionState.CONNECTING
-    ].includes(peer.connection.state);
-  }
-  _isUnregistered(peer) {
-    return !peer || this._peers.get(peer.remoteInfo) !== peer;
-  }
-};
-_ts_decorate3([
-  logInfo2
-], Swarm.prototype, "_instanceId", void 0);
-_ts_decorate3([
-  logInfo2
-], Swarm.prototype, "ownPeer", null);
-_ts_decorate3([
-  logInfo2
-], Swarm.prototype, "topic", null);
-_ts_decorate3([
-  synchronized3
-], Swarm.prototype, "onSwarmEvent", null);
-_ts_decorate3([
-  synchronized3
-], Swarm.prototype, "onOffer", null);
-_ts_decorate3([
-  synchronized3
-], Swarm.prototype, "goOffline", null);
-_ts_decorate3([
-  synchronized3
-], Swarm.prototype, "goOnline", null);
-
-// src/swarm/swarm-mapper.ts
-import { Event as Event4, SubscriptionList } from "@dxos/async";
-import { PublicKey as PublicKey4 } from "@dxos/keys";
-import { log as log5 } from "@dxos/log";
-import { PeerInfoHash as PeerInfoHash2 } from "@dxos/messaging";
-import { ComplexMap as ComplexMap3 } from "@dxos/util";
-var __dxlog_file5 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts";
-var SwarmMapper = class {
-  _swarm;
-  _subscriptions = new SubscriptionList();
-  _connectionSubscriptions = new ComplexMap3(PeerInfoHash2);
-  _peers = new ComplexMap3(PeerInfoHash2);
-  mapUpdated = new Event4();
-  get peers() {
-    return Array.from(this._peers.values());
-  }
-  constructor(_swarm) {
-    this._swarm = _swarm;
-    this._subscriptions.add(_swarm.connectionAdded.on((connection) => {
-      this._update();
-      this._connectionSubscriptions.set(connection.remoteInfo, connection.stateChanged.on(() => {
-        this._update();
-      }));
-    }));
-    this._subscriptions.add(_swarm.disconnected.on((peerId) => {
-      this._connectionSubscriptions.get(peerId)?.();
-      this._connectionSubscriptions.delete(peerId);
-      this._update();
-    }));
-    this._update();
-  }
-  _update() {
-    log5("updating swarm", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 40, S: this });
-    this._peers.clear();
-    this._peers.set(this._swarm.ownPeer, {
-      id: this._swarm.ownPeerId,
-      state: "ME",
-      connections: []
-    });
-    for (const connection of this._swarm.connections) {
-      this._peers.set(connection.remoteInfo, {
-        id: PublicKey4.from(connection.remoteInfo.peerKey),
-        state: connection.state,
-        connections: [
-          this._swarm.ownPeerId
-        ]
-      });
-    }
-    log5("graph changed", {
-      directConnections: this._swarm.connections.length,
-      totalPeersInSwarm: this._peers.size
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 77, S: this });
-    this.mapUpdated.emit(Array.from(this._peers.values()));
-  }
-  // TODO(burdon): Async open/close.
-  destroy() {
-    Array.from(this._connectionSubscriptions.values()).forEach((cb) => cb());
-    this._connectionSubscriptions.clear();
-    this._subscriptions.clear();
-  }
-};
-
-// src/swarm/connection-limiter.ts
-import { DeferredTask as DeferredTask2 } from "@dxos/async";
-import { Context as Context4 } from "@dxos/context";
-import { invariant as invariant5 } from "@dxos/invariant";
-import { PublicKey as PublicKey5 } from "@dxos/keys";
-import { log as log6 } from "@dxos/log";
-import { CancelledError as CancelledError3 } from "@dxos/protocols";
-import { ComplexMap as ComplexMap4 } from "@dxos/util";
-var __dxlog_file6 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection-limiter.ts";
-var MAX_CONCURRENT_INITIATING_CONNECTIONS = 50;
-var ConnectionLimiter = class {
-  _ctx = new Context4(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 15 });
-  _maxConcurrentInitConnections;
-  /**
-  * Queue of promises to resolve when initiating connections amount is below the limit.
-  */
-  _waitingPromises = new ComplexMap4(PublicKey5.hash);
-  resolveWaitingPromises = new DeferredTask2(this._ctx, async () => {
-    Array.from(this._waitingPromises.values()).slice(0, this._maxConcurrentInitConnections).forEach(({ resolve }) => {
-      resolve();
-    });
-  });
-  constructor({ maxConcurrentInitConnections = MAX_CONCURRENT_INITIATING_CONNECTIONS } = {}) {
-    this._maxConcurrentInitConnections = maxConcurrentInitConnections;
-  }
-  /**
-  * @returns Promise that resolves in queue when connections amount with 'CONNECTING' state is below the limit.
-  */
-  async connecting(sessionId) {
-    invariant5(!this._waitingPromises.has(sessionId), "Peer is already waiting for connection", { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 31, S: this, A: ["!this._waitingPromises.has(sessionId)", "'Peer is already waiting for connection'"] });
-    log6("waiting", {
-      sessionId
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 32, S: this });
-    await new Promise((resolve, reject) => {
-      this._waitingPromises.set(sessionId, {
-        resolve,
-        reject
-      });
-      this.resolveWaitingPromises.schedule();
-    });
-    log6("allow", {
-      sessionId
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 42, S: this });
-  }
-  /**
-  * Rejects promise returned by `connecting` method.
-  */
-  doneConnecting(sessionId) {
-    log6("done", {
-      sessionId
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 49, S: this });
-    if (!this._waitingPromises.has(sessionId)) {
-      return;
-    }
-    this._waitingPromises.get(sessionId).reject(new CancelledError3());
-    this._waitingPromises.delete(sessionId);
-    this.resolveWaitingPromises.schedule();
-  }
-};
-
-// src/connection-log.ts
-import { Event as Event5 } from "@dxos/async";
-import { raise } from "@dxos/debug";
-import { PublicKey as PublicKey6 } from "@dxos/keys";
-import { ComplexMap as ComplexMap5 } from "@dxos/util";
-var CONNECTION_GC_THRESHOLD = 1e3 * 60 * 15;
-var EventType = /* @__PURE__ */ (function(EventType2) {
-  EventType2["CONNECTION_STATE_CHANGED"] = "CONNECTION_STATE_CHANGED";
-  EventType2["PROTOCOL_ERROR"] = "PROTOCOL_ERROR";
-  EventType2["PROTOCOL_EXTENSIONS_INITIALIZED"] = "PROTOCOL_EXTENSIONS_INITIALIZED";
-  EventType2["PROTOCOL_EXTENSIONS_HANDSHAKE"] = "PROTOCOL_EXTENSIONS_HANDSHAKE";
-  EventType2["PROTOCOL_HANDSHAKE"] = "PROTOCOL_HANDSHAKE";
-  return EventType2;
-})({});
-var ConnectionLog = class {
-  /**
-  * SwarmId => info
-  */
-  _swarms = new ComplexMap5(PublicKey6.hash);
-  update = new Event5();
-  getSwarmInfo(swarmId) {
-    return this._swarms.get(swarmId) ?? raise(new Error(`Swarm not found: ${swarmId}`));
-  }
-  get swarms() {
-    return Array.from(this._swarms.values());
-  }
-  joinedSwarm(swarm) {
-    const info = {
-      id: PublicKey6.from(swarm._instanceId),
-      topic: swarm.topic,
-      isActive: true,
-      label: swarm.label,
-      connections: []
-    };
-    this._swarms.set(PublicKey6.from(swarm._instanceId), info);
-    this.update.emit();
-    swarm.connectionAdded.on((connection) => {
-      const connectionInfo = {
-        state: ConnectionState.CREATED,
-        closeReason: connection.closeReason,
-        remotePeerId: PublicKey6.from(connection.remoteInfo.peerKey),
-        sessionId: connection.sessionId,
-        transport: connection.transport && Object.getPrototypeOf(connection.transport).constructor.name,
-        protocolExtensions: [],
-        events: [],
-        lastUpdate: /* @__PURE__ */ new Date()
-      };
-      info.connections.push(connectionInfo);
-      this.update.emit();
-      connection.stateChanged.on(async (state) => {
-        connectionInfo.state = state;
-        connectionInfo.closeReason = connection.closeReason;
-        connectionInfo.lastUpdate = /* @__PURE__ */ new Date();
-        connectionInfo.events.push({
-          type: "CONNECTION_STATE_CHANGED",
-          newState: state
-        });
-        if (state === ConnectionState.CONNECTED) {
-          const details = await connection.transport?.getDetails();
-          connectionInfo.transportDetails = details;
-        }
-        this.update.emit();
-      });
-      connection.protocol?.stats?.on((stats) => {
-        connectionInfo.readBufferSize = stats.readBufferSize;
-        connectionInfo.writeBufferSize = stats.writeBufferSize;
-        connectionInfo.streams = stats.channels;
-        connectionInfo.lastUpdate = /* @__PURE__ */ new Date();
-        this.update.emit();
-      });
-      connection.transportStats?.on((stats) => {
-        connectionInfo.transportBytesSent = stats.bytesSent;
-        connectionInfo.transportBytesReceived = stats.bytesReceived;
-        connectionInfo.transportPacketsSent = stats.packetsSent;
-        connectionInfo.transportPacketsReceived = stats.packetsReceived;
-      });
-      gcSwarm(info);
-    });
-  }
-  leftSwarm(swarm) {
-    this.getSwarmInfo(PublicKey6.from(swarm._instanceId)).isActive = false;
-    this.update.emit();
-  }
-};
-var gcSwarm = (swarm) => {
-  swarm.connections = swarm.connections?.filter((connection) => {
-    return connection.lastUpdate ? Date.now() - connection.lastUpdate.getTime() < CONNECTION_GC_THRESHOLD : true;
-  });
-};
-
-// src/network-manager.ts
-import { Event as Event6, synchronized as synchronized4 } from "@dxos/async";
-import { assertArgument, invariant as invariant6 } from "@dxos/invariant";
-import { PublicKey as PublicKey7 } from "@dxos/keys";
-import { log as log7 } from "@dxos/log";
-import { Messenger } from "@dxos/messaging";
-import { ConnectionState as ConnectionState2 } from "@dxos/protocols/proto/dxos/client/services";
-import { ComplexMap as ComplexMap6 } from "@dxos/util";
-var __dxlog_file7 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts";
-function _ts_decorate4(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var SwarmNetworkManager = class {
-  /**
-  * @internal
-  */
-  _swarms = new ComplexMap6(PublicKey7.hash);
-  _mappers = new ComplexMap6(PublicKey7.hash);
-  _transportFactory;
-  _signalManager;
-  _messenger;
-  _signalConnection;
-  _connectionLimiter;
-  _connectionLog;
-  _peerInfo = void 0;
-  _connectionState = ConnectionState2.ONLINE;
-  connectionStateChanged = new Event6();
-  topicsUpdated = new Event6();
-  constructor({ transportFactory, signalManager, enableDevtoolsLogging, peerInfo }) {
-    this._transportFactory = transportFactory;
-    this._signalManager = signalManager;
-    this._signalManager.swarmEvent.on((event) => this._swarms.get(event.topic)?.onSwarmEvent(event));
-    this._messenger = new Messenger({
-      signalManager: this._signalManager
-    });
-    this._signalConnection = {
-      join: (ctx, opts) => this._signalManager.join(ctx, opts),
-      leave: (ctx, opts) => this._signalManager.leave(ctx, opts)
-    };
-    this._peerInfo = peerInfo;
-    this._connectionLimiter = new ConnectionLimiter();
-    if (enableDevtoolsLogging) {
-      this._connectionLog = new ConnectionLog();
-    }
-  }
-  // 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(topic) {
-    return this._mappers.get(topic);
-  }
-  getSwarm(topic) {
-    return this._swarms.get(topic);
-  }
-  setPeerInfo(peerInfo) {
-    this._peerInfo = peerInfo;
-  }
-  async open() {
-    log7("opening network manager", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 76, S: this });
-    await this._messenger.open();
-    await this._signalManager.open();
-    log7("opened network manager", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 79, S: this });
-  }
-  async close(ctx) {
-    for (const topic of this._swarms.keys()) {
-      await this.leaveSwarm(ctx, topic).catch((err) => {
-        log7(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 84, S: this });
-      });
-    }
-    await this._messenger.close();
-    await this._signalManager.close();
-  }
-  /**
-  * Join the swarm.
-  */
-  async joinSwarm(ctx, { topic, topology, protocolProvider: protocol, label }) {
-    assertArgument(PublicKey7.isPublicKey(topic), "topic");
-    invariant6(topology, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 94, S: this, A: ["topology", ""] });
-    invariant6(this._peerInfo, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 95, S: this, A: ["this._peerInfo", ""] });
-    assertArgument(typeof protocol === "function", "protocolProvider");
-    if (this._swarms.has(topic)) {
-      throw new Error(`Already connected to swarm: ${PublicKey7.from(topic)}`);
-    }
-    log7("joining", {
-      topic: PublicKey7.from(topic),
-      peerInfo: this._peerInfo,
-      topology: topology.toString()
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 100, S: this });
-    const swarm = new Swarm(topic, this._peerInfo, topology, protocol, this._messenger, this._transportFactory, label, this._connectionLimiter);
-    swarm.errors.handle((error) => {
-      log7("swarm error", {
-        error
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 107, S: this });
-    });
-    this._swarms.set(topic, swarm);
-    this._mappers.set(topic, new SwarmMapper(swarm));
-    await swarm.open();
-    this._signalConnection.join(ctx, {
-      topic,
-      peer: this._peerInfo
-    }).catch((error) => log7.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 118, S: this }));
-    this.topicsUpdated.emit();
-    this._connectionLog?.joinedSwarm(swarm);
-    log7("joined", {
-      topic: PublicKey7.from(topic),
-      count: this._swarms.size
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 121, S: this });
-    return {
-      close: (ctx2) => this.leaveSwarm(ctx2, topic)
-    };
-  }
-  /**
-  * Close the connection.
-  */
-  async leaveSwarm(ctx, topic) {
-    if (!this._swarms.has(topic)) {
-      return;
-    }
-    log7("leaving", {
-      topic: PublicKey7.from(topic)
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 136, S: this });
-    const swarm = this._swarms.get(topic);
-    await this._signalConnection.leave(ctx, {
-      topic,
-      peer: swarm.ownPeer
-    });
-    const map = this._mappers.get(topic);
-    map.destroy();
-    this._mappers.delete(topic);
-    this._connectionLog?.leftSwarm(swarm);
-    await swarm.destroy();
-    this._swarms.delete(topic);
-    this.topicsUpdated.emit();
-    log7("left", {
-      topic: PublicKey7.from(topic),
-      count: this._swarms.size
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 151, S: this });
-  }
-  async setConnectionState(state) {
-    if (state === this._connectionState) {
-      return;
-    }
-    switch (state) {
-      case ConnectionState2.OFFLINE: {
-        this._connectionState = state;
-        await Promise.all([
-          ...this._swarms.values()
-        ].map((swarm) => swarm.goOffline()));
-        await this._messenger.close();
-        await this._signalManager.close();
-        break;
-      }
-      case ConnectionState2.ONLINE: {
-        this._connectionState = state;
-        this._messenger.open();
-        await Promise.all([
-          ...this._swarms.values()
-        ].map((swarm) => swarm.goOnline()));
-        await this._signalManager.open();
-        break;
-      }
-    }
-    this.connectionStateChanged.emit(this._connectionState);
-  }
-};
-_ts_decorate4([
-  synchronized4
-], SwarmNetworkManager.prototype, "joinSwarm", null);
-_ts_decorate4([
-  synchronized4
-], SwarmNetworkManager.prototype, "leaveSwarm", null);
-
-// src/topology/fully-connected-topology.ts
-import { invariant as invariant7 } from "@dxos/invariant";
-var __dxlog_file8 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts";
-var FullyConnectedTopology = class {
-  _controller;
-  toString() {
-    return "FullyConnectedTopology";
-  }
-  init(controller) {
-    invariant7(!this._controller, "Already initialized", { "~LogMeta": "~LogMeta", F: __dxlog_file8, L: 11, S: this, A: ["!this._controller", "'Already initialized'"] });
-    this._controller = controller;
-  }
-  update() {
-    invariant7(this._controller, "Not initialized", { "~LogMeta": "~LogMeta", F: __dxlog_file8, L: 15, S: this, A: ["this._controller", "'Not initialized'"] });
-    const { candidates: discovered } = this._controller.getState();
-    for (const peer of discovered) {
-      this._controller.connect(peer);
-    }
-  }
-  async onOffer(peer) {
-    return true;
-  }
-  async destroy() {
-  }
-};
-
-// src/transport/memory-transport.ts
-import { Transform } from "@dxos/node-std/stream";
-import { Event as Event7, Trigger as Trigger2 } from "@dxos/async";
-import { ErrorStream as ErrorStream3 } from "@dxos/debug";
-import { invariant as invariant8 } from "@dxos/invariant";
-import { PublicKey as PublicKey8 } from "@dxos/keys";
-import { log as log8, logInfo as logInfo3 } from "@dxos/log";
-import { ComplexMap as ComplexMap7 } from "@dxos/util";
-var __dxlog_file9 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts";
-function _ts_decorate5(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var MEMORY_TRANSPORT_DELAY = 1;
-var createStreamDelay = (delay) => {
-  return new Transform({
-    objectMode: true,
-    transform: (chunk, _, cb) => {
-      setTimeout(() => cb(null, chunk), delay);
-    }
-  });
-};
-var MemoryTransportFactory = {
-  createTransport: (options) => new MemoryTransport(options)
-};
-var MemoryTransport = class _MemoryTransport {
-  _options;
-  // TODO(burdon): Remove static properties (inject context into constructor).
-  static _connections = new ComplexMap7(PublicKey8.hash);
-  _instanceId = PublicKey8.random();
-  _remote = new Trigger2();
-  _outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
-  _incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
-  _closed = false;
-  _remoteInstanceId;
-  _remoteConnection;
-  closed = new Event7();
-  connected = new Event7();
-  errors = new ErrorStream3();
-  constructor(_options) {
-    this._options = _options;
-    invariant8(!_MemoryTransport._connections.has(this._instanceId), "Duplicate memory connection", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 51, S: this, A: ["!MemoryTransport._connections.has(this._instanceId)", "'Duplicate memory connection'"] });
-    _MemoryTransport._connections.set(this._instanceId, this);
-  }
-  get isOpen() {
-    return !this._closed;
-  }
-  async open() {
-    log8("opening...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 59, S: this });
-    if (this._options.initiator) {
-      log8("sending signal", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 62, S: this });
-      try {
-        await this._options.sendSignal({
-          payload: {
-            transportId: this._instanceId.toHex()
-          }
-        });
-      } catch (err) {
-        if (!this._closed) {
-          this.errors.raise(toError(err));
-        }
-      }
-    } else {
-      this._remote.wait({
-        timeout: this._options.timeout ?? 1e3
-      }).then((remoteId) => {
-        if (this._closed) {
-          return;
-        }
-        this._remoteInstanceId = remoteId;
-        this._remoteConnection = _MemoryTransport._connections.get(this._remoteInstanceId);
-        if (!this._remoteConnection) {
-          this._closed = true;
-          this.closed.emit();
-          return;
-        }
-        invariant8(!this._remoteConnection._remoteConnection, `Remote already connected: ${this._remoteInstanceId}`, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 90, S: this, A: ["!this._remoteConnection._remoteConnection", "`Remote already connected: ${this._remoteInstanceId}`"] });
-        this._remoteConnection._remoteConnection = this;
-        this._remoteConnection._remoteInstanceId = this._instanceId;
-        log8("connected", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 93, S: this });
-        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((err) => {
-        if (this._closed) {
-          return;
-        }
-        this.errors.raise(err);
-      });
-    }
-    return this;
-  }
-  async close() {
-    log8("closing...", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 107, S: this });
-    this._closed = true;
-    _MemoryTransport._connections.delete(this._instanceId);
-    if (this._remoteConnection) {
-      this._remoteConnection._closed = true;
-      _MemoryTransport._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();
-    log8("closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 130, S: this });
-    return this;
-  }
-  async onSignal({ payload }) {
-    log8("received signal", {
-      payload
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 134, S: this });
-    if (!payload?.transportId) {
-      return;
-    }
-    const transportId = payload.transportId;
-    if (transportId) {
-      const remoteId = PublicKey8.fromHex(transportId);
-      this._remote.wake(remoteId);
-    }
-  }
-  async getDetails() {
-    return this._instanceId.toHex();
-  }
-  async getStats() {
-    return {
-      bytesSent: 0,
-      bytesReceived: 0,
-      packetsSent: 0,
-      packetsReceived: 0
-    };
-  }
-};
-_ts_decorate5([
-  logInfo3
-], MemoryTransport.prototype, "_instanceId", void 0);
-_ts_decorate5([
-  logInfo3
-], MemoryTransport.prototype, "_remoteInstanceId", void 0);
-var toError = (err) => err instanceof Error ? err : new Error(String(err));
-
-// src/transport/transport.ts
-var TransportKind = /* @__PURE__ */ (function(TransportKind2) {
-  TransportKind2["WEB_RTC"] = "WEB-RTC";
-  TransportKind2["WEB_RTC_PROXY"] = "WEB-RTC_PROXY";
-  TransportKind2["MEMORY"] = "MEMORY";
-  TransportKind2["TCP"] = "TCP";
-  return TransportKind2;
-})({});
-
-// src/transport/webrtc/rtc-connection-factory.ts
-import { Mutex } from "@dxos/async";
-var BrowserRtcConnectionFactory = class {
-  async initialize() {
-  }
-  async onConnectionDestroyed() {
-  }
-  async createConnection(config) {
-    return new RTCPeerConnection(config);
-  }
-  async initConnection(connection, info) {
-  }
-};
-var NodeRtcConnectionFactory = class _NodeRtcConnectionFactory {
-  static _createdConnections = 0;
-  static _cleanupMutex = new Mutex();
-  // This should be inside the function to avoid triggering `eval` in the global scope.
-  // eslint-disable-next-line @typescript-eslint/no-implied-eval
-  // TODO(burdon): Do imports here?
-  async initialize() {
-  }
-  async onConnectionDestroyed() {
-    return _NodeRtcConnectionFactory._cleanupMutex.executeSynchronized(async () => {
-      if (--_NodeRtcConnectionFactory._createdConnections === 0) {
-        (await import("#node-datachannel")).cleanup();
-      }
-    });
-  }
-  async createConnection(config) {
-    return _NodeRtcConnectionFactory._cleanupMutex.executeSynchronized(async () => {
-      const { RTCPeerConnection: RTCPeerConnection1 } = await import("#node-datachannel/polyfill");
-      _NodeRtcConnectionFactory._createdConnections++;
-      return new RTCPeerConnection1(config);
-    });
-  }
-  async initConnection(connection, info) {
-    if (info.initiator) {
-      connection.onnegotiationneeded?.(null);
-    }
-  }
-};
-var getRtcConnectionFactory = () => {
-  return typeof globalThis.RTCPeerConnection === "undefined" ? new NodeRtcConnectionFactory() : new BrowserRtcConnectionFactory();
-};
-
-// src/transport/webrtc/rtc-peer-connection.ts
-import { Mutex as Mutex2, Trigger as Trigger3, synchronized as synchronized5 } from "@dxos/async";
-import { invariant as invariant10 } from "@dxos/invariant";
-import { log as log10, logInfo as logInfo4 } from "@dxos/log";
-import { ConnectivityError as ConnectivityError3 } from "@dxos/protocols";
-import { trace } from "@dxos/tracing";
-
-// src/transport/webrtc/rtc-transport-channel.ts
-import { Duplex } from "@dxos/node-std/stream";
-import { Event as AsyncEvent } from "@dxos/async";
-import { Resource } from "@dxos/context";
-import { ErrorStream as ErrorStream4 } from "@dxos/debug";
-import { invariant as invariant9 } from "@dxos/invariant";
-import { log as log9 } from "@dxos/log";
-import { ConnectivityError as ConnectivityError2 } from "@dxos/protocols";
-
-// src/transport/webrtc/rtc-transport-stats.ts
-var describeSelectedRemoteCandidate = async (connection) => {
-  const stats = connection && await getRtcConnectionStats(connection);
-  const rc = stats?.remoteCandidate;
-  if (!rc) {
-    return "unavailable";
-  }
-  if (rc.candidateType === "relay") {
-    return `${rc.ip}:${rc.port} relay for ${rc.relatedAddress}:${rc.relatedPort}`;
-  }
-  return `${rc.ip}:${rc.port} ${rc.candidateType}`;
-};
-var createRtcTransportStats = async (connection, topic) => {
-  const stats = connection && await getRtcConnectionStats(connection, topic);
-  if (!stats) {
-    return {
-      bytesSent: 0,
-      bytesReceived: 0,
-      packetsSent: 0,
-      packetsReceived: 0,
-      rawStats: {}
-    };
-  }
-  return {
-    bytesSent: stats.dataChannel?.bytesSent,
-    bytesReceived: stats.dataChannel?.bytesReceived,
-    packetsSent: 0,
-    packetsReceived: 0,
-    rawStats: stats.raw
-  };
-};
-var getRtcConnectionStats = async (connection, channelTopic) => {
-  const stats = await connection.getStats();
-  const statsEntries = Array.from(stats.entries());
-  const transport = statsEntries.find(([_, entry]) => entry.type === "transport")?.[1];
-  const selectedCandidatePair = transport && statsEntries.find(([entryId]) => entryId === transport.selectedCandidatePairId)?.[1];
-  const remoteCandidate = selectedCandidatePair && statsEntries.find(([entryId]) => entryId === selectedCandidatePair.remoteCandidateId)?.[1];
-  const dataChannel = channelTopic && statsEntries.find(([_, entry]) => entry.type === "data-channel" && entry.label === channelTopic)?.[1];
-  return {
-    transport,
-    selectedCandidatePair,
-    dataChannel,
-    remoteCandidate,
-    raw: Object.fromEntries(stats)
-  };
-};
-
-// src/transport/webrtc/rtc-transport-channel.ts
-var __dxlog_file10 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-channel.ts";
-var MAX_MESSAGE_SIZE = 64 * 1024;
-var MAX_BUFFERED_AMOUNT = 64 * 1024;
-var RtcTransportChannel = class extends Resource {
-  _connection;
-  _options;
-  closed = new AsyncEvent();
-  connected = new AsyncEvent();
-  errors = new ErrorStream4();
-  _channel;
-  _stream;
-  _streamDataFlushedCallback = null;
-  _isChannelCreationInProgress = false;
-  constructor(_connection, _options) {
-    super(), this._connection = _connection, this._options = _options;
-  }
-  get isRtcChannelCreationInProgress() {
-    return this._isChannelCreationInProgress;
-  }
-  onConnectionError(error) {
-    if (this.isOpen) {
-      this.errors.raise(error);
-    }
-  }
-  async _open() {
-    invariant9(!this._isChannelCreationInProgress, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 41, S: this, A: ["!this._isChannelCreationInProgress", ""] });
-    this._isChannelCreationInProgress = true;
-    this._connection.createDataChannel(this._options.topic).then((channel) => {
-      if (this.isOpen) {
-        this._channel = channel;
-        this._initChannel(this._channel);
-      } else {
-        this._safeCloseChannel(channel);
-      }
-    }).catch((err) => {
-      if (this.isOpen) {
-        const error = err instanceof Error ? err : new ConnectivityError2({
-          message: `Failed to create a channel: ${JSON.stringify(err?.message)}`
-        });
-        this.errors.raise(error);
-      } else {
-        log9.verbose("connection establishment failed after transport was closed", {
-          err
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 57, S: this });
-      }
-    }).finally(() => {
-      this._isChannelCreationInProgress = false;
-    });
-  }
-  async _close() {
-    if (this._channel) {
-      this._safeCloseChannel(this._channel);
-      this._channel = void 0;
-      this._stream = void 0;
-    }
-    this.closed.emit();
-    log9("closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 72, S: this });
-  }
-  _initChannel(channel) {
-    Object.assign(channel, {
-      onopen: () => {
-        if (!this.isOpen) {
-          log9.warn("channel opened in a closed transport", {
-            topic: this._options.topic
-          }, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 78, S: this });
-          this._safeCloseChannel(channel);
-          return;
-        }
-        log9("onopen", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 84, S: this });
-        const duplex = new Duplex({
-          read: () => {
-          },
-          write: (chunk, encoding, callback) => {
-            return this._handleChannelWrite(chunk, callback);
-          }
-        });
-        duplex.pipe(this._options.stream).pipe(duplex);
-        this._stream = duplex;
-        this.connected.emit();
-      },
-      onclose: async () => {
-        log9("onclose", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 96, S: this });
-        await this.close();
-      },
-      onmessage: async (event) => {
-        if (!this._stream) {
-          log9.warn("ignoring message on a closed channel", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 101, S: this });
-          return;
-        }
-        let data = event.data;
-        if (data instanceof ArrayBuffer) {
-          data = Buffer.from(data);
-        } else if (data instanceof Blob) {
-          data = Buffer.from(await data.arrayBuffer());
-        }
-        this._stream.push(data);
-      },
-      onerror: (event) => {
-        if (this.isOpen) {
-          const err = event.error instanceof Error ? event.error : new Error(`Datachannel error: ${event.type}.`);
-          this.errors.raise(err);
-        }
-      },
-      onbufferedamountlow: () => {
-        const cb = this._streamDataFlushedCallback;
-        this._streamDataFlushedCallback = null;
-        cb?.();
-      }
-    });
-  }
-  async _handleChannelWrite(chunk, callback) {
-    if (!this._channel) {
-      log9.warn("writing to a channel after a connection was closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 127, S: this });
-      return;
-    }
-    if (chunk.length > MAX_MESSAGE_SIZE) {
-      const error = new Error(`Message too large: ${chunk.length} > ${MAX_MESSAGE_SIZE}.`);
-      this.errors.raise(error);
-      callback();
-      return;
-    }
-    try {
-      this._channel.send(chunk);
-    } catch (err) {
-      this.errors.raise(err);
-      callback();
-      return;
-    }
-    if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
-      if (this._streamDataFlushedCallback !== null) {
-        log9.error("consumer trying to write before we are ready for more data", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 145, S: this });
-      }
-      this._streamDataFlushedCallback = callback;
-    } else {
-      callback();
-    }
-  }
-  _safeCloseChannel(channel) {
-    try {
-      channel.close();
-    } catch (error) {
-      log9.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 156, S: this });
-    }
-  }
-  onSignal(signal) {
-    return this._connection.onSignal(signal);
-  }
-  async getDetails() {
-    return describeSelectedRemoteCandidate(this._connection.currentConnection);
-  }
-  async getStats() {
-    return createRtcTransportStats(this._connection.currentConnection, this._options.topic);
-  }
-};
-
-// src/transport/webrtc/utils.ts
-var chooseInitiatorPeer = (peer1Key, peer2Key) => peer1Key < peer2Key ? peer1Key : peer2Key;
-var areSdpEqual = (sdp1, sdp2) => {
-  const sdp1Lines = deduplicatedSdpLines(sdp1);
-  const sdp2Lines = deduplicatedSdpLines(sdp2);
-  if (sdp1Lines.length !== sdp2Lines.length) {
-    return false;
-  }
-  return sdp1Lines.every((line, idx) => line === sdp2Lines[idx]);
-};
-var deduplicatedSdpLines = (sdp) => {
-  const deduplicatedLines = [];
-  const seenLines = [];
-  for (const line of sdp.split("\r\n")) {
-    if (line.startsWith("m")) {
-      seenLines.length = 0;
-    }
-    if (seenLines.includes(line)) {
-      continue;
-    }
-    seenLines.push(line);
-    deduplicatedLines.push(line);
-  }
-  return deduplicatedLines;
-};
-
-// src/transport/webrtc/rtc-peer-connection.ts
-var __dxlog_file11 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-peer-connection.ts";
-function _ts_decorate6(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var RtcPeerConnection = class {
-  _factory;
-  _options;
-  // A peer who is not the initiator waits for another party to open a channel.
-  _channelCreatedCallbacks = /* @__PURE__ */ new Map();
-  // Channels indexed by topic.
-  _transportChannels = /* @__PURE__ */ new Map();
-  _dataChannels = /* @__PURE__ */ new Map();
-  // A peer is ready to receive ICE candidates when local and remote description were set.
-  _readyForCandidates = new Trigger3();
-  _offerProcessingMutex = new Mutex2();
-  /**
-  * Can't use peer.connection.initiator, because if two connections to the same peer are created in
-  * different swarms, we might be the initiator of the first one, but not of the other one.
-  * Use a stable peer keypair property (key ordering) to decide who's acting as the initiator of
-  * transport connection establishment and data channel creation.
-  */
-  _initiator;
-  _connection;
-  constructor(_factory, _options) {
-    this._factory = _factory;
-    this._options = _options;
-    this._initiator = chooseInitiatorPeer(_options.ownPeerKey, _options.remotePeerKey) === _options.ownPeerKey;
-  }
-  get transportChannelCount() {
-    return this._transportChannels.size;
-  }
-  get currentConnection() {
-    return this._connection;
-  }
-  async createDataChannel(topic) {
-    const connection = await this._openConnection();
-    if (!this._transportChannels.has(topic)) {
-      if (!this._transportChannels.size) {
-        void this._lockAndCloseConnection();
-      }
-      throw new Error("Transport closed while connection was being open");
-    }
-    if (this._initiator) {
-      const channel = connection.createDataChannel(topic);
-      this._dataChannels.set(topic, channel);
-      return channel;
-    } else {
-      const existingChannel = this._dataChannels.get(topic);
-      if (existingChannel) {
-        return existingChannel;
-      }
-      log10("waiting for initiator-peer to open a data channel", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 63, S: this });
-      return new Promise((resolve, reject) => {
-        this._channelCreatedCallbacks.set(topic, {
-          resolve,
-          reject
-        });
-      });
-    }
-  }
-  createTransportChannel(options) {
-    const channel = new RtcTransportChannel(this, options);
-    this._transportChannels.set(options.topic, channel);
-    channel.closed.on(() => {
-      this._transportChannels.delete(options.topic);
-      if (this._transportChannels.size === 0) {
-        void this._lockAndCloseConnection();
-      }
-    });
-    return channel;
-  }
-  async _openConnection() {
-    if (this._connection) {
-      return this._connection;
-    }
-    log10("initializing connection...", () => ({
-      remotePeer: this._options.remotePeerKey
-    }), { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 87, S: this });
-    const config = await this._loadConnectionConfig();
-    const connection = await this._factory.createConnection(config);
-    const iceCandidateErrors = [];
-    Object.assign(connection, {
-      onnegotiationneeded: async () => {
-        invariant10(this._initiator, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 100, S: this, A: ["this._initiator", ""] });
-        if (connection !== this._connection) {
-          this._onConnectionCallbackAfterClose("onnegotiationneeded", connection);
-          return;
-        }
-        log10("onnegotiationneeded", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 105, S: this });
-        try {
-          const offer = await connection.createOffer();
-          await connection.setLocalDescription(offer);
-          await this._sendDescription(connection, offer);
-        } catch (err) {
-          void this._lockAndAbort(connection, err);
-        }
-      },
-      // When ICE candidate identified (should be sent to remote peer) and when ICE gathering finalized.
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/icecandidate_event
-      onicecandidate: async (event) => {
-        if (connection !== this._connection) {
-          this._onConnectionCallbackAfterClose("onicecandidate", connection);
-          return;
-        }
-        if (event.candidate) {
-          log10("onicecandidate", {
-            candidate: event.candidate.candidate
-          }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 122, S: this });
-          await this._sendIceCandidate(event.candidate);
-        } else {
-          log10("onicecandidate gathering complete", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 127, S: this });
-        }
-      },
-      // When error occurs while performing ICE negotiations through a STUN or TURN server.
-      // It's ok for some candidates to fail if a working pair is eventually found.
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/icecandidateerror_event
-      onicecandidateerror: (event) => {
-        const { url, errorCode, errorText } = event;
-        iceCandidateErrors.push({
-          url,
-          errorCode,
-          errorText
-        });
-      },
-      // When possible error during ICE gathering.
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceconnectionstatechange_event
-      oniceconnectionstatechange: () => {
-        if (connection !== this._connection) {
-          this._onConnectionCallbackAfterClose("oniceconnectionstatechange", connection);
-          return;
-        }
-        log10("oniceconnectionstatechange", {
-          state: connection.iceConnectionState
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 148, S: this });
-        if (connection.iceConnectionState === "failed") {
-          void this._lockAndAbort(connection, createIceFailureError(iceCandidateErrors));
-        }
-      },
-      // When new track (or channel) is added.
-      // State: { new, connecting, connected, disconnected, failed, closed }
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/connectionstatechange_event
-      onconnectionstatechange: () => {
-        if (connection !== this._connection) {
-          if (connection.connectionState !== "closed" && connection.connectionState !== "failed") {
-            this._onConnectionCallbackAfterClose("onconnectionstatechange", connection);
-          }
-          return;
-        }
-        log10("onconnectionstatechange", {
-          state: connection.connectionState
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 165, S: this });
-        if (connection.connectionState === "failed") {
-          void this._lockAndAbort(connection, new Error("Connection failed."));
-        }
-      },
-      onsignalingstatechange: () => {
-        log10("onsignalingstatechange", {
-          state: connection.signalingState
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 173, S: this });
-      },
-      // When channel is added to connection.
-      // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event
-      ondatachannel: (event) => {
-        invariant10(!this._initiator, "Initiator is expected to create data channels.", { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 180, S: this, A: ["!this._initiator", "'Initiator is expected to create data channels.'"] });
-        if (connection !== this._connection) {
-          this._onConnectionCallbackAfterClose("ondatachannel", connection);
-          return;
-        }
-        log10("ondatachannel", {
-          label: event.channel.label
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 185, S: this });
-        this._dataChannels.set(event.channel.label, event.channel);
-        const pendingCallback = this._channelCreatedCallbacks.get(event.channel.label);
-        if (pendingCallback) {
-          this._channelCreatedCallbacks.delete(event.channel.label);
-          pendingCallback.resolve(event.channel);
-        }
-      }
-    });
-    this._connection = connection;
-    this._readyForCandidates.reset();
-    await this._factory.initConnection(connection, {
-      initiator: this._initiator
-    });
-    return this._connection;
-  }
-  async _lockAndAbort(connection, error) {
-    this._abortConnection(connection, error);
-  }
-  _abortConnection(connection, error) {
-    if (connection !== this._connection) {
-      log10.error("attempted to abort an inactive connection", {
-        error
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 208, S: this });
-      this._safeCloseConnection(connection);
-      return;
-    }
-    for (const [topic, pendingCallback] of this._channelCreatedCallbacks.entries()) {
-      pendingCallback.reject(error);
-      this._transportChannels.delete(topic);
-    }
-    this._channelCreatedCallbacks.clear();
-    for (const channel of this._transportChannels.values()) {
-      channel.onConnectionError(error);
-    }
-    this._transportChannels.clear();
-    this._safeCloseConnection();
-    log10("connection aborted", {
-      reason: error.message
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 224, S: this });
-  }
-  async _lockAndCloseConnection() {
-    invariant10(this._transportChannels.size === 0, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 229, S: this, A: ["this._transportChannels.size === 0", ""] });
-    if (this._connection) {
-      this._safeCloseConnection();
-      log10("connection closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 232, S: this });
-    }
-  }
-  async onSignal(signal) {
-    const connection = this._connection;
-    if (!connection) {
-      log10.warn("a signal ignored because the connection was closed", {
-        type: signal.payload.data.type
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 238, S: this });
-      return;
-    }
-    const data = signal.payload.data;
-    switch (data.type) {
-      case "offer": {
-        await this._offerProcessingMutex.executeSynchronized(async () => {
-          if (isRemoteDescriptionSet(connection, data)) {
-            return;
-          }
-          if (connection.connectionState !== "new") {
-            this._abortConnection(connection, new Error(`Received an offer in ${connection.connectionState}.`));
-            return;
-          }
-          try {
-            await connection.setRemoteDescription({
-              type: data.type,
-              sdp: data.sdp
-            });
-            const answer = await connection.createAnswer();
-            await connection.setLocalDescription(answer);
-            await this._sendDescription(connection, answer);
-            this._onSessionNegotiated(connection);
-          } catch (err) {
-            this._abortConnection(connection, new Error("Error handling a remote offer.", {
-              cause: err
-            }));
-          }
-        });
-        break;
-      }
-      case "answer":
-        await this._offerProcessingMutex.executeSynchronized(async () => {
-          try {
-            if (isRemoteDescriptionSet(connection, data)) {
-              return;
-            }
-            if (connection.signalingState !== "have-local-offer") {
-              this._abortConnection(connection, new Error(`Unexpected answer from remote peer, signalingState was ${connection.signalingState}.`));
-              return;
-            }
-            await connection.setRemoteDescription({
-              type: data.type,
-              sdp: data.sdp
-            });
-            this._onSessionNegotiated(connection);
-          } catch (err) {
-            this._abortConnection(connection, new Error("Error handling a remote answer.", {
-              cause: err
-            }));
-          }
-        });
-        break;
-      case "candidate":
-        void this._processIceCandidate(connection, data.candidate);
-        break;
-      default:
-        this._abortConnection(connection, new Error(`Unknown signal type ${data.type}.`));
-        break;
-    }
-    log10("signal processed", {
-      type: data.type
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 301, S: this });
-  }
-  async _processIceCandidate(connection, candidate) {
-    try {
-      await this._readyForCandidates.wait();
-      if (connection === this._connection) {
-        log10("adding ice candidate", {
-          candidate
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 310, S: this });
-        await connection.addIceCandidate(candidate);
-      }
-    } catch (err) {
-      log10.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 316, S: this });
-    }
-  }
-  _onSessionNegotiated(connection) {
-    if (connection === this._connection) {
-      log10("ready to process ice candidates", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 321, S: this });
-      this._readyForCandidates.wake();
-    } else {
-      log10.warn("session was negotiated after connection became inactive", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 324, S: this });
-    }
-  }
-  _onConnectionCallbackAfterClose(callback, connection) {
-    log10.warn("callback invoked after a connection was destroyed, this is probably a bug", {
-      callback,
-      state: connection.connectionState
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 328, S: this });
-    this._safeCloseConnection(connection);
-  }
-  _safeCloseConnection(connection = this._connection) {
-    const resetFields = this._connection && connection === this._connection;
-    try {
-      connection?.close();
-    } catch (err) {
-      log10.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 339, S: this });
-    }
-    if (resetFields) {
-      this._connection = void 0;
-      this._dataChannels.clear();
-      this._readyForCandidates.wake();
-      void this._factory.onConnectionDestroyed().catch((err) => log10.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 345, S: this }));
-      for (const [_, pendingCallback] of this._channelCreatedCallbacks.entries()) {
-        pendingCallback.reject("Connection closed.");
-      }
-      this._channelCreatedCallbacks.clear();
-    }
-  }
-  async _loadConnectionConfig() {
-    const config = {
-      ...this._options.webrtcConfig
-    };
-    try {
-      const providedIceServers = await this._options.iceProvider?.getIceServers() ?? [];
-      if (providedIceServers.length > 0) {
-        config.iceServers = [
-          ...config.iceServers ?? [],
-          ...providedIceServers
-        ];
-      }
-    } catch (error) {
-      log10.catch(error, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 365, S: this });
-    }
-    return config;
-  }
-  async _sendIceCandidate(candidate) {
-    try {
-      await this._options.sendSignal({
-        payload: {
-          data: {
-            type: "candidate",
-            candidate: {
-              candidate: candidate.candidate,
-              // These fields never seem to be not null, but connecting to Chrome doesn't work if they are.
-              sdpMLineIndex: candidate.sdpMLineIndex ?? "0",
-              sdpMid: candidate.sdpMid ?? "0"
-            }
-          }
-        }
-      });
-    } catch (err) {
-      log10.warn("signaling error", {
-        err
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 385, S: this });
-    }
-  }
-  async _sendDescription(connection, description) {
-    if (connection !== this._connection) {
-      return;
-    }
-    const data = {
-      type: description.type,
-      sdp: description.sdp
-    };
-    await this._options.sendSignal({
-      payload: {
-        data
-      }
-    });
-  }
-  get _connectionInfo() {
-    const connectionInfo = this._connection && {
-      connectionState: this._connection.connectionState,
-      iceConnectionState: this._connection.iceConnectionState,
-      iceGatheringState: this._connection.iceGatheringState,
-      signalingState: this._connection.signalingState,
-      remoteDescription: this._connection.remoteDescription,
-      localDescription: this._connection.localDescription
-    };
-    return {
-      ...connectionInfo,
-      ts: Date.now(),
-      remotePeerKey: this._options.remotePeerKey,
-      channels: [
-        ...this._transportChannels.keys()
-      ].map((topic) => topic),
-      config: this._connection?.getConfiguration()
-    };
-  }
-  get _loggerContext() {
-    return {
-      ownPeerKey: this._options.ownPeerKey,
-      remotePeerKey: this._options.remotePeerKey,
-      initiator: this._initiator,
-      channels: this._transportChannels.size
-    };
-  }
-};
-_ts_decorate6([
-  synchronized5
-], RtcPeerConnection.prototype, "_openConnection", null);
-_ts_decorate6([
-  synchronized5
-], RtcPeerConnection.prototype, "_lockAndAbort", null);
-_ts_decorate6([
-  synchronized5
-], RtcPeerConnection.prototype, "_lockAndCloseConnection", null);
-_ts_decorate6([
-  synchronized5
-], RtcPeerConnection.prototype, "onSignal", null);
-_ts_decorate6([
-  trace.info()
-], RtcPeerConnection.prototype, "_connectionInfo", null);
-_ts_decorate6([
-  logInfo4
-], RtcPeerConnection.prototype, "_loggerContext", null);
-RtcPeerConnection = _ts_decorate6([
-  trace.resource()
-], RtcPeerConnection);
-var isRemoteDescriptionSet = (connection, data) => {
-  if (!connection.remoteDescription?.type || connection.remoteDescription?.type !== data.type) {
-    return false;
-  }
-  return areSdpEqual(connection.remoteDescription.sdp, data.sdp);
-};
-var createIceFailureError = (details) => {
-  const candidateErrors = details.map(({ url, errorCode, errorText }) => `${errorCode} ${url}: ${errorText}`);
-  return new ConnectivityError3({
-    message: `ICE failed:
-${candidateErrors.join("\n")}`
-  });
-};
-
-// src/transport/webrtc/rtc-transport-factory.ts
-var createRtcTransportFactory = (webrtcConfig, iceProvider) => {
-  const connectionFactory = getRtcConnectionFactory();
-  return {
-    createTransport: (options) => {
-      const connection = new RtcPeerConnection(connectionFactory, {
-        ownPeerKey: options.ownPeerKey,
-        remotePeerKey: options.remotePeerKey,
-        sendSignal: options.sendSignal,
-        legacyInitiator: options.initiator,
-        webrtcConfig,
-        iceProvider
-      });
-      return connection.createTransportChannel(options);
-    }
-  };
-};
-
-// src/transport/webrtc/rtc-transport-proxy.ts
-import { Writable } from "@dxos/node-std/stream";
-import { Event as Event8, scheduleTask as scheduleTask4 } from "@dxos/async";
-import { Resource as Resource2 } from "@dxos/context";
-import { ErrorStream as ErrorStream5 } from "@dxos/debug";
-import { invariant as invariant11 } from "@dxos/invariant";
-import { PublicKey as PublicKey9 } from "@dxos/keys";
-import { log as log11 } from "@dxos/log";
-import { ConnectionResetError as ConnectionResetError2, ConnectivityError as ConnectivityError4, TimeoutError as TimeoutError3 } from "@dxos/protocols";
-import { ConnectionState as ConnectionState3 } from "@dxos/protocols/proto/dxos/mesh/bridge";
-import { arrayToBuffer } from "@dxos/util";
-var __dxlog_file12 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-proxy.ts";
-var RPC_TIMEOUT = 1e4;
-var CLOSE_RPC_TIMEOUT = 3e3;
-var RESP_MIN_THRESHOLD = 500;
-var RtcTransportProxy = class extends Resource2 {
-  _options;
-  _proxyId = PublicKey9.random();
-  closed = new Event8();
-  connected = new Event8();
-  errors = new ErrorStream5();
-  _serviceStream;
-  constructor(_options) {
-    super(), this._options = _options;
-  }
-  async _open() {
-    let stream;
-    try {
-      stream = this._options.bridgeService.open({
-        proxyId: this._proxyId,
-        remotePeerKey: this._options.remotePeerKey,
-        ownPeerKey: this._options.ownPeerKey,
-        topic: this._options.topic,
-        initiator: this._options.initiator ?? false
-      }, {
-        timeout: RPC_TIMEOUT
-      });
-    } catch (error) {
-      this.errors.raise(error);
-      return;
-    }
-    this._serviceStream = stream;
-    stream.waitUntilReady().then(() => {
-      stream.subscribe(async (event) => {
-        log11("rtc transport proxy event", event, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 46, S: this });
-        if (event.connection) {
-          await this._handleConnection(event.connection);
-        } else if (event.data) {
-          this._handleData(event.data);
-        } else if (event.signal) {
-          await this._handleSignal(event.signal);
-        }
-      }, (err) => {
-        log11("rtc bridge stream closed", {
-          err
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 55, S: this });
-        if (err) {
-          this._raiseIfOpen(err);
-        } else {
-          void this.close();
-        }
-      });
-      const connectorStream = new Writable({
-        write: (chunk, _, callback) => {
-          const sendStartMs = Date.now();
-          this._options.bridgeService.sendData({
-            proxyId: this._proxyId,
-            payload: chunk
-          }, {
-            timeout: RPC_TIMEOUT
-          }).then(() => {
-            if (Date.now() - sendStartMs > RESP_MIN_THRESHOLD) {
-              log11("slow response, delaying callback", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 74, S: this });
-              scheduleTask4(this._ctx, () => callback(), RESP_MIN_THRESHOLD);
-            } else {
-              callback();
-            }
-          }, (err) => {
-            callback();
-            this._raiseIfOpen(err);
-          });
-        }
-      });
-      connectorStream.on("error", (err) => {
-        this._raiseIfOpen(err);
-      });
-      this._options.stream.pipe(connectorStream);
-    }, (error) => {
-      if (error) {
-        this._raiseIfOpen(error);
-      } else {
-        void this.close();
-      }
-    });
-  }
-  async _close() {
-    try {
-      await this._serviceStream?.close();
-      this._serviceStream = void 0;
-    } catch (err) {
-      log11.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 102, S: this });
-    }
-    try {
-      await this._options.bridgeService.close({
-        proxyId: this._proxyId
-      }, {
-        timeout: CLOSE_RPC_TIMEOUT
-      });
-    } catch (err) {
-      log11.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 111, S: this });
-    }
-    this.closed.emit();
-  }
-  async onSignal(signal) {
-    this._options.bridgeService.sendSignal({
-      proxyId: this._proxyId,
-      signal
-    }, {
-      timeout: RPC_TIMEOUT
-    }).catch((err) => this._raiseIfOpen(decodeError(err)));
-  }
-  async _handleConnection(connectionEvent) {
-    if (connectionEvent.error) {
-      this.errors.raise(decodeError(connectionEvent.error));
-      return;
-    }
-    switch (connectionEvent.state) {
-      case ConnectionState3.CONNECTED: {
-        this.connected.emit();
-        break;
-      }
-      case ConnectionState3.CLOSED: {
-        await this.close();
-        break;
-      }
-    }
-  }
-  _handleData(dataEvent) {
-    try {
-      this._options.stream.write(arrayToBuffer(dataEvent.payload));
-    } catch (error) {
-      this._raiseIfOpen(error);
-    }
-  }
-  async _handleSignal(signalEvent) {
-    try {
-      await this._options.sendSignal(signalEvent.payload);
-    } catch (error) {
-      const type = signalEvent.payload.payload.data?.type;
-      if (type === "offer" || type === "answer") {
-        this._raiseIfOpen(new ConnectivityError4({
-          message: `Session establishment failed: ${type} couldn't be sent.`
-        }));
-      }
-    }
-  }
-  async getDetails() {
-    try {
-      const response = await this._options.bridgeService.getDetails({
-        proxyId: this._proxyId
-      }, {
-        timeout: RPC_TIMEOUT
-      });
-      return response.details;
-    } catch (err) {
-      return "bridge-svc unreachable";
-    }
-  }
-  async getStats() {
-    try {
-      const response = await this._options.bridgeService.getStats({
-        proxyId: this._proxyId
-      }, {
-        timeout: RPC_TIMEOUT
-      });
-      return response.stats;
-    } catch (err) {
-      return {
-        bytesSent: 0,
-        bytesReceived: 0,
-        packetsSent: 0,
-        packetsReceived: 0,
-        rawStats: "bridge-svc unreachable"
-      };
-    }
-  }
-  _raiseIfOpen(error) {
-    if (this.isOpen) {
-      this.errors.raise(error);
-    } else {
-      log11.info("error swallowed because transport was closed", {
-        message: error.message
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 195, S: this });
-    }
-  }
-  /**
-  * Called when underlying proxy service becomes unavailable.
-  */
-  forceClose() {
-    void this._serviceStream?.close();
-    this.closed.emit();
-  }
-};
-var RtcTransportProxyFactory = class {
-  _bridgeService;
-  _connections = /* @__PURE__ */ new Set();
-  /**
-  * Sets the current BridgeService to be used to open connections.
-  * Calling this method will close any existing connections.
-  */
-  setBridgeService(bridgeService) {
-    this._bridgeService = bridgeService;
-    for (const connection of this._connections) {
-      connection.forceClose();
-    }
-    return this;
-  }
-  createTransport(options) {
-    invariant11(this._bridgeService, "RtcTransportProxyFactory is not ready to open connections", { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 221, S: this, A: ["this._bridgeService", "'RtcTransportProxyFactory is not ready to open connections'"] });
-    const transport = new RtcTransportProxy({
-      ...options,
-      bridgeService: this._bridgeService
-    });
-    this._connections.add(transport);
-    transport.closed.on(() => {
-      this._connections.delete(transport);
-    });
-    return transport;
-  }
-};
-var decodeError = (err) => {
-  const message = typeof err === "string" ? err : err.message;
-  if (message.includes("CONNECTION_RESET")) {
-    return new ConnectionResetError2({
-      message
-    });
-  } else if (message.includes("TIMEOUT")) {
-    return new TimeoutError3({
-      message
-    });
-  } else if (message.includes("CONNECTIVITY_ERROR")) {
-    return new ConnectivityError4({
-      message
-    });
-  } else {
-    return typeof err === "string" ? new Error(err) : err;
-  }
-};
-
-// src/transport/webrtc/rtc-transport-service.ts
-import { Duplex as Duplex2 } from "@dxos/node-std/stream";
-import { Stream } from "@dxos/codec-protobuf/stream";
-import { invariant as invariant12 } from "@dxos/invariant";
-import { PublicKey as PublicKey10 } from "@dxos/keys";
-import { log as log12 } from "@dxos/log";
-import { ConnectionState as ConnectionState4 } from "@dxos/protocols/proto/dxos/mesh/bridge";
-import { ComplexMap as ComplexMap8 } from "@dxos/util";
-var __dxlog_file13 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-service.ts";
-var RtcTransportService = class {
-  _transportFactory;
-  _openTransports = new ComplexMap8(PublicKey10.hash);
-  constructor(webrtcConfig, iceProvider, _transportFactory = createRtcTransportFactory(webrtcConfig, iceProvider)) {
-    this._transportFactory = _transportFactory;
-  }
-  hasOpenTransports() {
-    return this._openTransports.size > 0;
-  }
-  open(request) {
-    const existingTransport = this._openTransports.get(request.proxyId);
-    if (existingTransport) {
-      log12.error("requesting a new transport bridge for an existing proxy", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 24, S: this });
-      void this._safeCloseTransport(existingTransport);
-      this._openTransports.delete(request.proxyId);
-    }
-    return new Stream(({ ready, next, close }) => {
-      const pushNewState = createStateUpdater(next);
-      const transportStream = new Duplex2({
-        read: () => {
-          const callbacks = [
-            ...transportState.writeProcessedCallbacks
-          ];
-          transportState.writeProcessedCallbacks.length = 0;
-          callbacks.forEach((cb) => cb());
-        },
-        write: function(chunk, _, callback) {
-          next({
-            data: {
-              payload: chunk
-            }
-          });
-          callback();
-        }
-      });
-      const transport = this._transportFactory.createTransport({
-        initiator: request.initiator,
-        topic: request.topic,
-        ownPeerKey: request.ownPeerKey,
-        remotePeerKey: request.remotePeerKey,
-        stream: transportStream,
-        sendSignal: async (signal) => {
-          next({
-            signal: {
-              payload: signal
-            }
-          });
-        }
-      });
-      const transportState = {
-        proxyId: request.proxyId,
-        transport,
-        connectorStream: transportStream,
-        writeProcessedCallbacks: []
-      };
-      transport.connected.on(() => pushNewState(ConnectionState4.CONNECTED));
-      transport.errors.handle(async (err) => {
-        pushNewState(ConnectionState4.CLOSED, err);
-        void this._safeCloseTransport(transportState);
-        close(err);
-      });
-      transport.closed.on(async () => {
-        pushNewState(ConnectionState4.CLOSED);
-        void this._safeCloseTransport(transportState);
-        close();
-      });
-      this._openTransports.set(request.proxyId, transportState);
-      transport.open().catch(async (err) => {
-        pushNewState(ConnectionState4.CLOSED, err);
-        void this._safeCloseTransport(transportState);
-        close(err);
-      });
-      ready();
-      log12("stream ready", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 85, S: this });
-      pushNewState(ConnectionState4.CONNECTING);
-    });
-  }
-  async sendSignal({ proxyId, signal }) {
-    const transport = this._openTransports.get(proxyId);
-    invariant12(transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 91, S: this, A: ["transport", ""] });
-    await transport.transport.onSignal(signal);
-  }
-  async getDetails({ proxyId }) {
-    const transport = this._openTransports.get(proxyId);
-    invariant12(transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 96, S: this, A: ["transport", ""] });
-    return {
-      details: await transport.transport.getDetails()
-    };
-  }
-  async getStats({ proxyId }) {
-    const transport = this._openTransports.get(proxyId);
-    invariant12(transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 103, S: this, A: ["transport", ""] });
-    return {
-      stats: await transport.transport.getStats()
-    };
-  }
-  async sendData({ proxyId, payload }) {
-    const transport = this._openTransports.get(proxyId);
-    invariant12(transport, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 110, S: this, A: ["transport", ""] });
-    const bufferHasSpace = transport.connectorStream.push(payload);
-    if (!bufferHasSpace) {
-      await new Promise((resolve) => {
-        transport.writeProcessedCallbacks.push(resolve);
-      });
-    }
-  }
-  async close({ proxyId }) {
-    const transport = this._openTransports.get(proxyId);
-    if (!transport) {
-      return;
-    }
-    this._openTransports.delete(proxyId);
-    await this._safeCloseTransport(transport);
-  }
-  async _safeCloseTransport(transport) {
-    if (this._openTransports.get(transport.proxyId) === transport) {
-      this._openTransports.delete(transport.proxyId);
-    }
-    transport.writeProcessedCallbacks.forEach((cb) => cb());
-    try {
-      await transport.transport.close();
-    } catch (error) {
-      log12.warn("transport close error", {
-        message: error?.message
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 134, S: this });
-    }
-    try {
-      transport.connectorStream.end();
-    } catch (error) {
-      log12.warn("connectorStream close error", {
-        message: error?.message
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 141, S: this });
-    }
-    log12("closed", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file13, L: 145, S: this });
-  }
-};
-var createStateUpdater = (next) => {
-  return (state, err) => {
-    next({
-      connection: {
-        state,
-        ...err ? {
-          error: err.message
-        } : void 0
-      }
-    });
-  };
-};
-
-// src/wire-protocol.ts
-import { Teleport } from "@dxos/teleport";
-var createTeleportProtocolFactory = (onConnection, defaultProps) => {
-  return (params) => {
-    const teleport = new Teleport({
-      ...defaultProps,
-      ...params
-    });
-    return {
-      stream: teleport.stream,
-      open: async (sessionId) => {
-        await teleport.open(sessionId);
-        await onConnection(teleport);
-      },
-      close: async () => {
-        await teleport.close();
-      },
-      abort: async () => {
-        await teleport.abort();
-      }
-    };
-  };
-};
-
-export {
-  ConnectionState,
-  Connection,
-  SwarmMessenger,
-  Swarm,
-  SwarmMapper,
-  MAX_CONCURRENT_INITIATING_CONNECTIONS,
-  ConnectionLimiter,
-  EventType,
-  ConnectionLog,
-  SwarmNetworkManager,
-  FullyConnectedTopology,
-  MemoryTransportFactory,
-  MemoryTransport,
-  TransportKind,
-  createRtcTransportFactory,
-  RtcTransportProxy,
-  RtcTransportProxyFactory,
-  RtcTransportService,
-  createTeleportProtocolFactory
-};
-//# sourceMappingURL=chunk-ERB3AQAF.mjs.map