@ricsam/isolate-daemon 0.1.21 → 0.1.22

package/dist/cjs/package.json

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

package/dist/mjs/connection.mjs

@@ -20,6 +20,25 @@ import {
 } from "@ricsam/isolate-runtime";
 var LINKER_CONFLICT_ERROR = "Module is currently being linked by another linker";
 var NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
+var DEFAULT_CALLBACK_TIMEOUT_MS = 120000;
+var FETCH_CALLBACK_TIMEOUT_MS = 35000;
+function createAbortError(reason = "The operation was aborted") {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException(reason, "AbortError");
+  }
+  const error = new Error(reason);
+  error.name = "AbortError";
+  return error;
+}
+function sendCallbackAbortMessage(connection, targetRequestId, reason) {
+  const abortMessage = {
+    type: MessageType.CALLBACK_ABORT,
+    requestId: connection.nextRequestId++,
+    targetRequestId,
+    reason
+  };
+  sendMessage(connection.socket, abortMessage);
+}
 function getErrorText(error) {
   if (error instanceof Error) {
     const cause = error.cause;
@@ -94,6 +113,7 @@ function handleConnection(socket, state) {
       }
     }
     for (const [, pending] of connection.pendingCallbacks) {
+      pending.cleanup?.();
       pending.reject(new Error("Connection closed"));
     }
     connection.pendingCallbacks.clear();
@@ -427,14 +447,14 @@ async function waitForConnection(callbackContext) {
   }
   throw new Error("No connection available and no reconnection pending");
 }
-async function invokeCallbackWithReconnect(callbackContext, getCallbackId, args, label, invokeClientCallback) {
+async function invokeCallbackWithReconnect(callbackContext, getCallbackId, args, label, invokeClientCallback, options) {
   const conn = await waitForConnection(callbackContext);
   const cbId = getCallbackId();
   if (cbId === undefined) {
     throw new Error(`${label} callback not available`);
   }
   try {
-    return await invokeClientCallback(conn, cbId, args);
+    return await invokeClientCallback(conn, cbId, args, options);
   } catch (err) {
     if (callbackContext.reconnectionPromise && !callbackContext.connection) {
       const newConn = await callbackContext.reconnectionPromise.promise;
@@ -442,7 +462,7 @@ async function invokeCallbackWithReconnect(callbackContext, getCallbackId, args,
       if (newCbId === undefined) {
         throw new Error(`${label} callback not available after reconnection`);
       }
-      return invokeClientCallback(newConn, newCbId, args);
+      return invokeClientCallback(newConn, newCbId, args, options);
     }
     throw err;
   }
@@ -765,6 +785,9 @@ async function handleCreateRuntime(message, connection, state) {
         }
       },
       fetch: async (url, init) => {
+        if (init.signal.aborted) {
+          throw createAbortError();
+        }
         const serialized = {
           url,
           method: init.method,
@@ -772,7 +795,16 @@ async function handleCreateRuntime(message, connection, state) {
           body: init.rawBody,
           signalAborted: init.signal.aborted
         };
-        const result = await invokeCallbackWithReconnect(callbackContext, () => callbackContext.fetch, [serialized], "Fetch", invokeClientCallback);
+        const callbackAbortController = new AbortController;
+        const onInitAbort = () => callbackAbortController.abort();
+        init.signal.addEventListener("abort", onInitAbort, { once: true });
+        const result = await invokeCallbackWithReconnect(callbackContext, () => callbackContext.fetch, [serialized], "Fetch", invokeClientCallback, {
+          signal: callbackAbortController.signal,
+          timeoutMs: FETCH_CALLBACK_TIMEOUT_MS,
+          timeoutLabel: "fetch callback"
+        }).finally(() => {
+          init.signal.removeEventListener("abort", onInitAbort);
+        });
         if (result && typeof result === "object" && result.__streamingResponse) {
           const response = result.response;
           response.__isCallbackStream = true;
@@ -1303,6 +1335,7 @@ function handleCallbackResponse(message, connection) {
     return;
   }
   connection.pendingCallbacks.delete(message.requestId);
+  pending.cleanup?.();
   if (message.error) {
     const error = new Error(message.error.message);
     error.name = message.error.name;
@@ -1314,12 +1347,68 @@ function handleCallbackResponse(message, connection) {
     pending.resolve(message.result);
   }
 }
-async function invokeClientCallback(connection, callbackId, args) {
+async function invokeClientCallback(connection, callbackId, args, options) {
   const requestId = connection.nextCallbackId++;
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_CALLBACK_TIMEOUT_MS;
   return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeoutId;
+    let onAbort;
+    let callbackInvokeSent = false;
+    const settle = (handler, value) => {
+      if (settled)
+        return;
+      settled = true;
+      connection.pendingCallbacks.delete(requestId);
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+      }
+      if (options?.signal && onAbort) {
+        options.signal.removeEventListener("abort", onAbort);
+      }
+      handler(value);
+    };
+    onAbort = () => {
+      if (settled)
+        return;
+      if (callbackInvokeSent) {
+        sendCallbackAbortMessage(connection, requestId, options?.timeoutLabel ? `${options.timeoutLabel} aborted` : "Callback aborted");
+      }
+      settle(reject, createAbortError());
+    };
+    if (options?.signal) {
+      if (options.signal.aborted) {
+        onAbort();
+        return;
+      }
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    if (timeoutMs > 0) {
+      timeoutId = setTimeout(() => {
+        if (settled)
+          return;
+        const label = options?.timeoutLabel ?? "callback";
+        const timeoutError = new Error(`${label} timed out after ${timeoutMs}ms`);
+        if (callbackInvokeSent) {
+          sendCallbackAbortMessage(connection, requestId, timeoutError.message);
+        }
+        settle(reject, timeoutError);
+      }, timeoutMs);
+    }
     const pending = {
-      resolve,
-      reject
+      callbackId,
+      cleanup: () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = undefined;
+        }
+        if (options?.signal && onAbort) {
+          options.signal.removeEventListener("abort", onAbort);
+        }
+      },
+      resolve: (result) => settle(resolve, result),
+      reject: (error) => settle(reject, error)
     };
     connection.pendingCallbacks.set(requestId, pending);
     const invoke = {
@@ -1329,6 +1418,7 @@ async function invokeClientCallback(connection, callbackId, args) {
       args
     };
     sendMessage(connection.socket, invoke);
+    callbackInvokeSent = true;
   });
 }
 function handleStreamPush(message, connection) {
@@ -1748,4 +1838,4 @@ export {
   handleConnection
 };
 
-//# debugId=D1C19AA670E1882A64756E2164756E21
+//# debugId=4B8E282F52FFC2D664756E2164756E21