@dxos/teleport 0.1.54 → 0.1.55-main.0618d91

package/dist/lib/browser/{chunk-7TGKNWZQ.mjs → chunk-GGVQ27WJ.mjs}

@@ -1,18 +1,39 @@
 import "@dxos/node-std/globals";
 
+// packages/core/mesh/teleport/src/testing/test-builder.ts
+import { pipeline } from "@dxos/node-std/stream";
+import invariant4 from "tiny-invariant";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log4 } from "@dxos/log";
+
+// packages/core/mesh/teleport/src/teleport.ts
+import invariant3 from "tiny-invariant";
+import { asyncTimeout, scheduleTaskInterval as scheduleTaskInterval2, runInContextAsync, synchronized, scheduleTask } from "@dxos/async";
+import { Context as Context2 } from "@dxos/context";
+import { failUndefined as failUndefined2 } from "@dxos/debug";
+import { PublicKey } from "@dxos/keys";
+import { log as log3 } from "@dxos/log";
+import { schema as schema2, RpcClosedError } from "@dxos/protocols";
+import { createProtoRpcPeer } from "@dxos/rpc";
+import { Callback } from "@dxos/util";
+
 // packages/core/mesh/teleport/src/muxing/framer.ts
 import { Duplex } from "@dxos/node-std/stream";
 import invariant from "tiny-invariant";
