@dxos/teleport 0.3.7 → 0.3.8-main.0ae9c21

package/dist/lib/node/chunk-MWNN2H3G.cjs

@@ -0,0 +1,1900 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_MWNN2H3G_exports = {};
+__export(chunk_MWNN2H3G_exports, {
+  Framer: () => Framer,
+  Muxer: () => Muxer,
+  Teleport: () => Teleport,
+  TestBuilder: () => TestBuilder,
+  TestConnection: () => TestConnection,
+  TestExtension: () => TestExtension,
+  TestExtensionWithStreams: () => TestExtensionWithStreams,
+  TestPeer: () => TestPeer,
+  decodeFrame: () => decodeFrame,
+  encodeFrame: () => encodeFrame
+});
+module.exports = __toCommonJS(chunk_MWNN2H3G_exports);
+var import_node_stream = require("node:stream");
+var import_invariant = require("@dxos/invariant");
+var import_keys = require("@dxos/keys");
+var import_log = require("@dxos/log");
+var import_async = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_debug = require("@dxos/debug");
+var import_invariant2 = require("@dxos/invariant");
+var import_keys2 = require("@dxos/keys");
+var import_log2 = require("@dxos/log");
+var import_protocols = require("@dxos/protocols");
+var import_async2 = require("@dxos/async");
+var import_context2 = require("@dxos/context");
+var import_log3 = require("@dxos/log");
+var import_protocols2 = require("@dxos/protocols");
+var import_rpc = require("@dxos/rpc");
+var import_util = require("@dxos/util");
+var import_node_stream2 = require("node:stream");
+var import_async3 = require("@dxos/async");
+var import_invariant3 = require("@dxos/invariant");
+var import_log4 = require("@dxos/log");
+var import_node_stream3 = require("node:stream");
+var import_async4 = require("@dxos/async");
+var import_context3 = require("@dxos/context");
+var import_debug2 = require("@dxos/debug");
+var import_invariant4 = require("@dxos/invariant");
+var import_log5 = require("@dxos/log");
+var import_protocols3 = require("@dxos/protocols");
+var varint = __toESM(require("varint"));
+var import_async5 = require("@dxos/async");
+var import_invariant5 = require("@dxos/invariant");
+var import_log6 = require("@dxos/log");
+var import_async6 = require("@dxos/async");
+var import_invariant6 = require("@dxos/invariant");
+var import_log7 = require("@dxos/log");
+var import_protocols4 = require("@dxos/protocols");
+var import_rpc2 = require("@dxos/rpc");
+var import_node_crypto = require("node:crypto");
+var import_async7 = require("@dxos/async");
+var import_invariant7 = require("@dxos/invariant");
+var import_log8 = require("@dxos/log");
+var import_protocols5 = require("@dxos/protocols");
+var import_rpc3 = require("@dxos/rpc");
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/control-extension.ts";
+var HEARTBEAT_RTT_WARN_THRESH = 1e4;
+var ControlExtension = class {
+  constructor(opts, localPeerId, remotePeerId) {
+    this.opts = opts;
+    this.localPeerId = localPeerId;
+    this.remotePeerId = remotePeerId;
+    this._ctx = new import_context2.Context({
+      onError: (err) => {
+        this._extensionContext.close(err);
+      }
+    });
+    this.onExtensionRegistered = new import_util.Callback();
+  }
+  async registerExtension(name) {
+    await this._rpc.rpc.Control.registerExtension({
+      name
+    });
+  }
+  async onOpen(extensionContext) {
+    this._extensionContext = extensionContext;
+    this._rpc = (0, import_rpc.createProtoRpcPeer)({
+      requested: {
+        Control: import_protocols2.schema.getService("dxos.mesh.teleport.control.ControlService")
+      },
+      exposed: {
+        Control: import_protocols2.schema.getService("dxos.mesh.teleport.control.ControlService")
+      },
+      handlers: {
+        Control: {
+          registerExtension: async (request) => {
+            this.onExtensionRegistered.call(request.name);
+          },
+          heartbeat: async (request) => {
+            (0, import_log3.log)("received heartbeat request", {
+              ts: request.requestTimestamp,
+              localPeerId: this.localPeerId.truncate(),
+              remotePeerId: this.remotePeerId.truncate()
+            }, {
+              F: __dxlog_file,
+              L: 66,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return {
+              requestTimestamp: request.requestTimestamp
+            };
+          }
+        }
+      },
+      port: await extensionContext.createPort("rpc", {
+        contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
+      }),
+      timeout: this.opts.heartbeatTimeout
+    });
+    await this._rpc.open();
+    (0, import_async2.scheduleTaskInterval)(this._ctx, async () => {
+      const reqTS = /* @__PURE__ */ new Date();
+      try {
+        const resp = await (0, import_async2.asyncTimeout)(this._rpc.rpc.Control.heartbeat({
+          requestTimestamp: reqTS
+        }), this.opts.heartbeatTimeout);
+        const now = Date.now();
+        if (resp.requestTimestamp instanceof Date) {
+          if (now - resp.requestTimestamp.getTime() > (HEARTBEAT_RTT_WARN_THRESH < this.opts.heartbeatTimeout ? HEARTBEAT_RTT_WARN_THRESH : this.opts.heartbeatTimeout / 2)) {
+            import_log3.log.warn(`heartbeat RTT for Teleport > ${HEARTBEAT_RTT_WARN_THRESH / 1e3}s`, {
+              rtt: now - resp.requestTimestamp.getTime(),
+              localPeerId: this.localPeerId.truncate(),
+              remotePeerId: this.remotePeerId.truncate()
+            }, {
+              F: __dxlog_file,
+              L: 103,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          } else {
+            (0, import_log3.log)("heartbeat RTT", {
+              rtt: now - resp.requestTimestamp.getTime(),
+              localPeerId: this.localPeerId.truncate(),
+              remotePeerId: this.remotePeerId.truncate()
+            }, {
+              F: __dxlog_file,
+              L: 109,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+        }
+      } catch (err) {
+        const now = Date.now();
+        if (err instanceof import_protocols2.RpcClosedError) {
+          (0, import_log3.log)("ignoring RpcClosedError in heartbeat", void 0, {
+            F: __dxlog_file,
+            L: 119,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return;
+        }
+        if (err instanceof import_async2.TimeoutError) {
+          (0, import_log3.log)("timeout waiting for heartbeat response", {
+            err,
+            delay: now - reqTS.getTime()
+          }, {
+            F: __dxlog_file,
+            L: 123,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this.opts.onTimeout(err);
+        } else {
+          import_log3.log.info("other error waiting for heartbeat response", {
+            err,
+            delay: now - reqTS.getTime()
+          }, {
+            F: __dxlog_file,
+            L: 126,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this.opts.onTimeout(err);
+        }
+      }
+    }, this.opts.heartbeatInterval);
+  }
+  async onClose(err) {
+    await this._ctx.dispose();
+    await this._rpc.close();
+  }
+  async onAbort(err) {
+    await this._ctx.dispose();
+    await this._rpc.abort();
+  }
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/framer.ts";
+var FRAME_LENGTH_SIZE = 2;
+var Framer = class {
+  constructor() {
+    this._messageCb = void 0;
+    this._subscribeCb = void 0;
+    this._buffer = void 0;
+    this._sendCallbacks = [];
+    this._bytesSent = 0;
+    this._bytesReceived = 0;
+    this._writable = true;
+    this.drain = new import_async3.Event();
+    this._stream = new import_node_stream2.Duplex({
+      objectMode: false,
+      read: () => {
+        this._processResponseQueue();
+      },
+      write: (chunk, encoding, callback) => {
+        (0, import_invariant3.invariant)(!this._subscribeCb, "Internal Framer bug. Concurrent writes detected.", {
+          F: __dxlog_file2,
+          L: 40,
+          S: this,
+          A: [
+            "!this._subscribeCb",
+            "'Internal Framer bug. Concurrent writes detected.'"
+          ]
+        });
+        this._bytesReceived += chunk.length;
+        if (this._buffer && this._buffer.length > 0) {
+          this._buffer = Buffer.concat([
+            this._buffer,
+            chunk
+          ]);
+        } else {
+          this._buffer = chunk;
+        }
+        if (this._messageCb) {
+          this._popFrames();
+          callback();
+        } else {
+          this._subscribeCb = () => {
+            this._popFrames();
+            this._subscribeCb = void 0;
+            callback();
+          };
+        }
+      }
+    });
+    this.port = {
+      send: (message) => {
+        return new Promise((resolve) => {
+          const frame = encodeFrame(message);
+          this._bytesSent += frame.length;
+          this._writable = this._stream.push(frame);
+          if (!this._writable) {
+            this._sendCallbacks.push(resolve);
+          } else {
+            resolve();
+          }
+        });
+      },
+      subscribe: (callback) => {
+        (0, import_invariant3.invariant)(!this._messageCb, "Rpc port already has a message listener.", {
+          F: __dxlog_file2,
+          L: 79,
+          S: this,
+          A: [
+            "!this._messageCb",
+            "'Rpc port already has a message listener.'"
+          ]
+        });
+        this._messageCb = callback;
+        this._subscribeCb?.();
+        return () => {
+          this._messageCb = void 0;
+        };
+      }
+    };
+  }
+  get stream() {
+    return this._stream;
+  }
+  get bytesSent() {
+    return this._bytesSent;
+  }
+  get bytesReceived() {
+    return this._bytesReceived;
+  }
+  get writable() {
+    return this._writable;
+  }
+  _processResponseQueue() {
+    const responseQueue = this._sendCallbacks;
+    this._sendCallbacks = [];
+    this._writable = true;
+    this.drain.emit();
+    responseQueue.forEach((cb) => cb());
+  }
+  /**
+  * Attempts to pop frames from the buffer and call the message callback.
+  */
+  _popFrames() {
+    let offset = 0;
+    while (offset < this._buffer.length) {
+      const frame = decodeFrame(this._buffer, offset);
+      if (!frame) {
+        break;
+      }
+      offset += frame.bytesConsumed;
+      this._messageCb(frame.payload);
+    }
+    if (offset < this._buffer.length) {
+      this._buffer = this._buffer.subarray(offset);
+    } else {
+      this._buffer = void 0;
+    }
+  }
+  destroy() {
+    if (this._stream.readableLength > 0) {
+      import_log4.log.info("framer destroyed while there are still read bytes in the buffer.", void 0, {
+        F: __dxlog_file2,
+        L: 140,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+    if (this._stream.writableLength > 0) {
+      import_log4.log.warn("framer destroyed while there are still write bytes in the buffer.", void 0, {
+        F: __dxlog_file2,
+        L: 143,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+    this._stream.destroy();
+  }
+};
+var decodeFrame = (buffer, offset) => {
+  if (buffer.length < offset + FRAME_LENGTH_SIZE) {
+    return void 0;
+  }
+  const frameLength = buffer.readUInt16BE(offset);
+  const bytesConsumed = FRAME_LENGTH_SIZE + frameLength;
+  if (buffer.length < offset + bytesConsumed) {
+    return void 0;
+  }
+  const payload = buffer.subarray(offset + FRAME_LENGTH_SIZE, offset + bytesConsumed);
+  return {
+    payload,
+    bytesConsumed
+  };
+};
+var encodeFrame = (payload) => {
+  const frame = Buffer.allocUnsafe(FRAME_LENGTH_SIZE + payload.length);
+  frame.writeUInt16BE(payload.length, 0);
+  frame.set(payload, FRAME_LENGTH_SIZE);
+  return frame;
+};
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/balancer.ts";
+var MAX_CHUNK_SIZE = 8192;
+var Balancer = class {
+  constructor(_sysChannelId) {
+    this._sysChannelId = _sysChannelId;
+    this._lastCallerIndex = 0;
+    this._channels = [];
+    this._framer = new Framer();
+    this._sendBuffers = /* @__PURE__ */ new Map();
+    this._receiveBuffers = /* @__PURE__ */ new Map();
+    this._sending = false;
+    this.incomingData = new import_async5.Event();
+    this.stream = this._framer.stream;
+    this._channels.push(_sysChannelId);
+    this._framer.port.subscribe(this._processIncomingMessage.bind(this));
+  }
+  get bytesSent() {
+    return this._framer.bytesSent;
+  }
+  get bytesReceived() {
+    return this._framer.bytesReceived;
+  }
+  get buffersCount() {
+    return this._sendBuffers.size;
+  }
+  addChannel(channel) {
+    this._channels.push(channel);
+  }
+  pushData(data, trigger, channelId) {
+    this._enqueueChunk(data, trigger, channelId);
+    this._sendChunks().catch((err) => import_log6.log.catch(err, void 0, {
+      F: __dxlog_file3,
+      L: 75,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+  }
+  destroy() {
+    if (this._sendBuffers.size !== 0) {
+      import_log6.log.info("destroying balancer with pending calls", void 0, {
+        F: __dxlog_file3,
+        L: 80,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+    this._sendBuffers.clear();
+    this._framer.destroy();
+  }
+  _processIncomingMessage(msg) {
+    const { channelId, dataLength, chunk } = decodeChunk(msg, (channelId2) => !this._receiveBuffers.has(channelId2));
+    if (!this._receiveBuffers.has(channelId)) {
+      if (chunk.length < dataLength) {
+        this._receiveBuffers.set(channelId, {
+          buffer: Buffer.from(chunk),
+          msgLength: dataLength
+        });
+      } else {
+        this.incomingData.emit(chunk);
+      }
+    } else {
+      const channelBuffer = this._receiveBuffers.get(channelId);
+      channelBuffer.buffer = Buffer.concat([
+        channelBuffer.buffer,
+        chunk
+      ]);
+      if (channelBuffer.buffer.length < channelBuffer.msgLength) {
+        return;
+      }
+      const msg2 = channelBuffer.buffer;
+      this._receiveBuffers.delete(channelId);
+      this.incomingData.emit(msg2);
+    }
+  }
+  _getNextCallerId() {
+    if (this._sendBuffers.has(this._sysChannelId)) {
+      return this._sysChannelId;
+    }
+    const index = this._lastCallerIndex;
+    this._lastCallerIndex = (this._lastCallerIndex + 1) % this._channels.length;
+    return this._channels[index];
+  }
+  _enqueueChunk(data, trigger, channelId) {
+    if (!this._channels.includes(channelId)) {
+      throw new Error(`Unknown channel ${channelId}`);
+    }
+    if (!this._sendBuffers.has(channelId)) {
+      this._sendBuffers.set(channelId, []);
+    }
+    const sendBuffer = this._sendBuffers.get(channelId);
+    const chunks = [];
+    for (let idx = 0; idx < data.length; idx += MAX_CHUNK_SIZE) {
+      chunks.push(data.subarray(idx, idx + MAX_CHUNK_SIZE));
+    }
+    chunks.forEach((chunk, index) => {
+      const msg = encodeChunk({
+        chunk,
+        channelId,
+        dataLength: index === 0 ? data.length : void 0
+      });
+      sendBuffer.push({
+        msg,
+        trigger: index === chunks.length - 1 ? trigger : void 0
+      });
+    });
+  }
+  // get the next chunk or null if there are no chunks remaining
+  _getNextChunk() {
+    let chunk;
+    while (this._sendBuffers.size > 0) {
+      const channelId = this._getNextCallerId();
+      const sendBuffer = this._sendBuffers.get(channelId);
+      if (!sendBuffer) {
+        continue;
+      }
+      chunk = sendBuffer.shift();
+      if (!chunk) {
+        continue;
+      }
+      if (sendBuffer.length === 0) {
+        this._sendBuffers.delete(channelId);
+      }
+      return chunk;
+    }
+    return null;
+  }
+  async _sendChunks() {
+    if (this._sending) {
+      return;
+    }
+    this._sending = true;
+    let chunk;
+    chunk = this._getNextChunk();
+    while (chunk) {
+      if (!this._framer.writable) {
+        (0, import_log6.log)("PAUSE for drain", void 0, {
+          F: __dxlog_file3,
+          L: 179,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        await this._framer.drain.waitForCount(1);
+        (0, import_log6.log)("RESUME for drain", void 0, {
+          F: __dxlog_file3,
+          L: 181,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+      try {
+        await this._framer.port.send(chunk.msg);
+        chunk.trigger?.wake();
+      } catch (err) {
+        (0, import_log6.log)("Error sending chunk", {
+          err
+        }, {
+          F: __dxlog_file3,
+          L: 187,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        chunk.trigger?.throw(err);
+      }
+      chunk = this._getNextChunk();
+    }
+    (0, import_invariant5.invariant)(this._sendBuffers.size === 0, "sendBuffers not empty", {
+      F: __dxlog_file3,
+      L: 192,
+      S: this,
+      A: [
+        "this._sendBuffers.size === 0",
+        "'sendBuffers not empty'"
+      ]
+    });
+    this._sending = false;
+  }
+};
+var encodeChunk = ({ channelId, dataLength, chunk }) => {
+  const channelTagLength = varint.encodingLength(channelId);
+  const dataLengthLength = dataLength ? varint.encodingLength(dataLength) : 0;
+  const message = Buffer.allocUnsafe(channelTagLength + dataLengthLength + chunk.length);
+  varint.encode(channelId, message);
+  if (dataLength) {
+    varint.encode(dataLength, message, channelTagLength);
+  }
+  message.set(chunk, channelTagLength + dataLengthLength);
+  return message;
+};
+var decodeChunk = (data, withLength) => {
+  const channelId = varint.decode(data);
+  let dataLength;
+  let offset = varint.decode.bytes;
+  if (withLength(channelId)) {
+    dataLength = varint.decode(data, offset);
+    offset += varint.decode.bytes;
+  }
+  const chunk = data.subarray(offset);
+  return {
+    channelId,
+    dataLength,
+    chunk
+  };
+};
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/muxer.ts";
+var Command = import_protocols3.schema.getCodecForType("dxos.mesh.muxer.Command");
+var DEFAULT_SEND_COMMAND_TIMEOUT = 6e4;
+var DESTROY_COMMAND_SEND_TIMEOUT = 5e3;
+var STATS_INTERVAL = 1e3;
+var MAX_SAFE_FRAME_SIZE = 1e6;
+var SYSTEM_CHANNEL_ID = 0;
+var GRACEFUL_CLOSE_TIMEOUT = 3e3;
+var Muxer = class {
+  constructor() {
+    this._balancer = new Balancer(SYSTEM_CHANNEL_ID);
+    this._channelsByLocalId = /* @__PURE__ */ new Map();
+    this._channelsByTag = /* @__PURE__ */ new Map();
+    this._ctx = new import_context3.Context();
+    this._nextId = 1;
+    this._closing = false;
+    this._destroying = false;
+    this._disposed = false;
+    this._lastStats = void 0;
+    this._lastChannelStats = /* @__PURE__ */ new Map();
+    this.afterClosed = new import_async4.Event();
+    this.statsUpdated = new import_async4.Event();
+    this.stream = this._balancer.stream;
+    this._balancer.incomingData.on(async (msg) => {
+      await this._handleCommand(Command.decode(msg));
+    });
+  }
+  /**
+  * Creates a duplex Node.js-style stream.
+  * The remote peer is expected to call `createStream` with the same tag.
+  * The stream is immediately readable and writable.
+  * NOTE: The data will be buffered until the stream is opened remotely with the same tag (may cause a memory leak).
+  */
+  async createStream(tag, opts = {}) {
+    const channel = this._getOrCreateStream({
+      tag,
+      contentType: opts.contentType
+    });
+    (0, import_invariant4.invariant)(!channel.push, `Channel already open: ${tag}`, {
+      F: __dxlog_file4,
+      L: 140,
+      S: this,
+      A: [
+        "!channel.push",
+        "`Channel already open: ${tag}`"
+      ]
+    });
+    const stream = new import_node_stream3.Duplex({
+      write: (data, encoding, callback) => {
+        this._sendData(channel, data).then(() => callback()).catch(callback);
+      },
+      read: () => {
+      }
+    });
+    channel.push = (data) => {
+      channel.stats.bytesReceived += data.length;
+      stream.push(data);
+    };
+    channel.destroy = (err) => {
+      stream.destroy(err);
+    };
+    try {
+      await this._sendCommand({
+        openChannel: {
+          id: channel.id,
+          tag: channel.tag,
+          contentType: channel.contentType
+        }
+      }, SYSTEM_CHANNEL_ID);
+    } catch (err) {
+      this._destroyChannel(channel, err);
+      throw err;
+    }
+    return stream;
+  }
+  /**
+  * Creates an RPC port.
+  * The remote peer is expected to call `createPort` with the same tag.
+  * The port is immediately usable.
+  * NOTE: The data will be buffered until the stream is opened remotely with the same tag (may cause a memory leak).
+  */
+  async createPort(tag, opts = {}) {
+    const channel = this._getOrCreateStream({
+      tag,
+      contentType: opts.contentType
+    });
+    (0, import_invariant4.invariant)(!channel.push, `Channel already open: ${tag}`, {
+      F: __dxlog_file4,
+      L: 192,
+      S: this,
+      A: [
+        "!channel.push",
+        "`Channel already open: ${tag}`"
+      ]
+    });
+    let inboundBuffer = [];
+    let callback;
+    channel.push = (data) => {
+      channel.stats.bytesReceived += data.length;
+      if (callback) {
+        callback(data);
+      } else {
+        inboundBuffer.push(data);
+      }
+    };
+    const port = {
+      send: async (data, timeout) => {
+        await this._sendData(channel, data, timeout);
+      },
+      subscribe: (cb) => {
+        (0, import_invariant4.invariant)(!callback, "Only one subscriber is allowed", {
+          F: __dxlog_file4,
+          L: 214,
+          S: this,
+          A: [
+            "!callback",
+            "'Only one subscriber is allowed'"
+          ]
+        });
+        callback = cb;
+        for (const data of inboundBuffer) {
+          cb(data);
+        }
+        inboundBuffer = [];
+      }
+    };
+    try {
+      await this._sendCommand({
+        openChannel: {
+          id: channel.id,
+          tag: channel.tag,
+          contentType: channel.contentType
+        }
+      }, SYSTEM_CHANNEL_ID);
+    } catch (err) {
+      this._destroyChannel(channel, err);
+      throw err;
+    }
+    return port;
+  }
+  // initiate graceful close
+  async close(err) {
+    if (this._destroying) {
+      (0, import_log5.log)("already destroying, ignoring graceful close request", void 0, {
+        F: __dxlog_file4,
+        L: 247,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    if (this._closing) {
+      (0, import_log5.log)("already closing, ignoring graceful close request", void 0, {
+        F: __dxlog_file4,
+        L: 251,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    this._closing = true;
+    await this._sendCommand({
+      close: {
+        error: err?.message
+      }
+    }, SYSTEM_CHANNEL_ID, DESTROY_COMMAND_SEND_TIMEOUT).catch(async (err2) => {
+      (0, import_log5.log)("error sending close command", {
+        err: err2
+      }, {
+        F: __dxlog_file4,
+        L: 266,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await this.dispose(err2);
+    });
+    await Promise.race([
+      new Promise((_resolve, reject) => {
+        setTimeout(() => {
+          reject(new import_protocols3.TimeoutError("gracefully closing muxer"));
+        }, GRACEFUL_CLOSE_TIMEOUT);
+      }),
+      (async () => {
+        await this.dispose(err);
+      })()
+    ]);
+  }
+  // force close without confirmation
+  async destroy(err) {
+    if (this._destroying) {
+      (0, import_log5.log)("already destroying, ignoring destroy request", void 0, {
+        F: __dxlog_file4,
+        L: 287,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    this._destroying = true;
+    void this._ctx.dispose();
+    if (this._closing) {
+      (0, import_log5.log)("destroy cancelling graceful close", void 0, {
+        F: __dxlog_file4,
+        L: 293,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._closing = false;
+    } else {
+      await this._sendCommand({
+        close: {
+          error: err?.message
+        }
+      }, SYSTEM_CHANNEL_ID).catch(async (err2) => {
+        (0, import_log5.log)("error sending courtesy close command", {
+          err: err2
+        }, {
+          F: __dxlog_file4,
+          L: 306,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      });
+    }
+    this.dispose(err).catch((err2) => {
+      (0, import_log5.log)("error disposing after destroy", {
+        err: err2
+      }, {
+        F: __dxlog_file4,
+        L: 311,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+  }
+  // complete the termination, graceful or otherwise
+  async dispose(err) {
+    if (this._disposed) {
+      (0, import_log5.log)("already destroyed, ignoring dispose request", void 0, {
+        F: __dxlog_file4,
+        L: 319,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    void this._ctx.dispose();
+    await this._balancer.destroy();
+    for (const channel of this._channelsByTag.values()) {
+      channel.destroy?.(err);
+    }
+    this._disposed = true;
+    this.afterClosed.emit(err);
+    this._channelsByLocalId.clear();
+    this._channelsByTag.clear();
+  }
+  async _handleCommand(cmd) {
+    if (this._disposed) {
+      import_log5.log.warn("Received command after disposed", {
+        cmd
+      }, {
+        F: __dxlog_file4,
+        L: 341,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    if (cmd.close) {
+      if (!this._closing) {
+        (0, import_log5.log)("received peer close, initiating my own graceful close", void 0, {
+          F: __dxlog_file4,
+          L: 347,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        await this.close();
+      } else {
+        (0, import_log5.log)("received close from peer, already closing", void 0, {
+          F: __dxlog_file4,
+          L: 350,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+      return;
+    }
+    if (cmd.openChannel) {
+      const channel = this._getOrCreateStream({
+        tag: cmd.openChannel.tag,
+        contentType: cmd.openChannel.contentType
+      });
+      channel.remoteId = cmd.openChannel.id;
+      for (const data of channel.buffer) {
+        await this._sendCommand({
+          data: {
+            channelId: channel.remoteId,
+            data
+          }
+        }, channel.id);
+      }
+      channel.buffer = [];
+    } else if (cmd.data) {
+      const stream = this._channelsByLocalId.get(cmd.data.channelId) ?? (0, import_debug2.failUndefined)();
+      if (!stream.push) {
+        import_log5.log.warn("Received data for channel before it was opened", {
+          tag: stream.tag
+        }, {
+          F: __dxlog_file4,
+          L: 379,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      stream.push(cmd.data.data);
+    }
+  }
+  async _sendCommand(cmd, channelId = -1, timeout = DEFAULT_SEND_COMMAND_TIMEOUT) {
+    if (this._disposed) {
+      import_log5.log.info("ignoring sendCommand after disposed", {
+        cmd
+      }, {
+        F: __dxlog_file4,
+        L: 388,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    try {
+      const trigger = new import_async4.Trigger();
+      this._balancer.pushData(Command.encode(cmd), trigger, channelId);
+      await trigger.wait({
+        timeout
+      });
+    } catch (err) {
+      await this.destroy(err);
+    }
+  }
+  _getOrCreateStream(params) {
+    if (this._channelsByTag.size === 0) {
+      (0, import_async4.scheduleTaskInterval)(this._ctx, async () => this._emitStats(), STATS_INTERVAL);
+    }
+    let channel = this._channelsByTag.get(params.tag);
+    if (!channel) {
+      channel = {
+        id: this._nextId++,
+        remoteId: null,
+        tag: params.tag,
+        contentType: params.contentType,
+        buffer: [],
+        push: null,
+        destroy: null,
+        stats: {
+          bytesSent: 0,
+          bytesReceived: 0
+        }
+      };
+      this._channelsByTag.set(channel.tag, channel);
+      this._channelsByLocalId.set(channel.id, channel);
+      this._balancer.addChannel(channel.id);
+    }
+    return channel;
+  }
+  async _sendData(channel, data, timeout) {
+    if (data.length > MAX_SAFE_FRAME_SIZE) {
+      import_log5.log.warn("frame size exceeds maximum safe value", {
+        size: data.length,
+        threshold: MAX_SAFE_FRAME_SIZE
+      }, {
+        F: __dxlog_file4,
+        L: 429,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+    channel.stats.bytesSent += data.length;
+    if (channel.remoteId === null) {
+      channel.buffer.push(data);
+      return;
+    }
+    await this._sendCommand({
+      data: {
+        channelId: channel.remoteId,
+        data
+      }
+    }, channel.id, timeout);
+  }
+  _destroyChannel(channel, err) {
+    if (channel.destroy) {
+      channel.destroy(err);
+    }
+    this._channelsByLocalId.delete(channel.id);
+    this._channelsByTag.delete(channel.tag);
+  }
+  async _emitStats() {
+    if (this._disposed || this._destroying) {
+      this._lastStats = void 0;
+      this._lastChannelStats.clear();
+      return;
+    }
+    const bytesSent = this._balancer.bytesSent;
+    const bytesReceived = this._balancer.bytesReceived;
+    const now = Date.now();
+    const interval = this._lastStats ? (now - this._lastStats.timestamp) / 1e3 : 0;
+    const calculateThroughput = (current, last) => last ? {
+      bytesSentRate: interval ? (current.bytesSent - last.bytesSent) / interval : void 0,
+      bytesReceivedRate: interval ? (current.bytesReceived - last.bytesReceived) / interval : void 0
+    } : {};
+    this._lastStats = {
+      timestamp: now,
+      channels: Array.from(this._channelsByTag.values()).map((channel) => {
+        const stats = {
+          id: channel.id,
+          tag: channel.tag,
+          contentType: channel.contentType,
+          writeBufferSize: channel.buffer.length,
+          bytesSent: channel.stats.bytesSent,
+          bytesReceived: channel.stats.bytesReceived,
+          ...calculateThroughput(channel.stats, this._lastChannelStats.get(channel.id))
+        };
+        this._lastChannelStats.set(channel.id, stats);
+        return stats;
+      }),
+      bytesSent,
+      bytesReceived,
+      ...calculateThroughput({
+        bytesSent,
+        bytesReceived
+      }, this._lastStats),
+      readBufferSize: this._balancer.stream.readableLength,
+      writeBufferSize: this._balancer.stream.writableLength
+    };
+    this.statsUpdated.emit(this._lastStats);
+  }
+};
+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 __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts";
+var CONTROL_HEARTBEAT_INTERVAL = 1e4;
+var CONTROL_HEARTBEAT_TIMEOUT = 6e4;
+var Teleport = class {
+  constructor({ initiator, localPeerId, remotePeerId }) {
+    this._ctx = new import_context.Context({
+      onError: (err) => {
+        void this.destroy(err).catch(() => {
+          import_log2.log.error("Error during destroy", err, {
+            F: __dxlog_file5,
+            L: 38,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        });
+      }
+    });
+    this._muxer = new Muxer();
+    this._extensions = /* @__PURE__ */ new Map();
+    this._remoteExtensions = /* @__PURE__ */ new Set();
+    this._open = false;
+    this._destroying = false;
+    this._aborting = false;
+    (0, import_invariant2.invariant)(typeof initiator === "boolean", void 0, {
+      F: __dxlog_file5,
+      L: 55,
+      S: this,
+      A: [
+        "typeof initiator === 'boolean'",
+        ""
+      ]
+    });
+    (0, import_invariant2.invariant)(import_keys2.PublicKey.isPublicKey(localPeerId), void 0, {
+      F: __dxlog_file5,
+      L: 56,
+      S: this,
+      A: [
+        "PublicKey.isPublicKey(localPeerId)",
+        ""
+      ]
+    });
+    (0, import_invariant2.invariant)(import_keys2.PublicKey.isPublicKey(remotePeerId), void 0, {
+      F: __dxlog_file5,
+      L: 57,
+      S: this,
+      A: [
+        "PublicKey.isPublicKey(remotePeerId)",
+        ""
+      ]
+    });
+    this.initiator = initiator;
+    this.localPeerId = localPeerId;
+    this.remotePeerId = remotePeerId;
+    this._control = new ControlExtension({
+      heartbeatInterval: CONTROL_HEARTBEAT_INTERVAL,
+      heartbeatTimeout: CONTROL_HEARTBEAT_TIMEOUT,
+      onTimeout: () => {
+        if (this._destroying || this._aborting) {
+          return;
+        }
+        import_log2.log.info("abort teleport due to onTimeout in ControlExtension", void 0, {
+          F: __dxlog_file5,
+          L: 70,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this.abort(new import_protocols.TimeoutError("control extension")).catch((err) => import_log2.log.catch(err, void 0, {
+          F: __dxlog_file5,
+          L: 71,
+          S: this,
+          C: (f, a) => f(...a)
+        }));
+      }
+    }, this.localPeerId, this.remotePeerId);
+    this._control.onExtensionRegistered.set(async (name) => {
+      (0, import_log2.log)("remote extension", {
+        name
+      }, {
+        F: __dxlog_file5,
+        L: 79,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      (0, import_invariant2.invariant)(!this._remoteExtensions.has(name), "Remote extension already exists", {
+        F: __dxlog_file5,
+        L: 80,
+        S: this,
+        A: [
+          "!this._remoteExtensions.has(name)",
+          "'Remote extension already exists'"
+        ]
+      });
+      this._remoteExtensions.add(name);
+      if (this._extensions.has(name)) {
+        try {
+          await this._openExtension(name);
+        } catch (err) {
+          await this.destroy(err);
+        }
+      }
+    });
+    {
+      this._muxer.stream.on("close", async () => {
+        if (this._destroying || this._aborting) {
+          (0, import_log2.log)("destroy teleport due to muxer stream close, skipping due to already destroying/aborting", void 0, {
+            F: __dxlog_file5,
+            L: 96,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return;
+        }
+        await this.destroy();
+      });
+      this._muxer.stream.on("error", async (err) => {
+        await this.destroy(err);
+      });
+    }
+    this._muxer.statsUpdated.on((stats) => {
+      import_log2.log.trace("dxos.mesh.teleport.stats", {
+        localPeerId,
+        remotePeerId,
+        bytesSent: stats.bytesSent,
+        bytesSentRate: stats.bytesSentRate,
+        bytesReceived: stats.bytesReceived,
+        bytesReceivedRate: stats.bytesReceivedRate,
+        channels: stats.channels
+      }, {
+        F: __dxlog_file5,
+        L: 109,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+  }
+  get stream() {
+    return this._muxer.stream;
+  }
+  get stats() {
+    return this._muxer.statsUpdated;
+  }
+  /**
+  * Blocks until the handshake is complete.
+  */
+  async open() {
+    this._setExtension("dxos.mesh.teleport.control", this._control);
+    await this._openExtension("dxos.mesh.teleport.control");
+    this._open = true;
+  }
+  async close(err) {
+    await this.destroy(err);
+  }
+  async abort(err) {
+    if (this._aborting || this._destroying) {
+      return;
+    }
+    this._aborting = true;
+    if (this._ctx.disposed) {
+      return;
+    }
+    await this._ctx.dispose();
+    for (const extension of this._extensions.values()) {
+      try {
+        await extension.onAbort(err);
+      } catch (err2) {
+        import_log2.log.catch(err2, void 0, {
+          F: __dxlog_file5,
+          L: 162,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+    await this._muxer.destroy(err);
+  }
+  async destroy(err) {
+    if (this._destroying || this._aborting) {
+      return;
+    }
+    this._destroying = true;
+    if (this._ctx.disposed) {
+      return;
+    }
+    await this._ctx.dispose();
+    for (const extension of this._extensions.values()) {
+      try {
+        await extension.onClose(err);
+      } catch (err2) {
+        import_log2.log.catch(err2, void 0, {
+          F: __dxlog_file5,
+          L: 186,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+    await this._muxer.close();
+  }
+  addExtension(name, extension) {
+    if (!this._open) {
+      throw new Error("Not open");
+    }
+    (0, import_log2.log)("addExtension", {
+      name
+    }, {
+      F: __dxlog_file5,
+      L: 198,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._setExtension(name, extension);
+    (0, import_async.scheduleTask)(this._ctx, async () => {
+      try {
+        await this._control.registerExtension(name);
+      } catch (err) {
+        if (err instanceof import_protocols.RpcClosedError) {
+          return;
+        }
+        throw err;
+      }
+    });
+    if (this._remoteExtensions.has(name)) {
+      (0, import_async.scheduleTask)(this._ctx, async () => {
+        await this._openExtension(name);
+      });
+    }
+  }
+  _setExtension(extensionName, extension) {
+    (0, import_invariant2.invariant)(!extensionName.includes("/"), "Invalid extension name", {
+      F: __dxlog_file5,
+      L: 222,
+      S: this,
+      A: [
+        "!extensionName.includes('/')",
+        "'Invalid extension name'"
+      ]
+    });
+    (0, import_invariant2.invariant)(!this._extensions.has(extensionName), "Extension already exists", {
+      F: __dxlog_file5,
+      L: 223,
+      S: this,
+      A: [
+        "!this._extensions.has(extensionName)",
+        "'Extension already exists'"
+      ]
+    });
+    this._extensions.set(extensionName, extension);
+  }
+  async _openExtension(extensionName) {
+    (0, import_log2.log)("open extension", {
+      extensionName
+    }, {
+      F: __dxlog_file5,
+      L: 228,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const extension = this._extensions.get(extensionName) ?? (0, import_debug.failUndefined)();
+    const context = {
+      initiator: this.initiator,
+      localPeerId: this.localPeerId,
+      remotePeerId: this.remotePeerId,
+      createPort: async (channelName, opts) => {
+        (0, import_invariant2.invariant)(!channelName.includes("/"), "Invalid channel name", {
+          F: __dxlog_file5,
+          L: 236,
+          S: this,
+          A: [
+            "!channelName.includes('/')",
+            "'Invalid channel name'"
+          ]
+        });
+        return this._muxer.createPort(`${extensionName}/${channelName}`, opts);
+      },
+      createStream: async (channelName, opts) => {
+        (0, import_invariant2.invariant)(!channelName.includes("/"), "Invalid channel name", {
+          F: __dxlog_file5,
+          L: 240,
+          S: this,
+          A: [
+            "!channelName.includes('/')",
+            "'Invalid channel name'"
+          ]
+        });
+        return this._muxer.createStream(`${extensionName}/${channelName}`, opts);
+      },
+      close: (err) => {
+        void (0, import_async.runInContextAsync)(this._ctx, async () => {
+          await this.close(err);
+        });
+      }
+    };
+    await extension.onOpen(context);
+    (0, import_log2.log)("extension opened", {
+      extensionName
+    }, {
+      F: __dxlog_file5,
+      L: 251,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+};
+_ts_decorate([
+  import_async.synchronized
+], Teleport.prototype, "abort", null);
+_ts_decorate([
+  import_async.synchronized
+], Teleport.prototype, "destroy", null);
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-builder.ts";
+var TestBuilder = class {
+  constructor() {
+    this._peers = /* @__PURE__ */ new Set();
+  }
+  createPeer(opts) {
+    const peer = opts.factory();
+    this._peers.add(peer);
+    return peer;
+  }
+  *createPeers(opts) {
+    while (true) {
+      yield this.createPeer(opts);
+    }
+  }
+  async destroy() {
+    await Promise.all(Array.from(this._peers).map((agent) => agent.destroy()));
+  }
+  async connect(peer1, peer2) {
+    (0, import_invariant.invariant)(peer1 !== peer2, void 0, {
+      F: __dxlog_file6,
+      L: 37,
+      S: this,
+      A: [
+        "peer1 !== peer2",
+        ""
+      ]
+    });
+    (0, import_invariant.invariant)(this._peers.has(peer1), void 0, {
+      F: __dxlog_file6,
+      L: 38,
+      S: this,
+      A: [
+        "this._peers.has(peer1)",
+        ""
+      ]
+    });
+    (0, import_invariant.invariant)(this._peers.has(peer1), void 0, {
+      F: __dxlog_file6,
+      L: 39,
+      S: this,
+      A: [
+        "this._peers.has(peer1)",
+        ""
+      ]
+    });
+    const connection1 = peer1.createConnection({
+      initiator: true,
+      remotePeerId: peer2.peerId
+    });
+    const connection2 = peer2.createConnection({
+      initiator: false,
+      remotePeerId: peer1.peerId
+    });
+    pipeStreams(connection1.teleport.stream, connection2.teleport.stream);
+    await Promise.all([
+      peer1.openConnection(connection1),
+      peer2.openConnection(connection2)
+    ]);
+    return [
+      connection1,
+      connection2
+    ];
+  }
+  async disconnect(peer1, peer2) {
+    (0, import_invariant.invariant)(peer1 !== peer2, void 0, {
+      F: __dxlog_file6,
+      L: 51,
+      S: this,
+      A: [
+        "peer1 !== peer2",
+        ""
+      ]
+    });
+    (0, import_invariant.invariant)(this._peers.has(peer1), void 0, {
+      F: __dxlog_file6,
+      L: 52,
+      S: this,
+      A: [
+        "this._peers.has(peer1)",
+        ""
+      ]
+    });
+    (0, import_invariant.invariant)(this._peers.has(peer1), void 0, {
+      F: __dxlog_file6,
+      L: 53,
+      S: this,
+      A: [
+        "this._peers.has(peer1)",
+        ""
+      ]
+    });
+    const connection1 = Array.from(peer1.connections).find((connection) => connection.remotePeerId.equals(peer2.peerId));
+    const connection2 = Array.from(peer2.connections).find((connection) => connection.remotePeerId.equals(peer1.peerId));
+    (0, import_invariant.invariant)(connection1, void 0, {
+      F: __dxlog_file6,
+      L: 62,
+      S: this,
+      A: [
+        "connection1",
+        ""
+      ]
+    });
+    (0, import_invariant.invariant)(connection2, void 0, {
+      F: __dxlog_file6,
+      L: 63,
+      S: this,
+      A: [
+        "connection2",
+        ""
+      ]
+    });
+    await Promise.all([
+      peer1.closeConnection(connection1),
+      peer2.closeConnection(connection2)
+    ]);
+  }
+};
+var TestPeer = class {
+  constructor(peerId = import_keys.PublicKey.random()) {
+    this.peerId = peerId;
+    this.connections = /* @__PURE__ */ new Set();
+  }
+  async onOpen(connection) {
+  }
+  async onClose(connection) {
+  }
+  createConnection({ initiator, remotePeerId }) {
+    const connection = new TestConnection(this.peerId, remotePeerId, initiator);
+    this.connections.add(connection);
+    return connection;
+  }
+  async openConnection(connection) {
+    (0, import_invariant.invariant)(this.connections.has(connection), void 0, {
+      F: __dxlog_file6,
+      L: 84,
+      S: this,
+      A: [
+        "this.connections.has(connection)",
+        ""
+      ]
+    });
+    await connection.teleport.open();
+    await this.onOpen(connection);
+  }
+  async closeConnection(connection) {
+    (0, import_invariant.invariant)(this.connections.has(connection), void 0, {
+      F: __dxlog_file6,
+      L: 90,
+      S: this,
+      A: [
+        "this.connections.has(connection)",
+        ""
+      ]
+    });
+    await this.onClose(connection);
+    await connection.teleport.close();
+    this.connections.delete(connection);
+  }
+  async destroy() {
+    for (const teleport of this.connections) {
+      await this.closeConnection(teleport);
+    }
+  }
+};
+var pipeStreams = (stream1, stream2) => {
+  (0, import_node_stream.pipeline)(stream1, stream2, (err) => {
+    if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+      import_log.log.catch(err, void 0, {
+        F: __dxlog_file6,
+        L: 106,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  });
+  (0, import_node_stream.pipeline)(stream2, stream1, (err) => {
+    if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+      import_log.log.catch(err, void 0, {
+        F: __dxlog_file6,
+        L: 111,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  });
+};
+var TestConnection = class {
+  constructor(localPeerId, remotePeerId, initiator) {
+    this.localPeerId = localPeerId;
+    this.remotePeerId = remotePeerId;
+    this.initiator = initiator;
+    this.teleport = new Teleport({
+      initiator,
+      localPeerId,
+      remotePeerId
+    });
+  }
+};
+var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-extension.ts";
+var TestExtension = class {
+  constructor(callbacks = {}) {
+    this.callbacks = callbacks;
+    this.open = new import_async6.Trigger();
+    this.closed = new import_async6.Trigger();
+    this.aborted = new import_async6.Trigger();
+  }
+  get remotePeerId() {
+    return this.extensionContext?.remotePeerId;
+  }
+  async onOpen(context) {
+    (0, import_log7.log)("onOpen", {
+      localPeerId: context.localPeerId,
+      remotePeerId: context.remotePeerId
+    }, {
+      F: __dxlog_file7,
+      L: 34,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.extensionContext = context;
+    this._rpc = (0, import_rpc2.createProtoRpcPeer)({
+      port: await context.createPort("rpc", {
+        contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
+      }),
+      requested: {
+        TestService: import_protocols4.schema.getService("example.testing.rpc.TestService")
+      },
+      exposed: {
+        TestService: import_protocols4.schema.getService("example.testing.rpc.TestService")
+      },
+      handlers: {
+        TestService: {
+          voidCall: async (request) => {
+          },
+          testCall: async (request) => {
+            return {
+              data: request.data
+            };
+          }
+        }
+      },
+      timeout: 2e3
+    });
+    await this._rpc.open();
+    await this.callbacks.onOpen?.();
+    this.open.wake();
+  }
+  async onClose(err) {
+    (0, import_log7.log)("onClose", {
+      err
+    }, {
+      F: __dxlog_file7,
+      L: 68,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this.callbacks.onClose?.();
+    this.closed.wake();
+    await this._rpc?.close();
+  }
+  async onAbort(err) {
+    (0, import_log7.log)("onAbort", {
+      err
+    }, {
+      F: __dxlog_file7,
+      L: 75,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this.callbacks.onAbort?.();
+    this.aborted.wake();
+    await this._rpc?.abort();
+  }
+  async test(message = "test") {
+    await this.open.wait({
+      timeout: 1500
+    });
+    const res = await (0, import_async6.asyncTimeout)(this._rpc.rpc.TestService.testCall({
+      data: message
+    }), 1500);
+    (0, import_invariant6.invariant)(res.data === message, void 0, {
+      F: __dxlog_file7,
+      L: 84,
+      S: this,
+      A: [
+        "res.data === message",
+        ""
+      ]
+    });
+  }
+  /**
+  * Force-close the connection.
+  */
+  async closeConnection(err) {
+    this.extensionContext?.close(err);
+  }
+};
+var __dxlog_file8 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-extension-with-streams.ts";
+var TestExtensionWithStreams = class {
+  constructor(callbacks = {}) {
+    this.callbacks = callbacks;
+    this.open = new import_async7.Trigger();
+    this.closed = new import_async7.Trigger();
+    this.aborted = new import_async7.Trigger();
+    this._streams = /* @__PURE__ */ new Map();
+  }
+  get remotePeerId() {
+    return this.extensionContext?.remotePeerId;
+  }
+  async _openStream(streamTag, interval = 5, chunkSize = 2048) {
+    (0, import_invariant7.invariant)(!this._streams.has(streamTag), `Stream already exists: ${streamTag}`, {
+      F: __dxlog_file8,
+      L: 39,
+      S: this,
+      A: [
+        "!this._streams.has(streamTag)",
+        "`Stream already exists: ${streamTag}`"
+      ]
+    });
+    const networkStream = await this.extensionContext.createStream(streamTag, {
+      contentType: "application/x-test-stream"
+    });
+    const streamEntry = {
+      networkStream,
+      bytesSent: 0,
+      bytesReceived: 0,
+      sendErrors: 0,
+      receiveErrors: 0,
+      startTimestamp: Date.now()
+    };
+    const pushChunk = () => {
+      streamEntry.timer = setTimeout(() => {
+        const chunk = (0, import_node_crypto.randomBytes)(chunkSize);
+        if (!networkStream.write(chunk, "binary", (err) => {
+          if (!err) {
+            streamEntry.bytesSent += chunk.length;
+          } else {
+            streamEntry.sendErrors += 1;
+          }
+        })) {
+          networkStream.once("drain", pushChunk);
+        } else {
+          process.nextTick(pushChunk);
+        }
+      }, interval);
+    };
+    pushChunk();
+    this._streams.set(streamTag, streamEntry);
+    networkStream.on("data", (data) => {
+      streamEntry.bytesReceived += data.length;
+    });
+    networkStream.on("error", (err) => {
+      streamEntry.receiveErrors += 1;
+    });
+    networkStream.on("close", () => {
+      networkStream.removeAllListeners();
+    });
+    streamEntry.reportingTimer = setInterval(() => {
+      const { bytesSent, bytesReceived, sendErrors, receiveErrors } = streamEntry;
+      import_log8.log.trace("dxos.test.stream-stats", {
+        streamTag,
+        bytesSent,
+        bytesReceived,
+        sendErrors,
+        receiveErrors,
+        from: this.extensionContext?.localPeerId,
+        to: this.extensionContext?.remotePeerId
+      }, {
+        F: __dxlog_file8,
+        L: 93,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }, 100);
+  }
+  _closeStream(streamTag) {
+    (0, import_invariant7.invariant)(this._streams.has(streamTag), `Stream does not exist: ${streamTag}`, {
+      F: __dxlog_file8,
+      L: 106,
+      S: this,
+      A: [
+        "this._streams.has(streamTag)",
+        "`Stream does not exist: ${streamTag}`"
+      ]
+    });
+    const stream = this._streams.get(streamTag);
+    clearTimeout(stream.timer);
+    clearTimeout(stream.reportingTimer);
+    const { bytesSent, bytesReceived, sendErrors, receiveErrors, startTimestamp } = stream;
+    stream.networkStream.destroy();
+    this._streams.delete(streamTag);
+    return {
+      bytesSent,
+      bytesReceived,
+      sendErrors,
+      receiveErrors,
+      runningTime: Date.now() - (startTimestamp ?? 0)
+    };
+  }
+  async onOpen(context) {
+    (0, import_log8.log)("onOpen", {
+      localPeerId: context.localPeerId,
+      remotePeerId: context.remotePeerId
+    }, {
+      F: __dxlog_file8,
+      L: 128,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.extensionContext = context;
+    this._rpc = (0, import_rpc3.createProtoRpcPeer)({
+      port: await context.createPort("rpc", {
+        contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
+      }),
+      requested: {
+        TestServiceWithStreams: import_protocols5.schema.getService("example.testing.rpc.TestServiceWithStreams")
+      },
+      exposed: {
+        TestServiceWithStreams: import_protocols5.schema.getService("example.testing.rpc.TestServiceWithStreams")
+      },
+      handlers: {
+        TestServiceWithStreams: {
+          requestTestStream: async (request) => {
+            const { data: streamTag, streamLoadInterval, streamLoadChunkSize } = request;
+            await this._openStream(streamTag, streamLoadInterval, streamLoadChunkSize);
+            return {
+              data: streamTag
+            };
+          },
+          closeTestStream: async (request) => {
+            const streamTag = request.data;
+            const { bytesSent, bytesReceived, sendErrors, receiveErrors, runningTime } = this._closeStream(streamTag);
+            return {
+              data: streamTag,
+              bytesSent,
+              bytesReceived,
+              sendErrors,
+              receiveErrors,
+              runningTime
+            };
+          }
+        }
+      },
+      timeout: 2e3
+    });
+    await this._rpc.open();
+    await this.callbacks.onOpen?.();
+    this.open.wake();
+  }
+  async onClose(err) {
+    (0, import_log8.log)("onClose", {
+      err
+    }, {
+      F: __dxlog_file8,
+      L: 179,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this.callbacks.onClose?.();
+    this.closed.wake();
+    for (const [streamTag, stream] of Object.entries(this._streams)) {
+      (0, import_log8.log)("closing stream", {
+        streamTag
+      }, {
+        F: __dxlog_file8,
+        L: 183,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      clearTimeout(stream.interval);
+      stream.networkStream.destroy();
+    }
+    await this._rpc?.close();
+  }
+  async onAbort(err) {
+    (0, import_log8.log)("onAbort", {
+      err
+    }, {
+      F: __dxlog_file8,
+      L: 191,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this.callbacks.onAbort?.();
+    this.aborted.wake();
+    await this._rpc?.abort();
+  }
+  async addNewStream(streamLoadInterval, streamLoadChunkSize, streamTag) {
+    await this.open.wait({
+      timeout: 1500
+    });
+    if (!streamTag) {
+      streamTag = `stream-${(0, import_node_crypto.randomBytes)(4).toString("hex")}`;
+    }
+    const { data } = await this._rpc.rpc.TestServiceWithStreams.requestTestStream({
+      data: streamTag,
+      streamLoadInterval,
+      streamLoadChunkSize
+    });
+    (0, import_invariant7.invariant)(data === streamTag, void 0, {
+      F: __dxlog_file8,
+      L: 207,
+      S: this,
+      A: [
+        "data === streamTag",
+        ""
+      ]
+    });
+    await this._openStream(streamTag, streamLoadInterval, streamLoadChunkSize);
+    return streamTag;
+  }
+  async closeStream(streamTag) {
+    await this.open.wait({
+      timeout: 1500
+    });
+    const { data, bytesSent, bytesReceived, sendErrors, receiveErrors, runningTime } = await this._rpc.rpc.TestServiceWithStreams.closeTestStream({
+      data: streamTag
+    });
+    (0, import_invariant7.invariant)(data === streamTag, void 0, {
+      F: __dxlog_file8,
+      L: 220,
+      S: this,
+      A: [
+        "data === streamTag",
+        ""
+      ]
+    });
+    const local = this._closeStream(streamTag);
+    return {
+      streamTag,
+      stats: {
+        local,
+        remote: {
+          bytesSent,
+          bytesReceived,
+          sendErrors,
+          receiveErrors,
+          runningTime
+        }
+      }
+    };
+  }
+  /**
+  * Force-close the connection.
+  */
+  async closeConnection(err) {
+    this.extensionContext?.close(err);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Framer,
+  Muxer,
+  Teleport,
+  TestBuilder,
+  TestConnection,
+  TestExtension,
+  TestExtensionWithStreams,
+  TestPeer,
+  decodeFrame,
+  encodeFrame
+});
+//# sourceMappingURL=chunk-MWNN2H3G.cjs.map