@dxos/teleport 0.1.53 → 0.1.54-main.270ec56

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

@@ -1,17 +1,18 @@
-import "@dxos/node-std/globals"
+import "@dxos/node-std/globals";
 
 // packages/core/mesh/teleport/src/muxing/framer.ts
-import assert from "@dxos/node-std/assert";
 import { Duplex } from "@dxos/node-std/stream";
+import invariant from "tiny-invariant";
 import * as varint from "varint";
 var Framer = class {
   constructor() {
+    this._responseQueue = [];
     this._stream = new Duplex({
       objectMode: false,
       read: () => {
       },
       write: (chunk, encoding, callback) => {
-        assert(!this._subscribeCb, "Internal Framer bug. Concurrent writes detected.");
+        invariant(!this._subscribeCb, "Internal Framer bug. Concurrent writes detected.");
         if (this._buffer && this._buffer.length > 0) {
           this._buffer = Buffer.concat([
             this._buffer,
@@ -34,11 +35,18 @@ var Framer = class {
     });
     this.port = {
       send: (message) => {
-        this._stream.push(encodeFrame(message));
+        return new Promise((resolve) => {
+          const canContinue = this._stream.push(encodeFrame(message));
+          if (!canContinue) {
+            this._responseQueue.push(resolve);
+          } else {
+            process.nextTick(resolve);
+          }
+        });
       },
       subscribe: (callback) => {
         var _a;
-        assert(!this._messageCb, "Rpc port already has a message listener.");
+        invariant(!this._messageCb, "Rpc port already has a message listener.");
         this._messageCb = callback;
         (_a = this._subscribeCb) == null ? void 0 : _a.call(this);
         return () => {
@@ -46,10 +54,16 @@ var Framer = class {
         };
       }
     };
+    this.stream.on("drain", this._processResponseQueue.bind(this));
   }
   get stream() {
     return this._stream;
   }
+  _processResponseQueue() {
+    const responseQueue = this._responseQueue;
+    this._responseQueue = [];
+    responseQueue.forEach((cb) => cb());
+  }
   /**
   * Attempts to pop frames from the buffer and call the message callback.
   */
@@ -70,6 +84,7 @@ var Framer = class {
     }
   }
   destroy() {
+    this._stream.removeAllListeners("drain");
     this._stream.destroy();
   }
 };
@@ -102,18 +117,96 @@ var encodeFrame = (payload) => {
 };
 
 // packages/core/mesh/teleport/src/muxing/muxer.ts
-import assert2 from "@dxos/node-std/assert";
 import { Duplex as Duplex2 } from "@dxos/node-std/stream";
-import { DeferredTask, Event, sleep } from "@dxos/async";
+import invariant2 from "tiny-invariant";
+import { scheduleTaskInterval, Event, Trigger } from "@dxos/async";
 import { Context } from "@dxos/context";
 import { failUndefined } from "@dxos/debug";
 import { log } from "@dxos/log";
 import { schema } from "@dxos/protocols";
-var codec = schema.getCodecForType("dxos.mesh.muxer.Command");
-var DEBOUNCE_STATS_INTERVAL = 1e3;
+
+// packages/core/mesh/teleport/src/muxing/balancer.ts
+var Balancer = class {
+  constructor(_port, _sysChannelId) {
+    this._port = _port;
+    this._sysChannelId = _sysChannelId;
+    this._lastCallerIndex = 0;
+    this._channels = [];
+    this._calls = /* @__PURE__ */ new Map();
+    this._channels.push(_sysChannelId);
+  }
+  addChannel(channel) {
+    this._channels.push(channel);
+  }
+  pushChunk(msg, trigger, channelId) {
+    const noCalls = this._calls.size === 0;
+    if (!this._channels.includes(channelId)) {
+      throw new Error(`Unknown channel ${channelId}`);
+    }
+    if (!this._calls.has(channelId)) {
+      this._calls.set(channelId, []);
+    }
+    const channelCalls = this._calls.get(channelId);
+    channelCalls.push({
+      msg,
+      trigger
+    });
+    if (noCalls) {
+      process.nextTick(async () => {
+        await this._processCalls();
+      });
+    }
+  }
+  destroy() {
+    this._calls.clear();
+  }
+  _getNextCallerId() {
+    if (this._calls.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) {
+      const channelId = this._getNextCallerId();
+      const channelCalls = this._calls.get(channelId);
+      if (!channelCalls) {
+        continue;
+      }
+      call = channelCalls.shift();
+      if (channelCalls.length === 0) {
+        this._calls.delete(channelId);
+      }
+    }
+    return call;
+  }
+  async _processCalls() {
+    if (this._calls.size === 0) {
+      return;
+    }
+    const call = this._getNextCall();
+    try {
+      await this._port.send(call.msg);
+      call.trigger.wake();
+    } catch (err) {
+      call.trigger.throw(err);
+    }
+    await this._processCalls();
+  }
+};
+
+// 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 Command = schema.getCodecForType("dxos.mesh.muxer.Command");
+var STATS_INTERVAL = 1e3;
+var SYSTEM_CHANNEL_ID = -1;
 var Muxer = class {
   constructor() {
     this._framer = new Framer();
+    this._balancer = new Balancer(this._framer.port, SYSTEM_CHANNEL_ID);
     this.stream = this._framer.stream;
     this._channelsByLocalId = /* @__PURE__ */ new Map();
     this._channelsByTag = /* @__PURE__ */ new Map();
@@ -123,21 +216,10 @@ var Muxer = class {
     this.close = new Event();
     this.statsUpdated = new Event();
     this._ctx = new Context();
-    this._emitStats = new DeferredTask(this._ctx, async () => {
-      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
-      })));
-      await sleep(DEBOUNCE_STATS_INTERVAL);
-    });
-    this._framer.port.subscribe((msg) => {
-      this._handleCommand(codec.decode(msg));
+    this._framer.port.subscribe(async (msg) => {
+      await this._handleCommand(Command.decode(msg));
     });
+    scheduleTaskInterval(this._ctx, async () => this._emitStats(), STATS_INTERVAL);
   }
   /**
   * Creates a duplex Node.js-style stream.
@@ -145,35 +227,38 @@ var Muxer = class {
   * 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).
   */
-  createStream(tag, opts = {}) {
+  async createStream(tag, opts = {}) {
     const channel = this._getOrCreateStream({
       tag,
       contentType: opts.contentType
     });
-    assert2(!channel.push, `Channel already open: ${tag}`);
+    invariant2(!channel.push, `Channel already open: ${tag}`);
     const stream = new Duplex2({
       write: (data, encoding, callback) => {
-        this._sendData(channel, data);
-        callback();
+        this._sendData(channel, data).then(() => callback()).catch(callback);
       },
       read: () => {
       }
     });
     channel.push = (data) => {
       channel.stats.bytesReceived += data.length;
-      this._emitStats.schedule();
       stream.push(data);
     };
     channel.destroy = (err) => {
       stream.destroy(err);
     };
-    this._sendCommand({
-      openChannel: {
-        id: channel.id,
-        tag: channel.tag,
-        contentType: channel.contentType
-      }
-    });
+    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;
   }
   /**
@@ -182,17 +267,16 @@ var Muxer = class {
   * 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).
   */
-  createPort(tag, opts = {}) {
+  async createPort(tag, opts = {}) {
     const channel = this._getOrCreateStream({
       tag,
       contentType: opts.contentType
     });
-    assert2(!channel.push, `Channel already open: ${tag}`);
+    invariant2(!channel.push, `Channel already open: ${tag}`);
     let inboundBuffer = [];
     let callback;
     channel.push = (data) => {
       channel.stats.bytesReceived += data.length;
-      this._emitStats.schedule();
       if (callback) {
         callback(data);
       } else {
@@ -200,11 +284,11 @@ var Muxer = class {
       }
     };
     const port = {
-      send: (data) => {
-        this._sendData(channel, data);
+      send: async (data) => {
+        await this._sendData(channel, data);
       },
       subscribe: (cb) => {
-        assert2(!callback, "Only one subscriber is allowed");
+        invariant2(!callback, "Only one subscriber is allowed");
         callback = cb;
         for (const data of inboundBuffer) {
           cb(data);
@@ -212,13 +296,18 @@ var Muxer = class {
         inboundBuffer = [];
       }
     };
-    this._sendCommand({
-      openChannel: {
-        id: channel.id,
-        tag: channel.tag,
-        contentType: channel.contentType
-      }
-    });
+    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;
   }
   /**
@@ -229,12 +318,16 @@ var Muxer = class {
       return;
     }
     this._destroying = true;
-    this._sendCommand({
+    Promise.resolve(this._sendCommand({
       destroy: {
         error: err == null ? void 0 : err.message
       }
+    }, SYSTEM_CHANNEL_ID)).then(() => {
+      this._dispose();
+    }).catch((err2) => {
+      this._dispose(err2);
     });
-    this._dispose();
+    void this._ctx.dispose();
   }
   _dispose(err) {
     var _a;
@@ -242,6 +335,7 @@ var Muxer = class {
       return;
     }
     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);
@@ -249,24 +343,25 @@ var Muxer = class {
     this.close.emit(err);
     this._channelsByLocalId.clear();
     this._channelsByTag.clear();
-    void this._ctx.dispose();
   }
-  _handleCommand(cmd) {
+  async _handleCommand(cmd) {
     var _a;
     log("Received command", {
       cmd
     }, {
-      file: "muxer.ts",
-      line: 224,
-      scope: this,
-      callSite: (f, a) => f(...a)
+      F: __dxlog_file,
+      L: 239,
+      S: this,
+      C: (f, a) => f(...a)
     });
     if (this._destroyed || this._destroying) {
-      log.warn("Received command after destroy", {}, {
-        file: "muxer.ts",
-        line: 227,
-        scope: this,
-        callSite: (f, a) => f(...a)
+      log.warn("Received command after destroy", {
+        cmd
+      }, {
+        F: __dxlog_file,
+        L: 242,
+        S: this,
+        C: (f, a) => f(...a)
       });
       return;
     }
@@ -277,12 +372,12 @@ var Muxer = class {
       });
       channel.remoteId = cmd.openChannel.id;
       for (const data of channel.buffer) {
-        this._sendCommand({
+        await this._sendCommand({
           data: {
             channelId: channel.remoteId,
             data
           }
-        });
+        }, channel.id);
       }
       channel.buffer = [];
     } else if (cmd.data) {
@@ -291,10 +386,10 @@ var Muxer = class {
         log.warn("Received data for channel before it was opened", {
           tag: stream.tag
         }, {
-          file: "muxer.ts",
-          line: 251,
-          scope: this,
-          callSite: (f, a) => f(...a)
+          F: __dxlog_file,
+          L: 269,
+          S: this,
+          C: (f, a) => f(...a)
         });
         return;
       }
@@ -303,10 +398,14 @@ var Muxer = class {
       this._dispose();
     }
   }
-  _sendCommand(cmd) {
-    Promise.resolve(this._framer.port.send(codec.encode(cmd))).catch((err) => {
+  async _sendCommand(cmd, channelId = -1) {
+    try {
+      const trigger = new Trigger();
+      this._balancer.pushChunk(Command.encode(cmd), trigger, channelId);
+      await trigger.wait();
+    } catch (err) {
       this.destroy(err);
-    });
+    }
   }
   _getOrCreateStream(params) {
     let channel = this._channelsByTag.get(params.tag);
@@ -326,28 +425,46 @@ var Muxer = class {
       };
       this._channelsByTag.set(channel.tag, channel);
       this._channelsByLocalId.set(channel.id, channel);
+      this._balancer.addChannel(channel.id);
     }
     return channel;
   }
-  _sendData(channel, data) {
+  async _sendData(channel, data) {
     channel.stats.bytesSent += data.length;
-    this._emitStats.schedule();
     if (channel.remoteId === null) {
       channel.buffer.push(data);
-    } else {
-      this._sendCommand({
-        data: {
-          channelId: channel.remoteId,
-          data
-        }
-      });
+      return;
+    }
+    await this._sendCommand({
+      data: {
+        channelId: channel.remoteId,
+        data
+      }
+    }, channel.id);
+  }
+  _destroyChannel(channel, err) {
+    if (channel.destroy) {
+      channel.destroy(err);
     }
+    this._channelsByLocalId.delete(channel.id);
+    this._channelsByTag.delete(channel.tag);
+  }
+  async _emitStats() {
+    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
+    })));
   }
 };
 
 // packages/core/mesh/teleport/src/teleport.ts
-import assert3 from "@dxos/node-std/assert";
-import { asyncTimeout, scheduleTaskInterval, runInContextAsync, synchronized, scheduleTask } from "@dxos/async";
+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";
@@ -355,7 +472,7 @@ 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";
-var __decorate = function(decorators, target, key, desc) {
+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);
@@ -364,17 +481,18 @@ var __decorate = function(decorators, target, key, desc) {
       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_file2 = "/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, {
-            file: "teleport.ts",
-            line: 35,
-            scope: this,
-            callSite: (f, a) => f(...a)
+            F: __dxlog_file2,
+            L: 35,
+            S: this,
+            C: (f, a) => f(...a)
           });
         });
       }
@@ -384,21 +502,21 @@ var Teleport = class {
       heartbeatInterval: 1e4,
       heartbeatTimeout: 1e4,
       onTimeout: () => {
-        this.destroy(new Error("Connection timed out")).catch((err) => log2.catch(err, {}, {
-          file: "teleport.ts",
-          line: 46,
-          scope: this,
-          callSite: (f, a) => f(...a)
+        this.destroy(new Error("Connection timed out")).catch((err) => log2.catch(err, void 0, {
+          F: __dxlog_file2,
+          L: 46,
+          S: this,
+          C: (f, a) => f(...a)
         }));
       }
     });
     this._extensions = /* @__PURE__ */ new Map();
     this._remoteExtensions = /* @__PURE__ */ new Set();
     this._open = false;
-    assert3(typeof initiator === "boolean");
-    assert3(PublicKey.isPublicKey(localPeerId));
-    assert3(PublicKey.isPublicKey(remotePeerId));
-    assert3(typeof initiator === "boolean");
+    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;
@@ -406,12 +524,12 @@ var Teleport = class {
       log2("remote extension", {
         name
       }, {
-        file: "teleport.ts",
-        line: 65,
-        scope: this,
-        callSite: (f, a) => f(...a)
+        F: __dxlog_file2,
+        L: 65,
+        S: this,
+        C: (f, a) => f(...a)
       });
-      assert3(!this._remoteExtensions.has(name), "Remote extension already exists");
+      invariant3(!this._remoteExtensions.has(name), "Remote extension already exists");
       this._remoteExtensions.add(name);
       if (this._extensions.has(name)) {
         try {
@@ -455,12 +573,12 @@ var Teleport = class {
     for (const extension of this._extensions.values()) {
       try {
         await extension.onClose(err);
-      } catch (err1) {
-        log2.catch(err1, {}, {
-          file: "teleport.ts",
-          line: 125,
-          scope: this,
-          callSite: (f, a) => f(...a)
+      } catch (err2) {
+        log2.catch(err2, void 0, {
+          F: __dxlog_file2,
+          L: 125,
+          S: this,
+          C: (f, a) => f(...a)
         });
       }
     }
@@ -473,10 +591,10 @@ var Teleport = class {
     log2("addExtension", {
       name
     }, {
-      file: "teleport.ts",
-      line: 137,
-      scope: this,
-      callSite: (f, a) => f(...a)
+      F: __dxlog_file2,
+      L: 137,
+      S: this,
+      C: (f, a) => f(...a)
     });
     this._setExtension(name, extension);
     scheduleTask(this._ctx, async () => {
@@ -496,8 +614,8 @@ var Teleport = class {
     }
   }
   _setExtension(extensionName, extension) {
-    assert3(!extensionName.includes("/"), "Invalid extension name");
-    assert3(!this._extensions.has(extensionName), "Extension already exists");
+    invariant3(!extensionName.includes("/"), "Invalid extension name");
+    invariant3(!this._extensions.has(extensionName), "Extension already exists");
     this._extensions.set(extensionName, extension);
   }
   async _openExtension(extensionName) {
@@ -505,22 +623,22 @@ var Teleport = class {
     log2("open extension", {
       extensionName
     }, {
-      file: "teleport.ts",
-      line: 167,
-      scope: this,
-      callSite: (f, a) => f(...a)
+      F: __dxlog_file2,
+      L: 167,
+      S: this,
+      C: (f, a) => f(...a)
     });
     const extension = (_a = this._extensions.get(extensionName)) != null ? _a : failUndefined2();
     const context = {
       initiator: this.initiator,
       localPeerId: this.localPeerId,
       remotePeerId: this.remotePeerId,
-      createPort: (channelName, opts) => {
-        assert3(!channelName.includes("/"), "Invalid channel name");
+      createPort: async (channelName, opts) => {
+        invariant3(!channelName.includes("/"), "Invalid channel name");
         return this._muxer.createPort(`${extensionName}/${channelName}`, opts);
       },
-      createStream: (channelName, opts) => {
-        assert3(!channelName.includes("/"), "Invalid channel name");
+      createStream: async (channelName, opts) => {
+        invariant3(!channelName.includes("/"), "Invalid channel name");
         return this._muxer.createStream(`${extensionName}/${channelName}`, opts);
       },
       close: (err) => {
@@ -533,14 +651,14 @@ var Teleport = class {
     log2("extension opened", {
       extensionName
     }, {
-      file: "teleport.ts",
-      line: 190,
-      scope: this,
-      callSite: (f, a) => f(...a)
+      F: __dxlog_file2,
+      L: 190,
+      S: this,
+      C: (f, a) => f(...a)
     });
   }
 };
-__decorate([
+_ts_decorate([
   synchronized
 ], Teleport.prototype, "destroy", null);
 var ControlExtension = class {
@@ -571,12 +689,12 @@ var ControlExtension = class {
           }
         }
       },
-      port: extensionContext.createPort("rpc", {
+      port: await extensionContext.createPort("rpc", {
         contentType: 'application/x-protobuf; messagType="dxos.rpc.Message"'
       })
     });
     await this._rpc.open();
-    scheduleTaskInterval(this._ctx, async () => {
+    scheduleTaskInterval2(this._ctx, async () => {
       try {
         await asyncTimeout(this._rpc.rpc.Control.heartbeat(), this.opts.heartbeatTimeout);
       } catch (err) {
@@ -596,16 +714,17 @@ var ControlExtension = class {
 };
 
 // packages/core/mesh/teleport/src/testing/test-extension.ts
-import assert4 from "@dxos/node-std/assert";
-import { asyncTimeout as asyncTimeout2, Trigger } from "@dxos/async";
+import invariant4 from "tiny-invariant";
+import { asyncTimeout as asyncTimeout2, Trigger as Trigger2 } from "@dxos/async";
 import { log as log3 } 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 TestExtension = class {
   constructor(callbacks = {}) {
     this.callbacks = callbacks;
-    this.open = new Trigger();
-    this.closed = new Trigger();
+    this.open = new Trigger2();
+    this.closed = new Trigger2();
   }
   get remotePeerId() {
     var _a;
@@ -617,14 +736,14 @@ var TestExtension = class {
       localPeerId: context.localPeerId,
       remotePeerId: context.remotePeerId
     }, {
-      file: "test-extension.ts",
-      line: 33,
-      scope: this,
-      callSite: (f, a) => f(...a)
+      F: __dxlog_file3,
+      L: 33,
+      S: this,
+      C: (f, a) => f(...a)
     });
     this.extensionContext = context;
     this._rpc = createProtoRpcPeer2({
-      port: context.createPort("rpc", {
+      port: await context.createPort("rpc", {
         contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
       }),
       requested: {
@@ -644,7 +763,7 @@ var TestExtension = class {
           }
         }
       },
-      timeout: 1e3
+      timeout: 2e3
     });
     await this._rpc.open();
     await ((_b = (_a = this.callbacks).onOpen) == null ? void 0 : _b.call(_a));
@@ -655,10 +774,10 @@ var TestExtension = class {
     log3("onClose", {
       err
     }, {
-      file: "test-extension.ts",
-      line: 67,
-      scope: this,
-      callSite: (f, a) => f(...a)
+      F: __dxlog_file3,
+      L: 67,
+      S: this,
+      C: (f, a) => f(...a)
     });
     await ((_b = (_a = this.callbacks).onClose) == null ? void 0 : _b.call(_a));
     this.closed.wake();
@@ -666,12 +785,12 @@ var TestExtension = class {
   }
   async test(message = "test") {
     await this.open.wait({
-      timeout: 500
+      timeout: 1500
     });
     const res = await asyncTimeout2(this._rpc.rpc.TestService.testCall({
       data: message
-    }), 500);
-    assert4(res.data === message);
+    }), 1500);
+    invariant4(res.data === message);
   }
   /**
   * Force-close the connection.
@@ -690,4 +809,4 @@ export {
   Teleport,
   TestExtension
 };
-//# sourceMappingURL=chunk-XWWASTDK.mjs.map
+//# sourceMappingURL=chunk-7TGKNWZQ.mjs.map