@dxos/teleport 0.1.55-main.ff36828 → 0.1.55

package/dist/lib/browser/{chunk-HCC6HY7F.mjs → chunk-WUEX3RV3.mjs}

@@ -4,7 +4,7 @@ import "@dxos/node-std/globals";
 import { pipeline } from "@dxos/node-std/stream";
 import invariant4 from "tiny-invariant";
 import { PublicKey as PublicKey2 } from "@dxos/keys";
-import { log as log3 } from "@dxos/log";
+import { log as log4 } from "@dxos/log";
 
 // packages/core/mesh/teleport/src/teleport.ts
 import invariant3 from "tiny-invariant";
@@ -12,7 +12,7 @@ import { asyncTimeout, scheduleTaskInterval as scheduleTaskInterval2, runInConte
 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 { log as log3 } from "@dxos/log";
 import { schema as schema2, RpcClosedError } from "@dxos/protocols";
 import { createProtoRpcPeer } from "@dxos/rpc";
 import { Callback } from "@dxos/util";
@@ -20,16 +20,20 @@ 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,
@@ -53,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();
           }
         });
       },
@@ -71,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());
   }
   /**
@@ -101,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 = "/mnt/ramdisk/work/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 = "/mnt/ramdisk/work/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);
@@ -353,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);
     }
@@ -363,20 +448,20 @@ var Muxer = class {
   }
   async _handleCommand(cmd) {
     var _a;
-    log("Received command", {
+    log2("Received command", {
       cmd
     }, {
-      F: __dxlog_file,
-      L: 237,
+      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: 240,
+        F: __dxlog_file2,
+        L: 243,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -400,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: 267,
+          F: __dxlog_file2,
+          L: 270,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -418,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);
@@ -447,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);
@@ -470,12 +566,19 @@ 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
+    });
   }
 };
 
@@ -490,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 = "/mnt/ramdisk/work/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)
           });
@@ -510,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)
         }));
@@ -528,11 +631,11 @@ var Teleport = class {
     this.localPeerId = localPeerId;
     this.remotePeerId = remotePeerId;
     this._control.onExtensionRegistered.set(async (name) => {
-      log2("remote extension", {
+      log3("remote extension", {
         name
       }, {
-        F: __dxlog_file2,
-        L: 64,
+        F: __dxlog_file3,
+        L: 63,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -554,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;
@@ -581,9 +698,9 @@ var Teleport = class {
       try {
         await extension.onClose(err);
       } catch (err2) {
-        log2.catch(err2, void 0, {
-          F: __dxlog_file2,
-          L: 124,
+        log3.catch(err2, void 0, {
+          F: __dxlog_file3,
+          L: 132,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -595,11 +712,11 @@ var Teleport = class {
     if (!this._open) {
       throw new Error("Not open");
     }
-    log2("addExtension", {
+    log3("addExtension", {
       name
     }, {
-      F: __dxlog_file2,
-      L: 136,
+      F: __dxlog_file3,
+      L: 144,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -627,11 +744,11 @@ var Teleport = class {
   }
   async _openExtension(extensionName) {
     var _a;
-    log2("open extension", {
+    log3("open extension", {
       extensionName
     }, {
-      F: __dxlog_file2,
-      L: 166,
+      F: __dxlog_file3,
+      L: 174,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -655,11 +772,11 @@ var Teleport = class {
       }
     };
     await extension.onOpen(context);
-    log2("extension opened", {
+    log3("extension opened", {
       extensionName
     }, {
-      F: __dxlog_file2,
-      L: 189,
+      F: __dxlog_file3,
+      L: 197,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -678,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({
@@ -713,15 +835,10 @@ 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_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-builder.ts";
+var __dxlog_file4 = "/mnt/ramdisk/work/packages/core/mesh/teleport/src/testing/test-builder.ts";
 var TestBuilder = class {
   constructor() {
     this._peers = /* @__PURE__ */ new Set();
