@ricsam/isolate-client 0.1.22 → 0.1.24

package/dist/cjs/connection.cjs

@@ -90,6 +90,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
   };
@@ -126,6 +128,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();
@@ -211,6 +218,7 @@ async function connect(options = {}) {
           requestId,
           options: {
             memoryLimitMB: runtimeOptions.memoryLimitMB,
+            executionTimeout: runtimeOptions.executionTimeout,
             cwd: runtimeOptions.cwd,
             callbacks,
             testEnvironment: testEnvironmentOption,
@@ -311,6 +319,18 @@ function handleMessage(message, state) {
       }
       break;
     }
+    case import_isolate_protocol.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 import_isolate_protocol.MessageType.ISOLATE_EVENT: {
       const msg = message;
       handleIsolateEvent(msg, state);
@@ -473,6 +493,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: import_isolate_protocol.MessageType.CALLBACK_RESPONSE,
     requestId: invoke.requestId
@@ -482,7 +504,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);
@@ -490,9 +515,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,
@@ -500,6 +531,8 @@ async function handleCallbackInvoke(invoke, state) {
         stack: error.stack
       };
       sendMessage(state.socket, response);
+    } finally {
+      state.activeCallbackInvocations.delete(invoke.requestId);
     }
   }
 }
@@ -680,6 +713,7 @@ async function createRuntime(state, options = {}, namespaceId) {
     requestId,
     options: {
       memoryLimitMB: options.memoryLimitMB,
+      executionTimeout: options.executionTimeout,
       cwd: options.cwd,
       callbacks,
       testEnvironment: testEnvironmentOption,
@@ -1009,7 +1043,8 @@ async function createRuntime(state, options = {}, namespaceId) {
         requestId: reqId,
         isolateId,
         code,
-        filename: options2?.filename
+        filename: options2?.filename,
+        executionTimeout: options2?.executionTimeout
       };
       await sendRequest(state, req);
     },
@@ -1105,42 +1140,52 @@ function registerFetchCallback(state, callback) {
   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 && !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: import_isolate_protocol.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: import_isolate_protocol.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 import_isolate_protocol.serializeResponse(response);
+    } finally {
+      if (callbackRequestId !== undefined) {
+        state.callbackAbortControllers.delete(callbackRequestId);
+      }
     }
-    return import_isolate_protocol.serializeResponse(response);
   });
   return { callbackId, name: "fetch", type: "async" };
 }
@@ -1742,4 +1787,4 @@ function handleClientWsClose(isolateId, payload, state) {
   }
 }
 
-//# debugId=9D2040E2D4C3FD6F64756E2164756E21
+//# debugId=D533D4D673D0E39164756E2164756E21