@vastblast/capnweb 0.7.1 → 0.7.3

package/dist/index.js

@@ -2042,9 +2042,6 @@ var RpcSessionImpl = class {
     this.options = options;
     this.exports.push({ hook: mainHook, refcount: 1 });
     this.imports.push(new ImportTableEntry(this, 0, false));
-    this.cancelReadLoop = (error) => {
-      this.activeReadAbort?.reject(error);
-    };
     this.readLoop().catch((err) => this.abort(err));
   }
   exports = [];
@@ -2052,7 +2049,6 @@ var RpcSessionImpl = class {
   imports = [];
   abortReason;
   cancelReadLoop;
-  activeReadAbort;
   // We assign positive numbers to imports we initiate, and negative numbers to exports we
   // initiate. So the next import ID is just `imports.length`, but the next export ID needs
   // to be tracked explicitly.
@@ -2330,7 +2326,8 @@ var RpcSessionImpl = class {
   }
   abort(error, trySendAbortMessage = true) {
     if (this.abortReason !== void 0) return;
-    this.cancelReadLoop(error);
+    this.cancelReadLoop?.(error);
+    this.cancelReadLoop = void 0;
     if (trySendAbortMessage) {
       try {
         this.transport.send(JSON.stringify(["abort", Devaluator.devaluate(error, void 0, this)])).catch((err) => {
@@ -2368,17 +2365,7 @@ var RpcSessionImpl = class {
   }
   async readLoop() {
     while (!this.abortReason) {
-      let readAbort = Promise.withResolvers();
-      this.activeReadAbort = readAbort;
-      let msgText;
-      try {
-        msgText = await Promise.race([this.transport.receive(), readAbort.promise]);
-      } finally {
-        if (this.activeReadAbort === readAbort) {
-          this.activeReadAbort = void 0;
-        }
-      }
-      let msg = JSON.parse(msgText);
+      let msg = JSON.parse(await this.receiveOrAbort());
       if (this.abortReason) break;
       if (msg instanceof Array) {
         switch (msg[0]) {
@@ -2460,6 +2447,22 @@ var RpcSessionImpl = class {
       throw new Error(`bad RPC message: ${JSON.stringify(msg)}`);
     }
   }
+  receiveOrAbort() {
+    let readCanceled = Promise.withResolvers();
+    this.cancelReadLoop = readCanceled.reject;
+    let receivePromise;
+    try {
+      receivePromise = this.transport.receive();
+    } catch (err) {
+      this.cancelReadLoop = void 0;
+      return Promise.reject(err);
+    }
+    return Promise.race([receivePromise, readCanceled.promise]).finally(() => {
+      if (this.cancelReadLoop === readCanceled.reject) {
+        this.cancelReadLoop = void 0;
+      }
+    });
+  }
   async drain() {
     if (this.abortReason) {
       throw this.abortReason;
@@ -2506,6 +2509,7 @@ var RpcSession = class {
 };
 
 // src/websocket.ts
+var RESOLVED_VOID_PROMISE = Promise.resolve();
 function newWebSocketRpcSession(webSocket, localMain, options) {
   if (typeof webSocket === "string") {
     webSocket = new WebSocket(webSocket);
@@ -2570,18 +2574,23 @@ var WebSocketTransport = class {
   #receiveRejecter;
   #receiveQueue = [];
   #error;
-  async send(message) {
-    if (this.#sendQueue === void 0) {
-      this.#webSocket.send(message);
-    } else {
-      this.#sendQueue.push(message);
+  send(message) {
+    try {
+      if (this.#sendQueue === void 0) {
+        this.#webSocket.send(message);
+      } else {
+        this.#sendQueue.push(message);
+      }
+      return RESOLVED_VOID_PROMISE;
+    } catch (err) {
+      return Promise.reject(err);
     }
   }
-  async receive() {
+  receive() {
     if (this.#receiveQueue.length > 0) {
-      return this.#receiveQueue.shift();
+      return Promise.resolve(this.#receiveQueue.shift());
     } else if (this.#error) {
-      throw this.#error;
+      return Promise.reject(this.#error);
     } else {
       return new Promise((resolve, reject) => {
         this.#receiveResolver = resolve;
@@ -2614,6 +2623,7 @@ var WebSocketTransport = class {
 };
 
 // src/batch.ts
+var RESOLVED_VOID_PROMISE2 = Promise.resolve();
 var BatchClientTransport = class {
   constructor(sendBatch) {
     this.#promise = this.#scheduleBatch(sendBatch);
@@ -2622,10 +2632,11 @@ var BatchClientTransport = class {
   #aborted;
   #batchToSend = [];
   #batchToReceive = null;
-  async send(message) {
+  send(message) {
     if (this.#batchToSend !== null) {
       this.#batchToSend.push(message);
     }
+    return RESOLVED_VOID_PROMISE2;
   }
   async receive() {
     if (!this.#batchToReceive) {
@@ -2675,8 +2686,9 @@ var BatchServerTransport = class {
   #batchToSend = [];
   #batchToReceive;
   #allReceived = Promise.withResolvers();
-  async send(message) {
+  send(message) {
     this.#batchToSend.push(message);
+    return RESOLVED_VOID_PROMISE2;
   }
   async receive() {
     let msg = this.#batchToReceive.shift();
@@ -2734,6 +2746,7 @@ async function nodeHttpBatchRpcResponse(request, response, localMain, options) {
 }
 
 // src/messageport.ts
+var RESOLVED_VOID_PROMISE3 = Promise.resolve();
 function newMessagePortRpcSession(port, localMain, options) {
   let transport = new MessagePortTransport(port);
   let rpc = new RpcSession(transport, localMain, options);
@@ -2767,17 +2780,22 @@ var MessagePortTransport = class {
   #receiveRejecter;
   #receiveQueue = [];
   #error;
-  async send(message) {
+  send(message) {
     if (this.#error) {
-      throw this.#error;
+      return Promise.reject(this.#error);
+    }
+    try {
+      this.#port.postMessage(message);
+      return RESOLVED_VOID_PROMISE3;
+    } catch (err) {
+      return Promise.reject(err);
     }
-    this.#port.postMessage(message);
   }
-  async receive() {
+  receive() {
     if (this.#receiveQueue.length > 0) {
-      return this.#receiveQueue.shift();
+      return Promise.resolve(this.#receiveQueue.shift());
     } else if (this.#error) {
-      throw this.#error;
+      return Promise.reject(this.#error);
     } else {
       return new Promise((resolve, reject) => {
         this.#receiveResolver = resolve;