@@ -809,8 +926,8 @@ var TestPeer = class {
 var pipeStreams = (stream1, stream2) => {
   pipeline(stream1, stream2, (err) => {
     if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
-      log3.catch(err, void 0, {
-        F: __dxlog_file3,
+      log4.catch(err, void 0, {
+        F: __dxlog_file4,
         L: 106,
         S: void 0,
         C: (f, a) => f(...a)
@@ -819,8 +936,8 @@ var pipeStreams = (stream1, stream2) => {
   });
   pipeline(stream2, stream1, (err) => {
     if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
-      log3.catch(err, void 0, {
-        F: __dxlog_file3,
+      log4.catch(err, void 0, {
+        F: __dxlog_file4,
         L: 111,
         S: void 0,
         C: (f, a) => f(...a)
@@ -844,10 +961,10 @@ var TestConnection = class {
 // packages/core/mesh/teleport/src/testing/test-extension.ts
 import invariant5 from "tiny-invariant";
 import { asyncTimeout as asyncTimeout2, Trigger as Trigger2 } from "@dxos/async";
-import { log as log4 } 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_file4 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-extension.ts";
+var __dxlog_file5 = "/mnt/ramdisk/work/packages/core/mesh/teleport/src/testing/test-extension.ts";
 var TestExtension = class {
   constructor(callbacks = {}) {
     this.callbacks = callbacks;
@@ -860,11 +977,11 @@ var TestExtension = class {
   }
   async onOpen(context) {
     var _a, _b;
-    log4("onOpen", {
+    log5("onOpen", {
       localPeerId: context.localPeerId,
       remotePeerId: context.remotePeerId
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 33,
       S: this,
       C: (f, a) => f(...a)
@@ -899,10 +1016,10 @@ var TestExtension = class {
   }
   async onClose(err) {
     var _a, _b, _c;
-    log4("onClose", {
+    log5("onClose", {
       err
     }, {
-      F: __dxlog_file4,
+      F: __dxlog_file5,
       L: 67,
       S: this,
       C: (f, a) => f(...a)
@@ -933,10 +1050,10 @@ var TestExtension = class {
 import assert from "@dxos/node-std/assert";
 import { randomBytes } from "@dxos/node-std/crypto";
 import { Trigger as Trigger3 } from "@dxos/async";
-import { log as log5 } from "@dxos/log";
+import { log as log6 } from "@dxos/log";
 import { schema as schema4 } from "@dxos/protocols";
 import { createProtoRpcPeer as createProtoRpcPeer3 } from "@dxos/rpc";
-var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/mesh/teleport/src/testing/test-extension-with-streams.ts";
+var __dxlog_file6 = "/mnt/ramdisk/work/packages/core/mesh/teleport/src/testing/test-extension-with-streams.ts";
 var TestExtensionWithStreams = class {
   constructor(callbacks = {}) {
     this.callbacks = callbacks;
@@ -988,11 +1105,30 @@ var TestExtensionWithStreams = class {
     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);
@@ -1006,12 +1142,12 @@ var TestExtensionWithStreams = class {
   }
   async onOpen(context) {
     var _a, _b;
-    log5("onOpen", {
+    log6("onOpen", {
       localPeerId: context.localPeerId,
       remotePeerId: context.remotePeerId
     }, {
-      F: __dxlog_file5,
-      L: 111,
+      F: __dxlog_file6,
+      L: 126,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -1057,22 +1193,22 @@ var TestExtensionWithStreams = class {
   }
   async onClose(err) {
     var _a, _b, _c;
-    log5("onClose", {
+    log6("onClose", {
       err
     }, {
-      F: __dxlog_file5,
-      L: 162,
+      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)) {
-      log5("closing stream", {
+      log6("closing stream", {
         streamTag
       }, {
-        F: __dxlog_file5,
-        L: 166,
+        F: __dxlog_file6,
+        L: 181,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -1141,4 +1277,4 @@ export {
   TestExtension,
   TestExtensionWithStreams
 };
-//# sourceMappingURL=chunk-HCC6HY7F.mjs.map
+//# sourceMappingURL=chunk-WUEX3RV3.mjs.map