@ricsam/isolate-daemon 0.1.8 → 0.1.9

package/dist/cjs/package.json

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

package/dist/mjs/connection.mjs

@@ -34,7 +34,8 @@ function handleConnection(socket, state) {
     nextCallbackId: 1,
     nextStreamId: 1,
     activeStreams: new Map,
-    streamReceivers: new Map
+    streamReceivers: new Map,
+    callbackStreamReceivers: new Map
   };
   state.connections.set(socket, connection);
   const parser = createFrameParser();
@@ -195,6 +196,15 @@ async function handleMessage(message, connection, state) {
     case MessageType.STREAM_ERROR:
       handleStreamError(message, connection);
       break;
+    case MessageType.CALLBACK_STREAM_START:
+      handleCallbackStreamStart(message, connection);
+      break;
+    case MessageType.CALLBACK_STREAM_CHUNK:
+      handleCallbackStreamChunk(message, connection);
+      break;
+    case MessageType.CALLBACK_STREAM_END:
+      handleCallbackStreamEnd(message, connection);
+      break;
     default:
       sendError(connection.socket, message.requestId ?? 0, ErrorCode.UNKNOWN_MESSAGE_TYPE, `Unknown message type: ${message.type}`);
   }
@@ -386,7 +396,12 @@ async function handleCreateRuntime(message, connection, state) {
             throw new Error("Fetch callback not available");
           }
           const serialized = await serializeRequest(request);
-          const result = await invokeClientCallback(conn, callbackId, [serialized]);
+          const result = await invokeClientCallback(conn, callbackId, [serialized], 60000);
+          if (result && typeof result === "object" && result.__streamingResponse) {
+            const response = result.response;
+            response.__isCallbackStream = true;
+            return response;
+          }
           return deserializeResponse(result);
         }
       },
@@ -1434,6 +1449,115 @@ function handleStreamError(message, connection) {
     session.state = "closed";
     connection.activeStreams.delete(message.streamId);
   }
+  const callbackReceiver = connection.callbackStreamReceivers.get(message.streamId);
+  if (callbackReceiver && callbackReceiver.state === "active") {
+    callbackReceiver.state = "errored";
+    callbackReceiver.error = new Error(message.error);
+    const resolvers = callbackReceiver.pullResolvers.splice(0);
+    for (const resolver of resolvers) {
+      resolver();
+    }
+    connection.callbackStreamReceivers.delete(message.streamId);
+  }
+}
+function handleCallbackStreamStart(message, connection) {
+  const receiver = {
+    streamId: message.streamId,
+    requestId: message.requestId,
+    metadata: message.metadata,
+    controller: null,
+    state: "active",
+    pendingChunks: [],
+    pullResolvers: [],
+    controllerFinalized: false
+  };
+  const readableStream = new ReadableStream({
+    start(controller) {
+      receiver.controller = controller;
+    },
+    pull(_controller) {
+      if (receiver.controllerFinalized) {
+        return;
+      }
+      if (receiver.pendingChunks.length > 0) {
+        const chunk = receiver.pendingChunks.shift();
+        receiver.controller.enqueue(chunk);
+        return Promise.resolve();
+      }
+      if (receiver.state === "closed") {
+        if (!receiver.controllerFinalized) {
+          receiver.controllerFinalized = true;
+          receiver.controller.close();
+        }
+        return Promise.resolve();
+      }
+      if (receiver.state === "errored") {
+        if (!receiver.controllerFinalized && receiver.error) {
+          receiver.controllerFinalized = true;
+          receiver.controller.error(receiver.error);
+        }
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        receiver.pullResolvers.push(resolve);
+      });
+    },
+    cancel(_reason) {
+      receiver.state = "closed";
+      receiver.controllerFinalized = true;
+      const resolvers = receiver.pullResolvers.splice(0);
+      for (const resolver of resolvers) {
+        resolver();
+      }
+      connection.callbackStreamReceivers.delete(message.streamId);
+      return Promise.resolve();
+    }
+  });
+  connection.callbackStreamReceivers.set(message.streamId, receiver);
+  const pending = connection.pendingCallbacks.get(message.requestId);
+  if (pending) {
+    connection.pendingCallbacks.delete(message.requestId);
+    if (pending.timeoutId) {
+      clearTimeout(pending.timeoutId);
+    }
+    const response = new Response(readableStream, {
+      status: message.metadata.status,
+      statusText: message.metadata.statusText,
+      headers: message.metadata.headers
+    });
+    pending.resolve({ __streamingResponse: true, response });
+  }
+}
+function handleCallbackStreamChunk(message, connection) {
+  const receiver = connection.callbackStreamReceivers.get(message.streamId);
+  if (receiver && receiver.state === "active") {
+    if (receiver.pullResolvers.length > 0) {
+      receiver.controller.enqueue(message.chunk);
+      const resolver = receiver.pullResolvers.shift();
+      resolver();
+    } else {
+      receiver.pendingChunks.push(message.chunk);
+    }
+  }
+}
+function handleCallbackStreamEnd(message, connection) {
+  const receiver = connection.callbackStreamReceivers.get(message.streamId);
+  if (receiver) {
+    receiver.state = "closed";
+    while (receiver.pendingChunks.length > 0) {
+      const chunk = receiver.pendingChunks.shift();
+      receiver.controller.enqueue(chunk);
+    }
+    if (!receiver.controllerFinalized) {
+      receiver.controllerFinalized = true;
+      receiver.controller.close();
+    }
+    const resolvers = receiver.pullResolvers.splice(0);
+    for (const resolver of resolvers) {
+      resolver();
+    }
+    connection.callbackStreamReceivers.delete(message.streamId);
+  }
 }
 function waitForCredit(session) {
   return new Promise((resolve) => {
@@ -1661,4 +1785,4 @@ export {
   handleConnection
 };
 
-//# debugId=E63E520A2BD6529F64756E2164756E21
+//# debugId=9E949C5B88C72B2F64756E2164756E21