@ricsam/isolate-client 0.1.4 → 0.1.6

package/dist/mjs/connection.mjs

@@ -10,7 +10,7 @@ import {
   STREAM_DEFAULT_CREDIT,
   marshalValue
 } from "@ricsam/isolate-protocol";
-import { createPlaywrightHandler } from "@ricsam/isolate-playwright";
+import { createPlaywrightHandler } from "@ricsam/isolate-playwright/client";
 var DEFAULT_TIMEOUT = 30000;
 var isolateWsCallbacks = new Map;
 async function connect(options = {}) {
@@ -24,7 +24,8 @@ async function connect(options = {}) {
     nextStreamId: 1,
     connected: true,
     streamResponses: new Map,
-    uploadStreams: new Map
+    uploadStreams: new Map,
+    moduleSourceCache: new Map
   };
   const parser = createFrameParser();
   socket.on("data", (data) => {
@@ -39,15 +40,38 @@ async function connect(options = {}) {
   socket.on("close", () => {
     state.connected = false;
     for (const [, pending] of state.pendingRequests) {
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
       pending.reject(new Error("Connection closed"));
     }
     state.pendingRequests.clear();
+    for (const [, receiver] of state.streamResponses) {
+      receiver.state = "errored";
+      receiver.error = new Error("Connection closed");
+      const resolvers = receiver.pullResolvers.splice(0);
+      for (const resolver of resolvers) {
+        resolver();
+      }
+    }
+    state.streamResponses.clear();
+    for (const [, session] of state.uploadStreams) {
+      session.state = "closed";
+      if (session.creditResolver) {
+        session.creditResolver();
+      }
+    }
+    state.uploadStreams.clear();
   });
   socket.on("error", (err) => {
     console.error("Socket error:", err);
   });
   return {
     createRuntime: (runtimeOptions) => createRuntime(state, runtimeOptions),
+    createNamespace: (id) => ({
+      id,
+      createRuntime: (runtimeOptions) => createRuntime(state, runtimeOptions, id)
+    }),
     close: async () => {
       state.connected = false;
       socket.destroy();
@@ -148,10 +172,76 @@ function handleMessage(message, state) {
         streamId: msg.streamId,
         requestId: msg.requestId,
         metadata: msg.metadata,
-        chunks: [],
-        totalBytes: 0
+        controller: null,
+        state: "active",
+        pendingChunks: [],
+        pullResolvers: [],
+        controllerFinalized: false
       };
+      const readableStream = new ReadableStream({
+        start(controller) {
+          receiver.controller = controller;
+        },
+        pull(_controller) {
+          if (receiver.controllerFinalized) {
+            return;
+          }
+          while (receiver.pendingChunks.length > 0) {
+            const chunk = receiver.pendingChunks.shift();
+            receiver.controller.enqueue(chunk);
+          }
+          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();
+          }
+          sendMessage(state.socket, {
+            type: MessageType.STREAM_PULL,
+            streamId: msg.streamId,
+            maxBytes: STREAM_DEFAULT_CREDIT
+          });
+          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();
+          }
+          sendMessage(state.socket, {
+            type: MessageType.STREAM_ERROR,
+            streamId: msg.streamId,
+            error: "Stream cancelled by consumer"
+          });
+          state.streamResponses.delete(msg.streamId);
+          return new Promise((resolve) => setTimeout(resolve, 0));
+        }
+      });
       state.streamResponses.set(msg.streamId, receiver);
+      const pending = state.pendingRequests.get(msg.requestId);
+      if (pending) {
+        state.pendingRequests.delete(msg.requestId);
+        if (pending.timeoutId)
+          clearTimeout(pending.timeoutId);
+        const response = new Response(readableStream, {
+          status: msg.metadata?.status ?? 200,
+          statusText: msg.metadata?.statusText ?? "OK",
+          headers: msg.metadata?.headers
+        });
+        pending.resolve({ response, __streaming: true });
+      }
       sendMessage(state.socket, {
         type: MessageType.STREAM_PULL,
         streamId: msg.streamId,
@@ -162,14 +252,14 @@ function handleMessage(message, state) {
     case MessageType.RESPONSE_STREAM_CHUNK: {
       const msg = message;
       const receiver = state.streamResponses.get(msg.streamId);
-      if (receiver) {
-        receiver.chunks.push(msg.chunk);
-        receiver.totalBytes += msg.chunk.length;
-        sendMessage(state.socket, {
-          type: MessageType.STREAM_PULL,
-          streamId: msg.streamId,
-          maxBytes: STREAM_DEFAULT_CREDIT
-        });
+      if (receiver && receiver.state === "active") {
+        if (receiver.pullResolvers.length > 0) {
+          receiver.controller.enqueue(msg.chunk);
+          const resolver = receiver.pullResolvers.shift();
+          resolver();
+        } else {
+          receiver.pendingChunks.push(msg.chunk);
+        }
       }
       break;
     }
@@ -177,20 +267,18 @@ function handleMessage(message, state) {
       const msg = message;
       const receiver = state.streamResponses.get(msg.streamId);
       if (receiver) {
-        const body = concatUint8Arrays(receiver.chunks);
-        const pending = state.pendingRequests.get(receiver.requestId);
-        if (pending) {
-          state.pendingRequests.delete(receiver.requestId);
-          if (pending.timeoutId)
-            clearTimeout(pending.timeoutId);
-          pending.resolve({
-            response: {
-              status: receiver.metadata?.status ?? 200,
-              statusText: receiver.metadata?.statusText ?? "OK",
-              headers: receiver.metadata?.headers ?? [],
-              body
-            }
-          });
+        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();
         }
         state.streamResponses.delete(msg.streamId);
       }
@@ -217,12 +305,15 @@ function handleMessage(message, state) {
       }
       const receiver = state.streamResponses.get(msg.streamId);
       if (receiver) {
-        const pending = state.pendingRequests.get(receiver.requestId);
-        if (pending) {
-          state.pendingRequests.delete(receiver.requestId);
-          if (pending.timeoutId)
-            clearTimeout(pending.timeoutId);
-          pending.reject(new Error(msg.error));
+        receiver.state = "errored";
+        receiver.error = new Error(msg.error);
+        while (receiver.pendingChunks.length > 0) {
+          const chunk = receiver.pendingChunks.shift();
+          receiver.controller.enqueue(chunk);
+        }
+        const resolvers = receiver.pullResolvers.splice(0);
+        for (const resolver of resolvers) {
+          resolver();
         }
         state.streamResponses.delete(msg.streamId);
       }
@@ -232,16 +323,6 @@ function handleMessage(message, state) {
       console.warn(`Unexpected message type: ${message.type}`);
   }
 }
-function concatUint8Arrays(arrays) {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
 async function handleCallbackInvoke(invoke, state) {
   const callback = state.callbacks.get(invoke.callbackId);
   const response = {
@@ -291,7 +372,7 @@ function sendRequest(state, message, timeout = DEFAULT_TIMEOUT) {
     sendMessage(state.socket, message);
   });
 }
-async function createRuntime(state, options = {}) {
+async function createRuntime(state, options = {}, namespaceId) {
   const callbacks = {};
   if (options.console) {
     callbacks.console = registerConsoleCallbacks(state, options.console);
@@ -414,11 +495,13 @@ async function createRuntime(state, options = {}) {
       memoryLimitMB: options.memoryLimitMB,
       cwd: options.cwd,
       callbacks,
-      testEnvironment: testEnvironmentOption
+      testEnvironment: testEnvironmentOption,
+      namespaceId
     }
   };
   const result = await sendRequest(state, request);
   const isolateId = result.isolateId;
+  const reused = result.reused ?? false;
   const wsCommandCallbacks = new Set;
   isolateWsCallbacks.set(isolateId, wsCommandCallbacks);
   const fetchHandle = {
@@ -433,15 +516,21 @@ async function createRuntime(state, options = {}) {
         request: serializableRequest,
         options: opts
       };
+      const handleResponse = (res) => {
+        if (res.__streaming && res.response instanceof Response) {
+          return res.response;
+        }
+        return deserializeResponse(res.response);
+      };
       if (serialized.bodyStreamId !== undefined && bodyStream) {
         const streamId = serialized.bodyStreamId;
         const responsePromise = sendRequest(state, request2, opts?.timeout ?? DEFAULT_TIMEOUT);
         await sendBodyStream(state, streamId, bodyStream);
         const res = await responsePromise;
-        return deserializeResponse(res.response);
+        return handleResponse(res);
       } else {
         const res = await sendRequest(state, request2, opts?.timeout ?? DEFAULT_TIMEOUT);
-        return deserializeResponse(res.response);
+        return handleResponse(res);
       }
     },
     async getUpgradeRequest() {
@@ -656,6 +745,7 @@ async function createRuntime(state, options = {}) {
   return {
     id: isolateId,
     isolateId,
+    reused,
     fetch: fetchHandle,
     timers: timersHandle,
     console: consoleHandle,
@@ -789,7 +879,14 @@ function registerFsCallbacks(state, callbacks) {
 function registerModuleLoaderCallback(state, callback) {
   const callbackId = state.nextCallbackId++;
   state.callbacks.set(callbackId, async (moduleName) => {
-    return callback(moduleName);
+    const specifier = moduleName;
+    const cached = state.moduleSourceCache.get(specifier);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const source = await callback(specifier);
+    state.moduleSourceCache.set(specifier, source);
+    return source;
   });
   return { callbackId, name: "moduleLoader", type: "async" };
 }
@@ -1118,4 +1215,4 @@ export {
   connect
 };
 
-//# debugId=8168995DA414336764756E2164756E21
+//# debugId=B4800C212010D2AD64756E2164756E21