-import * as varint from "varint";
+var FRAME_LENGTH_SIZE = 2;
 var Framer = class {
   constructor() {
-    this._responseQueue = [];
+    this._sendCallbacks = [];
+    this._bytesSent = 0;
+    this._bytesReceived = 0;
     this._stream = new Duplex({
       objectMode: false,
       read: () => {
+        this._processResponseQueue();
       },
       write: (chunk, encoding, callback) => {
         invariant(!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,
@@ -36,11 +57,13 @@ var Framer = class {
     this.port = {
       send: (message) => {
         return new Promise((resolve) => {
-          const canContinue = this._stream.push(encodeFrame(message));
+          const frame = encodeFrame(message);
+          this._bytesSent += frame.length;
+          const canContinue = this._stream.push(frame);
           if (!canContinue) {
-            this._responseQueue.push(resolve);
+            this._sendCallbacks.push(resolve);
           } else {
-            process.nextTick(resolve);
+            resolve();
           }
         });
       },
@@ -54,14 +77,19 @@ var Framer = class {
         };
       }
     };
-    this.stream.on("drain", this._processResponseQueue.bind(this));
   }
   get stream() {
     return this._stream;
   }
+  get bytesSent() {
+    return this._bytesSent;
+  }
+  get bytesReceived() {
+    return this._bytesReceived;
+  }
   _processResponseQueue() {
-    const responseQueue = this._responseQueue;
-    this._responseQueue = [];
+    const responseQueue = this._sendCallbacks;
+    this._sendCallbacks = [];
     responseQueue.forEach((cb) => cb());
   }
   /**
@@ -84,139 +112,214 @@ var Framer = class {
     }
   }
   destroy() {
-    this._stream.removeAllListeners("drain");
     this._stream.destroy();
   }
 };
 var decodeFrame = (buffer, offset) => {
-  try {
-    const frameLength = varint.decode(buffer, offset);
-    const tagLength = varint.decode.bytes;
-    if (buffer.length < offset + tagLength + frameLength) {
-      return void 0;
-    }
-    const payload = buffer.subarray(offset + tagLength, offset + tagLength + frameLength);
-    return {
-      payload,
-      bytesConsumed: tagLength + frameLength
-    };
-  } catch (err) {
-    if (err instanceof RangeError) {
-      return void 0;
-    } else {
-      throw err;
-    }
+  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 tagLength = varint.encodingLength(payload.length);
-  const frame = Buffer.allocUnsafe(tagLength + payload.length);
-  varint.encode(payload.length, frame);
-  frame.set(payload, tagLength);
+  const frame = Buffer.allocUnsafe(FRAME_LENGTH_SIZE + payload.length);
+  frame.writeUInt16BE(payload.length, 0);
+  frame.set(payload, FRAME_LENGTH_SIZE);
   return frame;
 };
 
 // packages/core/mesh/teleport/src/muxing/muxer.ts
 import { Duplex as Duplex2 } from "@dxos/node-std/stream";
 import invariant2 from "tiny-invariant";
-import { scheduleTaskInterval, Event, Trigger } from "@dxos/async";
+import { scheduleTaskInterval, Event as Event2, Trigger } from "@dxos/async";
 import { Context } from "@dxos/context";
 import { failUndefined } from "@dxos/debug";
-import { log } from "@dxos/log";
+import { log as log2 } from "@dxos/log";
 import { schema } from "@dxos/protocols";
 
 // packages/core/mesh/teleport/src/muxing/balancer.ts
+import * as varint from "varint";
+import { Event } from "@dxos/async";
+import { log } from "@dxos/log";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/balancer.ts";
+var MAX_CHUNK_SIZE = 8192;
 var Balancer = class {
-  constructor(_port, _sysChannelId) {
-    this._port = _port;
+  constructor(_sysChannelId) {
     this._sysChannelId = _sysChannelId;
     this._lastCallerIndex = 0;
     this._channels = [];
-    this._calls = /* @__PURE__ */ new Map();
+    this._framer = new Framer();
+    this._sendBuffers = /* @__PURE__ */ new Map();
+    this._receiveBuffers = /* @__PURE__ */ new Map();
+    this.incomingData = new 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;
   }
   addChannel(channel) {
     this._channels.push(channel);
   }
-  pushChunk(msg, trigger, channelId) {
-    const noCalls = this._calls.size === 0;
+  pushData(data, trigger, channelId) {
+    const noCalls = this._sendBuffers.size === 0;
     if (!this._channels.includes(channelId)) {
       throw new Error(`Unknown channel ${channelId}`);
     }
-    if (!this._calls.has(channelId)) {
-      this._calls.set(channelId, []);
+    if (!this._sendBuffers.has(channelId)) {
+      this._sendBuffers.set(channelId, []);
     }
-    const channelCalls = this._calls.get(channelId);
-    channelCalls.push({
-      msg,
-      trigger
+    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
+      });
     });
     if (noCalls) {
-      process.nextTick(async () => {
-        await this._processCalls();
-      });
+      this._sendChunks().catch((err) => log.catch(err, void 0, {
+        F: __dxlog_file,
+        L: 96,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
     }
   }
   destroy() {
-    this._calls.clear();
+    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._calls.has(this._sysChannelId)) {
+    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];
   }
-  _getNextCall() {
-    let call;
-    while (!call) {
+  _getNextChunk() {
+    let chunk;
+    while (!chunk) {
       const channelId = this._getNextCallerId();
-      const channelCalls = this._calls.get(channelId);
-      if (!channelCalls) {
+      const sendBuffer = this._sendBuffers.get(channelId);
+      if (!sendBuffer) {
         continue;
       }
-      call = channelCalls.shift();
-      if (channelCalls.length === 0) {
-        this._calls.delete(channelId);
+      chunk = sendBuffer.shift();
+      if (sendBuffer.length === 0) {
+        this._sendBuffers.delete(channelId);
       }
     }
-    return call;
+    return chunk;
   }
-  async _processCalls() {
-    if (this._calls.size === 0) {
+  async _sendChunks() {
+    var _a, _b;
+    if (this._sendBuffers.size === 0) {
       return;
     }
-    const call = this._getNextCall();
+    const chunk = this._getNextChunk();
     try {
-      await this._port.send(call.msg);
-      call.trigger.wake();
+      await this._framer.port.send(chunk.msg);
+      (_a = chunk.trigger) == null ? void 0 : _a.wake();
     } catch (err) {
-      call.trigger.throw(err);
+      (_b = chunk.trigger) == null ? void 0 : _b.throw(err);
     }
-    await this._processCalls();
+    await this._sendChunks();
+  }
+};
+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
+  };
 };
 
 // packages/core/mesh/teleport/src/muxing/muxer.ts
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/muxer.ts";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/muxing/muxer.ts";
 var Command = schema.getCodecForType("dxos.mesh.muxer.Command");
 var STATS_INTERVAL = 1e3;
-var SYSTEM_CHANNEL_ID = -1;
+var MAX_SAFE_FRAME_SIZE = 1e6;
+var SYSTEM_CHANNEL_ID = 0;
 var Muxer = class {
   constructor() {
-    this._framer = new Framer();
-    this._balancer = new Balancer(this._framer.port, SYSTEM_CHANNEL_ID);
-    this.stream = this._framer.stream;
+    this._balancer = new Balancer(SYSTEM_CHANNEL_ID);
     this._channelsByLocalId = /* @__PURE__ */ new Map();
     this._channelsByTag = /* @__PURE__ */ new Map();
-    this._nextId = 0;
+    this._ctx = new Context();
+    this._nextId = 1;
     this._destroyed = false;
     this._destroying = false;
-    this.close = new Event();
-    this.statsUpdated = new Event();
-    this._ctx = new Context();
-    this._framer.port.subscribe(async (msg) => {
+    this.close = new Event2();
+    this.statsUpdated = new Event2();
+    this.stream = this._balancer.stream;
+    this._balancer.incomingData.on(async (msg) => {
       await this._handleCommand(Command.decode(msg));
     });
     scheduleTaskInterval(this._ctx, async () => this._emitStats(), STATS_INTERVAL);
@@ -318,11 +421,11 @@ var Muxer = class {
       return;
     }
     this._destroying = true;
-    Promise.resolve(this._sendCommand({
+    this._sendCommand({
       destroy: {
         error: err == null ? void 0 : err.message
       }
-    }, SYSTEM_CHANNEL_ID)).then(() => {
+    }, SYSTEM_CHANNEL_ID).then(() => {
       this._dispose();
     }).catch((err2) => {
       this._dispose(err2);
@@ -336,7 +439,6 @@ var Muxer = class {
     }
     this._destroyed = true;
     this._balancer.destroy();
-    this._framer.destroy();
     for (const channel of this._channelsByTag.values()) {
       (_a = channel.destroy) == null ? void 0 : _a.call(channel, err);
     }
@@ -346,20 +448,20 @@ var Muxer = class {
   }
   async _handleCommand(cmd) {
     var _a;
-    log("Received command", {
+    log2("Received command", {
       cmd
     }, {
-      F: __dxlog_file,
-      L: 239,
+      F: __dxlog_file2,
+      L: 240,
       S: this,
       C: (f, a) => f(...a)
     });
     if (this._destroyed || this._destroying) {
-      log.warn("Received command after destroy", {
+      log2.warn("Received command after destroy", {
         cmd
       }, {
-        F: __dxlog_file,
-        L: 242,
+        F: __dxlog_file2,
+        L: 243,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -383,11 +485,11 @@ var Muxer = class {
     } else if (cmd.data) {
       const stream = (_a = this._channelsByLocalId.get(cmd.data.channelId)) != null ? _a : failUndefined();
       if (!stream.push) {
-        log.warn("Received data for channel before it was opened", {
+        log2.warn("Received data for channel before it was opened", {
           tag: stream.tag
         }, {
-          F: __dxlog_file,
-          L: 269,
+          F: __dxlog_file2,
+          L: 270,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -401,7 +503,7 @@ var Muxer = class {
   async _sendCommand(cmd, channelId = -1) {
     try {
       const trigger = new Trigger();
-      this._balancer.pushChunk(Command.encode(cmd), trigger, channelId);
+      this._balancer.pushData(Command.encode(cmd), trigger, channelId);
       await trigger.wait();
     } catch (err) {
       this.destroy(err);
@@ -430,6 +532,17 @@ var Muxer = class {
     return channel;
   }
   async _sendData(channel, data) {
+    if (data.length > MAX_SAFE_FRAME_SIZE) {
+      log2.warn("frame size exceeds maximum safe value", {
+        size: data.length,
+        threshold: MAX_SAFE_FRAME_SIZE
+      }, {
+        F: __dxlog_file2,
+        L: 314,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
     channel.stats.bytesSent += data.length;
     if (channel.remoteId === null) {
       channel.buffer.push(data);
@@ -453,25 +566,23 @@ var Muxer = class {
     if (this._destroyed || this._destroying) {
       return;
     }
-    this.statsUpdated.emit(Array.from(this._channelsByTag.values()).map((channel) => ({
-      id: channel.id,
-      tag: channel.tag,
-      bytesSent: channel.stats.bytesSent,
-      bytesReceived: channel.stats.bytesReceived
-    })));
+    const bytesSent = this._balancer.bytesSent;
+    const bytesReceived = this._balancer.bytesReceived;
+    this.statsUpdated.emit({
+      channels: Array.from(this._channelsByTag.values()).map((channel) => ({
+        id: channel.id,
+        tag: channel.tag,
+        contentType: channel.contentType,
+        bytesSent: channel.stats.bytesSent,
+        bytesReceived: channel.stats.bytesReceived
+      })),
+      bytesSent,
+      bytesReceived
+    });
   }
 };
 
 // packages/core/mesh/teleport/src/teleport.ts
-import invariant3 from "tiny-invariant";
-import { asyncTimeout, scheduleTaskInterval as scheduleTaskInterval2, runInContextAsync, synchronized, scheduleTask } from "@dxos/async";
-import { Context as Context2 } from "@dxos/context";
-import { failUndefined as failUndefined2 } from "@dxos/debug";
-import { PublicKey } from "@dxos/keys";
-import { log as log2 } from "@dxos/log";
-import { schema as schema2, RpcClosedError } from "@dxos/protocols";
-import { createProtoRpcPeer } from "@dxos/rpc";
-import { Callback } from "@dxos/util";
 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")
@@ -482,15 +593,15 @@ function _ts_decorate(decorators, target, key, desc) {
         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_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/teleport.ts";
 var Teleport = class {
   constructor({ initiator, localPeerId, remotePeerId }) {
     this._ctx = new Context2({
       onError: (err) => {
         void this.destroy(err).catch(() => {
-          log2.error("Error during destroy", err, {
-            F: __dxlog_file2,
-            L: 35,
+          log3.error("Error during destroy", err, {
+            F: __dxlog_file3,
+            L: 34,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -502,9 +613,9 @@ var Teleport = class {
       heartbeatInterval: 1e4,
       heartbeatTimeout: 1e4,
       onTimeout: () => {
-        this.destroy(new Error("Connection timed out")).catch((err) => log2.catch(err, void 0, {
-          F: __dxlog_file2,
-          L: 46,
+        this.destroy(new Error("Connection timed out")).catch((err) => log3.catch(err, void 0, {
+          F: __dxlog_file3,
+          L: 45,
           S: this,
           C: (f, a) => f(...a)
         }));
@@ -516,16 +627,15 @@ var Teleport = class {
     invariant3(typeof initiator === "boolean");
     invariant3(PublicKey.isPublicKey(localPeerId));
     invariant3(PublicKey.isPublicKey(remotePeerId));
-    invariant3(typeof initiator === "boolean");
     this.initiator = initiator;
     this.localPeerId = localPeerId;
     this.remotePeerId = remotePeerId;
     this._control.onExtensionRegistered.set(async (name) => {
-      log2("remote extension", {
+      log3("remote extension", {
         name
       }, {
-        F: __dxlog_file2,
-        L: 65,
+        F: __dxlog_file3,
+        L: 63,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -547,6 +657,20 @@ var Teleport = class {
         await this.destroy(err);
       });
     }
+    this._muxer.statsUpdated.on((stats) => {
+      log3.trace("dxos.mesh.teleport.stats", {
+        localPeerId,
+        remotePeerId,
+        bytesSent: stats.bytesSent,
+        bytesReceived: stats.bytesReceived,
+        channels: stats.channels
+      }, {
+        F: __dxlog_file3,
+        L: 88,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
   }
   get stream() {
     return this._muxer.stream;
@@ -574,9 +698,9 @@ var Teleport = class {
       try {
         await extension.onClose(err);
       } catch (err2) {
-        log2.catch(err2, void 0, {
-          F: __dxlog_file2,
-          L: 125,
+        log3.catch(err2, void 0, {
+          F: __dxlog_file3,
+          L: 132,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -588,11 +712,11 @@ var Teleport = class {
     if (!this._open) {
       throw new Error("Not open");
     }
-    log2("addExtension", {
+    log3("addExtension", {
       name
     }, {
-      F: __dxlog_file2,
-      L: 137,
+      F: __dxlog_file3,
+      L: 144,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -620,11 +744,11 @@ var Teleport = class {
   }
   async _openExtension(extensionName) {
     var _a;
-    log2("open extension", {
+    log3("open extension", {
       extensionName
     }, {
-      F: __dxlog_file2,
-      L: 167,
+      F: __dxlog_file3,
+      L: 174,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -648,11 +772,11 @@ var Teleport = class {
       }
     };
     await extension.onOpen(context);
-    log2("extension opened", {
+    log3("extension opened", {
       extensionName
     }, {
-      F: __dxlog_file2,
-      L: 190,
+      F: __dxlog_file3,
+      L: 197,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -671,6 +795,11 @@ var ControlExtension = class {
     });
     this.onExtensionRegistered = new Callback();
   }
+  async registerExtension(name) {
+    await this._rpc.rpc.Control.registerExtension({
+      name
+    });
+  }
   async onOpen(extensionContext) {
     this._extensionContext = extensionContext;
     this._rpc = createProtoRpcPeer({
@@ -706,20 +835,136 @@ var ControlExtension = class {
     await this._ctx.dispose();
     await this._rpc.close();
   }
-  async registerExtension(name) {
-    await this._rpc.rpc.Control.registerExtension({
-      name
+};
+
+// packages/core/mesh/teleport/src/testing/test-builder.ts
+var __dxlog_file4 = "/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) {
+    invariant4(peer1 !== peer2);
+    invariant4(this._peers.has(peer1));
+    invariant4(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) {
+    invariant4(peer1 !== peer2);
+    invariant4(this._peers.has(peer1));
+    invariant4(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));
+    invariant4(connection1);
+    invariant4(connection2);
+    await Promise.all([
+      peer1.closeConnection(connection1),
+      peer2.closeConnection(connection2)
+    ]);
+  }
+};
+var TestPeer = class {
+  constructor(peerId = PublicKey2.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) {
+    invariant4(this.connections.has(connection));
+    await connection.teleport.open();
+    await this.onOpen(connection);
+  }
+  async closeConnection(connection) {
+    invariant4(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) => {
+  pipeline(stream1, stream2, (err) => {
+    if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+      log4.catch(err, void 0, {
+        F: __dxlog_file4,
+        L: 106,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  });
+  pipeline(stream2, stream1, (err) => {
+    if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+      log4.catch(err, void 0, {
+        F: __dxlog_file4,
+        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
     });
   }
 };
 
 // packages/core/mesh/teleport/src/testing/test-extension.ts
-import invariant4 from "tiny-invariant";
+import invariant5 from "tiny-invariant";
 import { asyncTimeout as asyncTimeout2, Trigger as Trigger2 } from "@dxos/async";
-import { log as log3 } from "@dxos/log";
+import { log as log5 } from "@dxos/log";
 import { schema as schema3 } from "@dxos/protocols";
 import { createProtoRpcPeer as createProtoRpcPeer2 } from "@dxos/rpc";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-extension.ts";
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-extension.ts";
 var TestExtension = class {
   constructor(callbacks = {}) {
     this.callbacks = callbacks;
@@ -732,11 +977,11 @@ var TestExtension = class {
   }
   async onOpen(context) {
     var _a, _b;
-    log3("onOpen", {
+    log5("onOpen", {
       localPeerId: context.localPeerId,
       remotePeerId: context.remotePeerId
     }, {
-      F: __dxlog_file3,
+      F: __dxlog_file5,
       L: 33,
       S: this,
       C: (f, a) => f(...a)
@@ -771,10 +1016,10 @@ var TestExtension = class {
   }
   async onClose(err) {
     var _a, _b, _c;
-    log3("onClose", {
+    log5("onClose", {
       err
     }, {
-      F: __dxlog_file3,
+      F: __dxlog_file5,
       L: 67,
       S: this,
       C: (f, a) => f(...a)
@@ -790,7 +1035,226 @@ var TestExtension = class {
     const res = await asyncTimeout2(this._rpc.rpc.TestService.testCall({
       data: message
     }), 1500);
-    invariant4(res.data === message);
+    invariant5(res.data === message);
+  }
+  /**
+  * Force-close the connection.
+  */
+  async closeConnection(err) {
+    var _a;
+    (_a = this.extensionContext) == null ? void 0 : _a.close(err);
+  }
+};
+
+// packages/core/mesh/teleport/src/testing/test-extension-with-streams.ts
+import assert from "@dxos/node-std/assert";
+import { randomBytes } from "@dxos/node-std/crypto";
+import { Trigger as Trigger3 } from "@dxos/async";
+import { log as log6 } from "@dxos/log";
+import { schema as schema4 } from "@dxos/protocols";
+import { createProtoRpcPeer as createProtoRpcPeer3 } from "@dxos/rpc";
+var __dxlog_file6 = "/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 Trigger3();
+    this.closed = new Trigger3();
+    this._streams = /* @__PURE__ */ new Map();
+  }
+  get remotePeerId() {
+    var _a;
+    return (_a = this.extensionContext) == null ? void 0 : _a.remotePeerId;
+  }
+  async _openStream(streamTag, interval = 5, chunkSize = 2048) {
+    assert(!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 = 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(() => {
+      var _a, _b;
+      const { bytesSent, bytesReceived, sendErrors, receiveErrors } = streamEntry;
+      log6.trace("dxos.test.stream-stats", {
+        streamTag,
+        bytesSent,
+        bytesReceived,
+        sendErrors,
+        receiveErrors,
+        from: (_a = this.extensionContext) == null ? void 0 : _a.localPeerId,
+        to: (_b = this.extensionContext) == null ? void 0 : _b.remotePeerId
+      }, {
+        F: __dxlog_file6,
+        L: 91,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }, 100);
+  }
+  _closeStream(streamTag) {
+    assert(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 != null ? startTimestamp : 0)
+    };
+  }
+  async onOpen(context) {
+    var _a, _b;
+    log6("onOpen", {
+      localPeerId: context.localPeerId,
+      remotePeerId: context.remotePeerId
+    }, {
+      F: __dxlog_file6,
+      L: 126,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.extensionContext = context;
+    this._rpc = createProtoRpcPeer3({
+      port: await context.createPort("rpc", {
+        contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
+      }),
+      requested: {
+        TestServiceWithStreams: schema4.getService("example.testing.rpc.TestServiceWithStreams")
+      },
+      exposed: {
+        TestServiceWithStreams: schema4.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 ((_b = (_a = this.callbacks).onOpen) == null ? void 0 : _b.call(_a));
+    this.open.wake();
+  }
+  async onClose(err) {
+    var _a, _b, _c;
+    log6("onClose", {
+      err
+    }, {
+      F: __dxlog_file6,
+      L: 177,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await ((_b = (_a = this.callbacks).onClose) == null ? void 0 : _b.call(_a));
+    this.closed.wake();
+    for (const [streamTag, stream] of Object.entries(this._streams)) {
+      log6("closing stream", {
+        streamTag
+      }, {
+        F: __dxlog_file6,
+        L: 181,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      clearTimeout(stream.interval);
+      stream.networkStream.destroy();
+    }
+    await ((_c = this._rpc) == null ? void 0 : _c.close());
+  }
+  async addNewStream(streamLoadInterval, streamLoadChunkSize, streamTag) {
+    await this.open.wait({
+      timeout: 1500
+    });
+    if (!streamTag) {
+      streamTag = `stream-${randomBytes(4).toString("hex")}`;
+    }
+    const { data } = await this._rpc.rpc.TestServiceWithStreams.requestTestStream({
+      data: streamTag,
+      streamLoadInterval,
+      streamLoadChunkSize
+    });
+    assert(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
+    });
+    assert(data === streamTag);
+    const local = this._closeStream(streamTag);
+    return {
+      streamTag,
+      stats: {
+        local,
+        remote: {
+          bytesSent,
+          bytesReceived,
+          sendErrors,
+          receiveErrors,
+          runningTime
+        }
+      }
+    };
   }
   /**
   * Force-close the connection.
@@ -807,6 +1271,10 @@ export {
   encodeFrame,
   Muxer,
   Teleport,
-  TestExtension
+  TestBuilder,
+  TestPeer,
+  TestConnection,
+  TestExtension,
+  TestExtensionWithStreams
 };
-//# sourceMappingURL=chunk-7TGKNWZQ.mjs.map
+//# sourceMappingURL=chunk-GGVQ27WJ.mjs.map