@ricsam/isolate-fetch 0.1.9 → 0.1.10

package/dist/cjs/index.cjs

@@ -50,6 +50,7 @@ var import_isolated_vm = __toESM(require("isolated-vm"));
 var import_isolate_core = require("@ricsam/isolate-core");
 var import_stream_state = require("./stream-state.cjs");
 var instanceStateMap = new WeakMap;
+var passthruBodies = new WeakMap;
 var nextInstanceId = 1;
 function getInstanceStateMapForContext(context) {
   let map = instanceStateMap.get(context);
@@ -59,6 +60,14 @@ function getInstanceStateMapForContext(context) {
   }
   return map;
 }
+function getPassthruBodiesForContext(context) {
+  let map = passthruBodies.get(context);
+  if (!map) {
+    map = new Map;
+    passthruBodies.set(context, map);
+  }
+  return map;
+}
 var headersCode = `
 (function() {
   class Headers {
@@ -647,8 +656,12 @@ function setupResponse(context, stateMap) {
       // Mark as needing async Blob handling - will be read in constructor
       return { __isBlob: true, blob: body };
     }
-    // Handle ReadableStream (both native and host-backed)
-    if (body instanceof ReadableStream || body instanceof HostBackedReadableStream) {
+    // Handle HostBackedReadableStream specially - preserve streamId
+    if (body instanceof HostBackedReadableStream) {
+      return { __isHostStream: true, stream: body, streamId: body._getStreamId() };
+    }
+    // Handle native ReadableStream
+    if (body instanceof ReadableStream) {
       return { __isStream: true, stream: body };
     }
     // Try to convert to string
@@ -703,7 +716,27 @@ function setupResponse(context, stateMap) {
         return;
       }
 
-      // Handle streaming body
+      // Handle HostBackedReadableStream - reuse existing streamId for pass-through
+      if (preparedBody && preparedBody.__isHostStream) {
+        // Reuse the existing streamId to preserve the pass-through body mapping
+        this.#streamId = preparedBody.streamId;
+        const status = init.status ?? 200;
+        const statusText = init.statusText ?? '';
+        const headers = new Headers(init.headers);
+        const headersArray = Array.from(headers.entries());
+
+        this.#instanceId = __Response_constructStreaming(
+          this.#streamId,
+          status,
+          statusText,
+          headersArray
+        );
+        this.#headers = headers;
+        // Don't pump - the body is already backed by this streamId
+        return;
+      }
+
+      // Handle native ReadableStream body
       if (preparedBody && preparedBody.__isStream) {
         this.#streamId = __Stream_create();
         const status = init.status ?? 200;
@@ -1384,7 +1417,8 @@ function setupRequest(context, stateMap) {
 `;
   context.evalSync(requestCode);
 }
-function setupFetchFunction(context, stateMap, options) {
+var FETCH_STREAM_THRESHOLD = 64 * 1024;
+function setupFetchFunction(context, stateMap, streamRegistry, options) {
   const global = context.global;
   const fetchRef = new import_isolated_vm.default.Reference(async (url, method, headersJson, bodyJson, signalAborted) => {
     if (signalAborted) {
@@ -1400,6 +1434,69 @@ function setupFetchFunction(context, stateMap, options) {
     });
     const onFetch = options?.onFetch ?? fetch;
     const nativeResponse = await onFetch(nativeRequest);
+    const contentLength = nativeResponse.headers.get("content-length");
+    const knownSize = contentLength ? parseInt(contentLength, 10) : null;
+    const isCallbackStream = nativeResponse.__isCallbackStream;
+    const isNetworkResponse = nativeResponse.url && (nativeResponse.url.startsWith("http://") || nativeResponse.url.startsWith("https://"));
+    const shouldStream = nativeResponse.body && (isCallbackStream || isNetworkResponse && (knownSize === null || knownSize > FETCH_STREAM_THRESHOLD));
+    if (shouldStream && nativeResponse.body) {
+      if (isCallbackStream) {
+        const streamId2 = streamRegistry.create();
+        const passthruMap = getPassthruBodiesForContext(context);
+        passthruMap.set(streamId2, nativeResponse.body);
+        const instanceId3 = nextInstanceId++;
+        const state3 = {
+          status: nativeResponse.status,
+          statusText: nativeResponse.statusText,
+          headers: Array.from(nativeResponse.headers.entries()),
+          body: new Uint8Array(0),
+          bodyUsed: false,
+          type: "default",
+          url: nativeResponse.url,
+          redirected: nativeResponse.redirected,
+          streamId: streamId2
+        };
+        stateMap.set(instanceId3, state3);
+        return instanceId3;
+      }
+      const streamId = streamRegistry.create();
+      const instanceId2 = nextInstanceId++;
+      const state2 = {
+        status: nativeResponse.status,
+        statusText: nativeResponse.statusText,
+        headers: Array.from(nativeResponse.headers.entries()),
+        body: new Uint8Array(0),
+        bodyUsed: false,
+        type: "default",
+        url: nativeResponse.url,
+        redirected: nativeResponse.redirected,
+        streamId
+      };
+      stateMap.set(instanceId2, state2);
+      const reader = nativeResponse.body.getReader();
+      (async () => {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              streamRegistry.close(streamId);
+              break;
+            }
+            if (value) {
+              while (streamRegistry.isQueueFull(streamId)) {
+                await new Promise((r) => setTimeout(r, 1));
+              }
+              streamRegistry.push(streamId, value);
+            }
+          }
+        } catch (err) {
+          streamRegistry.error(streamId, err);
+        } finally {
+          reader.releaseLock();
+        }
+      })();
+      return instanceId2;
+    }
     const responseBody = await nativeResponse.arrayBuffer();
     const responseBodyArray = Array.from(new Uint8Array(responseBody));
     const instanceId = nextInstanceId++;
@@ -1573,7 +1670,7 @@ async function setupFetch(context, options) {
   context.evalSync(hostBackedStreamCode);
   setupResponse(context, stateMap);
   setupRequest(context, stateMap);
-  setupFetchFunction(context, stateMap, options);
+  setupFetchFunction(context, stateMap, streamRegistry, options);
   const serveState = {
     pendingUpgrade: null,
     activeConnections: new Map
@@ -1636,6 +1733,22 @@ async function setupFetch(context, options) {
         if (!responseState) {
           throw new Error("Response state not found");
         }
+        if (responseState.streamId !== null) {
+          const passthruMap = getPassthruBodiesForContext(context);
+          const passthruBody = passthruMap.get(responseState.streamId);
+          if (passthruBody) {
+            passthruMap.delete(responseState.streamId);
+            const responseHeaders2 = new Headers(responseState.headers);
+            const status2 = responseState.status === 101 ? 200 : responseState.status;
+            const response2 = new Response(passthruBody, {
+              status: status2,
+              statusText: responseState.statusText,
+              headers: responseHeaders2
+            });
+            response2._originalStatus = responseState.status;
+            return response2;
+          }
+        }
         if (responseState.streamId !== null) {
           const responseStreamId = responseState.streamId;
           let streamDone = false;
@@ -1817,4 +1930,4 @@ async function setupFetch(context, options) {
   };
 }
 
-//# debugId=653D8B1934FCEAA064756E2164756E21
+//# debugId=D2829934F58098A764756E2164756E21