@ricsam/isolate-client 0.1.5 → 0.1.6

package/dist/mjs/connection.mjs

@@ -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();
@@ -150,23 +174,35 @@ function handleMessage(message, state) {
         metadata: msg.metadata,
         controller: null,
         state: "active",
-        pendingChunks: []
+        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") {
-            receiver.controller.close();
-            return;
+            if (!receiver.controllerFinalized) {
+              receiver.controllerFinalized = true;
+              receiver.controller.close();
+            }
+            return Promise.resolve();
           }
           if (receiver.state === "errored") {
-            return;
+            if (!receiver.controllerFinalized && receiver.error) {
+              receiver.controllerFinalized = true;
+              receiver.controller.error(receiver.error);
+            }
+            return Promise.resolve();
           }
           sendMessage(state.socket, {
             type: MessageType.STREAM_PULL,
@@ -174,17 +210,23 @@ function handleMessage(message, state) {
             maxBytes: STREAM_DEFAULT_CREDIT
           });
           return new Promise((resolve) => {
-            receiver.pullResolver = resolve;
+            receiver.pullResolvers.push(resolve);
           });
         },
         cancel(_reason) {
-          receiver.state = "errored";
+          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);
@@ -211,10 +253,9 @@ function handleMessage(message, state) {
       const msg = message;
       const receiver = state.streamResponses.get(msg.streamId);
       if (receiver && receiver.state === "active") {
-        if (receiver.pullResolver) {
+        if (receiver.pullResolvers.length > 0) {
           receiver.controller.enqueue(msg.chunk);
-          const resolver = receiver.pullResolver;
-          receiver.pullResolver = undefined;
+          const resolver = receiver.pullResolvers.shift();
           resolver();
         } else {
           receiver.pendingChunks.push(msg.chunk);
@@ -231,10 +272,12 @@ function handleMessage(message, state) {
           const chunk = receiver.pendingChunks.shift();
           receiver.controller.enqueue(chunk);
         }
-        receiver.controller.close();
-        if (receiver.pullResolver) {
-          const resolver = receiver.pullResolver;
-          receiver.pullResolver = undefined;
+        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);
@@ -263,10 +306,13 @@ function handleMessage(message, state) {
       const receiver = state.streamResponses.get(msg.streamId);
       if (receiver) {
         receiver.state = "errored";
-        receiver.controller.error(new Error(msg.error));
-        if (receiver.pullResolver) {
-          const resolver = receiver.pullResolver;
-          receiver.pullResolver = undefined;
+        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);
@@ -326,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);
@@ -449,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 = {
@@ -697,6 +745,7 @@ async function createRuntime(state, options = {}) {
   return {
     id: isolateId,
     isolateId,
+    reused,
     fetch: fetchHandle,
     timers: timersHandle,
     console: consoleHandle,
@@ -830,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" };
 }
@@ -1159,4 +1215,4 @@ export {
   connect
 };
 
-//# debugId=2BAB1C12EE66984164756E2164756E21
+//# debugId=B4800C212010D2AD64756E2164756E21