@ricsam/isolate-fetch 0.1.10 → 0.1.12

package/dist/cjs/index.cjs

@@ -423,77 +423,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) };
+          controller.enqueue(new Uint8Array(result.value));
         },
-
-        releaseLock: () => {
-          released = true;
-        },
-
-        get closed() {
-          return new Promise(() => {});
-        },
-
-        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;
 })();
 `;
@@ -673,6 +675,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
@@ -835,9 +838,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
@@ -850,7 +859,8 @@ function setupResponse(context, stateMap) {
       }
       __Stream_close(newStreamId);
 
-      return HostBackedReadableStream._fromStreamId(newStreamId);
+      this.#cachedBody = HostBackedReadableStream._fromStreamId(newStreamId);
+      return this.#cachedBody;
     }
 
     async text() {
@@ -1726,6 +1736,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 });
@@ -1810,12 +1826,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() {
@@ -1930,4 +1951,4 @@ async function setupFetch(context, options) {
   };
 }
 
-//# debugId=D2829934F58098A764756E2164756E21
+//# debugId=B1E0412945057BF364756E2164756E21