@ricsam/isolate-fetch 0.1.9 → 0.1.11

package/dist/mjs/index.mjs

@@ -6,6 +6,7 @@ import {
   startNativeStreamReader
 } from "./stream-state.mjs";
 var instanceStateMap = new WeakMap;
+var passthruBodies = new WeakMap;
 var nextInstanceId = 1;
 function getInstanceStateMapForContext(context) {
   let map = instanceStateMap.get(context);
@@ -15,6 +16,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 {
@@ -370,77 +379,79 @@ var hostBackedStreamCode = `
 (function() {
   const _streamIds = new WeakMap();
 
-  class HostBackedReadableStream {
+  // Polyfill values() on ReadableStream if not available (older V8 versions)
+  if (typeof ReadableStream.prototype.values !== 'function') {
+    ReadableStream.prototype.values = function(options) {
+      const reader = this.getReader();
+      return {
+        async next() {
+          const { value, done } = await reader.read();
+          if (done) {
+            reader.releaseLock();
+            return { value: undefined, done: true };
+          }
+          return { value, done: false };
+        },
+        async return(value) {
+          reader.releaseLock();
+          return { value, done: true };
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    };
+  }
+
+  // Create a proper ReadableStream subclass that reports as "ReadableStream"
+  class HostBackedReadableStream extends ReadableStream {
     constructor(streamId) {
       if (streamId === undefined) {
         streamId = __Stream_create();
       }
-      _streamIds.set(this, streamId);
-    }
 
-    _getStreamId() {
-      return _streamIds.get(this);
-    }
+      let closed = false;
 
-    getReader() {
-      const streamId = this._getStreamId();
-      let released = false;
+      super({
+        async pull(controller) {
+          if (closed) return;
 
-      return {
-        read: async () => {
-          if (released) {
-            throw new TypeError("Reader has been released");
-          }
           const resultJson = __Stream_pull_ref.applySyncPromise(undefined, [streamId]);
           const result = JSON.parse(resultJson);
 
           if (result.done) {
-            return { done: true, value: undefined };
+            closed = true;
+            controller.close();
+            return;
           }
-          return { done: false, value: new Uint8Array(result.value) };
-        },
-
-        releaseLock: () => {
-          released = true;
-        },
-
-        get closed() {
-          return new Promise(() => {});
+          controller.enqueue(new Uint8Array(result.value));
         },
-
-        cancel: async (reason) => {
+        cancel(reason) {
+          closed = true;
           __Stream_error(streamId, String(reason || "cancelled"));
         }
-      };
-    }
+      });
 
-    async cancel(reason) {
-      __Stream_error(this._getStreamId(), String(reason || "cancelled"));
+      _streamIds.set(this, streamId);
     }
 
-    get locked() {
-      return false;
+    // Override to report as ReadableStream for spec compliance
+    get [Symbol.toStringTag]() {
+      return 'ReadableStream';
     }
 
-    async *[Symbol.asyncIterator]() {
-      const reader = this.getReader();
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) return;
-          yield value;
-        }
-      } finally {
-        reader.releaseLock();
-      }
+    _getStreamId() {
+      return _streamIds.get(this);
     }
 
-    // Static method to create from existing stream ID
     static _fromStreamId(streamId) {
       return new HostBackedReadableStream(streamId);
     }
   }
 
+  // Make constructor.name return 'ReadableStream' for spec compliance
+  Object.defineProperty(HostBackedReadableStream, 'name', { value: 'ReadableStream' });
+
   globalThis.HostBackedReadableStream = HostBackedReadableStream;
 })();
 `;
@@ -603,8 +614,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
@@ -616,6 +631,7 @@ function setupResponse(context, stateMap) {
     #headers;
     #streamId = null;
     #blobInitPromise = null; // For async Blob body initialization
+    #cachedBody = null; // Memoized body stream for spec compliance
 
     constructor(body, init = {}) {
       // Handle internal construction from instance ID
@@ -659,7 +675,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;
@@ -758,9 +794,15 @@ function setupResponse(context, stateMap) {
     }
 
     get body() {
+      // Return cached body if available (WHATWG spec requires same object on repeated access)
+      if (this.#cachedBody !== null) {
+        return this.#cachedBody;
+      }
+
       const streamId = __Response_getStreamId(this.#instanceId);
       if (streamId !== null) {
-        return HostBackedReadableStream._fromStreamId(streamId);
+        this.#cachedBody = HostBackedReadableStream._fromStreamId(streamId);
+        return this.#cachedBody;
       }
 
       // Fallback: create host-backed stream from buffered body
@@ -773,7 +815,8 @@ function setupResponse(context, stateMap) {
       }
       __Stream_close(newStreamId);
 
-      return HostBackedReadableStream._fromStreamId(newStreamId);
+      this.#cachedBody = HostBackedReadableStream._fromStreamId(newStreamId);
+      return this.#cachedBody;
     }
 
     async text() {
@@ -1340,7 +1383,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 ivm.Reference(async (url, method, headersJson, bodyJson, signalAborted) => {
     if (signalAborted) {
@@ -1356,6 +1400,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++;
@@ -1529,7 +1636,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
@@ -1585,6 +1692,12 @@ async function setupFetch(context, options) {
             const request = Request._fromInstanceId(${requestInstanceId});
             const server = new __Server__();
             const response = await Promise.resolve(__serveOptions__.fetch(request, server));
+            if (response == null) {
+              throw new TypeError("fetch handler did not return a Response object (got " + (response === null ? "null" : "undefined") + ")");
+            }
+            if (typeof response._getInstanceId !== 'function') {
+              throw new TypeError("fetch handler must return a Response object (got " + (typeof response) + ")");
+            }
             return response._getInstanceId();
           })()
         `, { promise: true });
@@ -1592,6 +1705,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;
@@ -1653,12 +1782,17 @@ async function setupFetch(context, options) {
         response._originalStatus = responseState.status;
         return response;
       } finally {
+        if (requestStreamId !== null) {
+          const startTime = Date.now();
+          let streamState = streamRegistry.get(requestStreamId);
+          while (streamState && !streamState.closed && !streamState.errored && Date.now() - startTime < 100) {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            streamState = streamRegistry.get(requestStreamId);
+          }
+        }
         if (streamCleanup) {
           await streamCleanup();
         }
-        if (requestStreamId !== null) {
-          streamRegistry.delete(requestStreamId);
-        }
       }
     },
     getUpgradeRequest() {
@@ -1777,4 +1911,4 @@ export {
   clearAllInstanceState
 };
 
-//# debugId=CBC79B470DCCB48D64756E2164756E21
+//# debugId=5C3C175E215A892A64756E2164756E21