@ricsam/isolate-client 0.1.21 → 0.1.23

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/isolate-client",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "type": "commonjs"
 }

package/dist/mjs/connection.mjs

@@ -39,6 +39,8 @@ async function connect(options = {}) {
     uploadStreams: new Map,
     moduleSourceCache: new Map,
     callbackStreamReaders: new Map,
+    activeCallbackInvocations: new Map,
+    callbackAbortControllers: new Map,
     closing: false,
     namespacedRuntimes: new Map
   };
@@ -75,6 +77,11 @@ async function connect(options = {}) {
         }
       }
       state.uploadStreams.clear();
+      for (const [, controller] of state.callbackAbortControllers) {
+        controller.abort();
+      }
+      state.callbackAbortControllers.clear();
+      state.activeCallbackInvocations.clear();
       if (!state.closing && state.namespacedRuntimes.size > 0) {
         state.reconnecting = reconnect(state, options).catch(() => {
           state.namespacedRuntimes.clear();
@@ -260,6 +267,18 @@ function handleMessage(message, state) {
       }
       break;
     }
+    case MessageType.CALLBACK_ABORT: {
+      const msg = message;
+      const invocation = state.activeCallbackInvocations.get(msg.targetRequestId);
+      if (invocation) {
+        invocation.aborted = true;
+      }
+      const controller = state.callbackAbortControllers.get(msg.targetRequestId);
+      if (controller && !controller.signal.aborted) {
+        controller.abort();
+      }
+      break;
+    }
     case MessageType.ISOLATE_EVENT: {
       const msg = message;
       handleIsolateEvent(msg, state);
@@ -422,6 +441,8 @@ function handleMessage(message, state) {
 }
 async function handleCallbackInvoke(invoke, state) {
   const callback = state.callbacks.get(invoke.callbackId);
+  const invocationState = { aborted: false };
+  state.activeCallbackInvocations.set(invoke.requestId, invocationState);
   const response = {
     type: MessageType.CALLBACK_RESPONSE,
     requestId: invoke.requestId
@@ -431,7 +452,10 @@ async function handleCallbackInvoke(invoke, state) {
       name: "Error",
       message: `Unknown callback: ${invoke.callbackId}`
     };
-    sendMessage(state.socket, response);
+    if (!invocationState.aborted) {
+      sendMessage(state.socket, response);
+    }
+    state.activeCallbackInvocations.delete(invoke.requestId);
   } else {
     try {
       const needsRequestId = state.callbacksNeedingRequestId.has(invoke.callbackId);
@@ -439,9 +463,15 @@ async function handleCallbackInvoke(invoke, state) {
       if (result && typeof result === "object" && result.__callbackStreaming) {
         return;
       }
+      if (invocationState.aborted) {
+        return;
+      }
       response.result = result;
       sendMessage(state.socket, response);
     } catch (err) {
+      if (invocationState.aborted) {
+        return;
+      }
       const error = err;
       response.error = {
         name: error.name,
@@ -449,6 +479,8 @@ async function handleCallbackInvoke(invoke, state) {
         stack: error.stack
       };
       sendMessage(state.socket, response);
+    } finally {
+      state.activeCallbackInvocations.delete(invoke.requestId);
     }
   }
 }
@@ -1047,48 +1079,59 @@ function registerConsoleCallbacks(state, callbacks) {
   return registrations;
 }
 var CALLBACK_STREAM_THRESHOLD = 64 * 1024;
+var NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
 function registerFetchCallback(state, callback) {
   const callbackId = state.nextCallbackId++;
   state.callbacksNeedingRequestId.add(callbackId);
   state.callbacks.set(callbackId, async (serialized, requestId) => {
     const data = serialized;
     const signalController = new AbortController;
+    const callbackRequestId = typeof requestId === "number" ? requestId : undefined;
+    if (callbackRequestId !== undefined) {
+      state.callbackAbortControllers.set(callbackRequestId, signalController);
+    }
     if (data.signalAborted) {
       signalController.abort();
     }
-    const init = {
-      method: data.method,
-      headers: data.headers,
-      rawBody: data.body ?? null,
-      body: data.body ?? null,
-      signal: signalController.signal
-    };
-    const response = await callback(data.url, init);
-    const contentLength = response.headers.get("content-length");
-    const knownSize = contentLength ? parseInt(contentLength, 10) : null;
-    const isNetworkResponse = response.url && (response.url.startsWith("http://") || response.url.startsWith("https://"));
-    const shouldStream = isNetworkResponse && response.body && (knownSize === null || knownSize > CALLBACK_STREAM_THRESHOLD);
-    if (shouldStream && response.body) {
-      const streamId = state.nextStreamId++;
-      const headers = [];
-      response.headers.forEach((value, key) => {
-        headers.push([key, value]);
-      });
-      sendMessage(state.socket, {
-        type: MessageType.CALLBACK_STREAM_START,
-        requestId,
-        streamId,
-        metadata: {
-          status: response.status,
-          statusText: response.statusText,
-          headers,
-          url: response.url || undefined
-        }
-      });
-      streamCallbackResponseBody(state, streamId, requestId, response.body);
-      return { __callbackStreaming: true, streamId };
+    try {
+      const init = {
+        method: data.method,
+        headers: data.headers,
+        rawBody: data.body ?? null,
+        body: data.body ?? null,
+        signal: signalController.signal
+      };
+      const response = await callback(data.url, init);
+      const contentLength = response.headers.get("content-length");
+      const knownSize = contentLength ? parseInt(contentLength, 10) : null;
+      const isNetworkResponse = response.url && (response.url.startsWith("http://") || response.url.startsWith("https://"));
+      const shouldStream = isNetworkResponse && !NULL_BODY_STATUSES.has(response.status) && !!response.body && (knownSize === null || knownSize > CALLBACK_STREAM_THRESHOLD);
+      if (shouldStream && response.body) {
+        const streamId = state.nextStreamId++;
+        const headers = [];
+        response.headers.forEach((value, key) => {
+          headers.push([key, value]);
+        });
+        sendMessage(state.socket, {
+          type: MessageType.CALLBACK_STREAM_START,
+          requestId,
+          streamId,
+          metadata: {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            url: response.url || undefined
+          }
+        });
+        streamCallbackResponseBody(state, streamId, requestId, response.body);
+        return { __callbackStreaming: true, streamId };
+      }
+      return serializeResponse(response);
+    } finally {
+      if (callbackRequestId !== undefined) {
+        state.callbackAbortControllers.delete(callbackRequestId);
+      }
     }
-    return serializeResponse(response);
   });
   return { callbackId, name: "fetch", type: "async" };
 }
@@ -1694,4 +1737,4 @@ export {
   connect
 };
 
-//# debugId=17E01CA2373935E664756E2164756E21
+//# debugId=A9015ACD8149CB6C64756E2164756E21