@vastblast/capnweb 0.7.0 → 0.7.3

package/dist/index-workers.js

@@ -2051,8 +2051,7 @@ var RpcSessionImpl = class {
   reverseExports = /* @__PURE__ */ new Map();
   imports = [];
   abortReason;
-  cancelReadLoop = () => {
-  };
+  cancelReadLoop;
   // 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 +2329,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,19 +2368,7 @@ var RpcSessionImpl = class {
   }
   async readLoop() {
     while (!this.abortReason) {
-      let rejectFunc;
-      let abortPromise = new Promise((resolve, reject) => {
-        rejectFunc = reject;
-      });
-      this.cancelReadLoop = rejectFunc;
-      let msgText;
-      try {
-        msgText = await Promise.race([this.transport.receive(), abortPromise]);
-      } finally {
-        this.cancelReadLoop = () => {
-        };
-      }
-      let msg = JSON.parse(msgText);
+      let msg = JSON.parse(await this.receiveOrAbort());
       if (this.abortReason) break;
       if (msg instanceof Array) {
         switch (msg[0]) {
@@ -2462,6 +2450,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;
@@ -2508,6 +2512,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);
@@ -2572,18 +2577,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;
@@ -2616,6 +2626,7 @@ var WebSocketTransport = class {
 };
 
 // src/batch.ts
+var RESOLVED_VOID_PROMISE2 = Promise.resolve();
 var BatchClientTransport = class {
   constructor(sendBatch) {
     this.#promise = this.#scheduleBatch(sendBatch);
@@ -2624,10 +2635,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) {
@@ -2677,8 +2689,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();
@@ -2736,6 +2749,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);
@@ -2769,17 +2783,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;