@ricsam/isolate-fetch 0.1.12 → 0.1.13

package/dist/cjs/index.cjs

@@ -410,6 +410,9 @@ function setupStreamCallbacks(context, streamRegistry) {
   global.setSync("__Stream_isQueueFull", new import_isolated_vm.default.Callback((streamId) => {
     return streamRegistry.isQueueFull(streamId);
   }));
+  global.setSync("__Stream_cancel", new import_isolated_vm.default.Callback((streamId) => {
+    streamRegistry.cancel(streamId);
+  }));
   const pullRef = new import_isolated_vm.default.Reference(async (streamId) => {
     const result = await streamRegistry.pull(streamId);
     if (result.done) {
@@ -460,7 +463,7 @@ var hostBackedStreamCode = `
         async pull(controller) {
           if (closed) return;
 
-          const resultJson = __Stream_pull_ref.applySyncPromise(undefined, [streamId]);
+          const resultJson = await __Stream_pull_ref.apply(undefined, [streamId], { result: { promise: true, copy: true } });
           const result = JSON.parse(resultJson);
 
           if (result.done) {
@@ -472,7 +475,7 @@ var hostBackedStreamCode = `
         },
         cancel(reason) {
           closed = true;
-          __Stream_error(streamId, String(reason || "cancelled"));
+          __Stream_cancel(streamId);
         }
       });
 
@@ -499,7 +502,7 @@ var hostBackedStreamCode = `
   globalThis.HostBackedReadableStream = HostBackedReadableStream;
 })();
 `;
-function setupResponse(context, stateMap) {
+function setupResponse(context, stateMap, streamRegistry) {
   const global = context.global;
   global.setSync("__Response_construct", new import_isolated_vm.default.Callback((bodyBytes, status, statusText, headers) => {
     const instanceId = nextInstanceId++;
@@ -579,6 +582,10 @@ function setupResponse(context, stateMap) {
     const state = stateMap.get(instanceId);
     return state?.type ?? "default";
   }));
+  global.setSync("__Response_get_nullBody", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.nullBody ?? false;
+  }));
   global.setSync("__Response_setType", new import_isolated_vm.default.Callback((instanceId, type) => {
     const state = stateMap.get(instanceId);
     if (state) {
@@ -612,6 +619,38 @@ function setupResponse(context, stateMap) {
     if (!state) {
       throw new Error("[TypeError]Cannot clone invalid Response");
     }
+    if (state.streamId !== null) {
+      const streamId1 = streamRegistry.create();
+      const streamId2 = streamRegistry.create();
+      const origStreamId = state.streamId;
+      (async () => {
+        try {
+          while (true) {
+            const result = await streamRegistry.pull(origStreamId);
+            if (result.done) {
+              streamRegistry.close(streamId1);
+              streamRegistry.close(streamId2);
+              break;
+            }
+            streamRegistry.push(streamId1, new Uint8Array(result.value));
+            streamRegistry.push(streamId2, new Uint8Array(result.value));
+          }
+        } catch (err) {
+          streamRegistry.error(streamId1, err);
+          streamRegistry.error(streamId2, err);
+        }
+      })();
+      state.streamId = streamId1;
+      const newId2 = nextInstanceId++;
+      const newState2 = {
+        ...state,
+        streamId: streamId2,
+        body: state.body ? new Uint8Array(state.body) : null,
+        bodyUsed: false
+      };
+      stateMap.set(newId2, newState2);
+      return newId2;
+    }
     const newId = nextInstanceId++;
     const newState = {
       ...state,
@@ -838,6 +877,11 @@ function setupResponse(context, stateMap) {
     }
 
     get body() {
+      // Null-body responses (204, 304, HEAD) must return null
+      if (__Response_get_nullBody(this.#instanceId)) {
+        return null;
+      }
+
       // Return cached body if available (WHATWG spec requires same object on repeated access)
       if (this.#cachedBody !== null) {
         return this.#cachedBody;
@@ -869,6 +913,26 @@ function setupResponse(context, stateMap) {
       } catch (err) {
         throw __decodeError(err);
       }
+      if (__Response_get_nullBody(this.#instanceId)) {
+        return "";
+      }
+      if (this.#streamId !== null) {
+        const reader = this.body.getReader();
+        const chunks = [];
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value) chunks.push(value);
+        }
+        const totalLength = chunks.reduce((acc, c) => acc + c.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          result.set(chunk, offset);
+          offset += chunk.length;
+        }
+        return new TextDecoder().decode(result);
+      }
       return __Response_text(this.#instanceId);
     }
 
@@ -1119,30 +1183,10 @@ function setupRequest(context, stateMap) {
       return Array.from(new TextEncoder().encode(body.toString()));
     }
     if (body instanceof FormData) {
-      // Check if FormData has any File/Blob entries
-      let hasFiles = false;
-      for (const [, value] of body.entries()) {
-        if (value instanceof File || value instanceof Blob) {
-          hasFiles = true;
-          break;
-        }
-      }
-
-      if (hasFiles) {
-        // Serialize as multipart/form-data
-        const { body: bytes, contentType } = __serializeFormData(body);
-        globalThis.__pendingFormDataContentType = contentType;
-        return Array.from(bytes);
-      }
-
-      // URL-encoded for string-only FormData
-      const parts = [];
-      body.forEach((value, key) => {
-        if (typeof value === 'string') {
-          parts.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));
-        }
-      });
-      return Array.from(new TextEncoder().encode(parts.join('&')));
+      // Always serialize as multipart/form-data per spec
+      const { body: bytes, contentType } = __serializeFormData(body);
+      globalThis.__pendingFormDataContentType = contentType;
+      return Array.from(bytes);
     }
     // Try to convert to string
     return Array.from(new TextEncoder().encode(String(body)));
@@ -1240,7 +1284,7 @@ function setupRequest(context, stateMap) {
       if (globalThis.__pendingFormDataContentType) {
         headers.set('content-type', globalThis.__pendingFormDataContentType);
         delete globalThis.__pendingFormDataContentType;
-      } else if (body instanceof FormData && !headers.has('content-type')) {
+      } else if (body instanceof URLSearchParams && !headers.has('content-type')) {
         headers.set('content-type', 'application/x-www-form-urlencoded');
       }
 
@@ -1430,32 +1474,56 @@ function setupRequest(context, stateMap) {
 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) => {
+  const fetchAbortControllers = new Map;
+  global.setSync("__fetch_abort", new import_isolated_vm.default.Callback((fetchId) => {
+    const controller = fetchAbortControllers.get(fetchId);
+    if (controller) {
+      setImmediate(() => controller.abort());
+    }
+  }));
+  const fetchRef = new import_isolated_vm.default.Reference(async (url, method, headersJson, bodyJson, signalAborted, fetchId) => {
     if (signalAborted) {
       throw new Error("[AbortError]The operation was aborted.");
     }
+    const hostController = new AbortController;
+    fetchAbortControllers.set(fetchId, hostController);
     const headers = JSON.parse(headersJson);
     const bodyBytes = bodyJson ? JSON.parse(bodyJson) : null;
     const body = bodyBytes ? new Uint8Array(bodyBytes) : null;
     const nativeRequest = new Request(url, {
       method,
       headers,
-      body
+      body,
+      signal: hostController.signal
     });
     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 = {
+    try {
+      let cleanupAbort;
+      const abortPromise = new Promise((_, reject) => {
+        if (hostController.signal.aborted) {
+          reject(Object.assign(new Error("The operation was aborted."), { name: "AbortError" }));
+          return;
+        }
+        const onAbort = () => {
+          reject(Object.assign(new Error("The operation was aborted."), { name: "AbortError" }));
+        };
+        hostController.signal.addEventListener("abort", onAbort, { once: true });
+        cleanupAbort = () => hostController.signal.removeEventListener("abort", onAbort);
+      });
+      abortPromise.catch(() => {});
+      const nativeResponse = await Promise.race([onFetch(nativeRequest), abortPromise]);
+      cleanupAbort?.();
+      const status = nativeResponse.status;
+      const isNullBody = status === 204 || status === 304 || method.toUpperCase() === "HEAD";
+      const isCallbackStream = nativeResponse.__isCallbackStream;
+      const isNetworkResponse = nativeResponse.url && (nativeResponse.url.startsWith("http://") || nativeResponse.url.startsWith("https://"));
+      const shouldStream = !isNullBody && nativeResponse.body && (isCallbackStream || isNetworkResponse);
+      if (shouldStream && nativeResponse.body) {
+        const streamId = streamRegistry.create();
+        const streamCleanupFn = import_stream_state.startNativeStreamReader(nativeResponse.body, streamId, streamRegistry);
+        streamRegistry.setCleanup(streamId, streamCleanupFn);
+        const instanceId2 = nextInstanceId++;
+        const state2 = {
           status: nativeResponse.status,
           statusText: nativeResponse.statusText,
           headers: Array.from(nativeResponse.headers.entries()),
@@ -1464,65 +1532,37 @@ function setupFetchFunction(context, stateMap, streamRegistry, options) {
           type: "default",
           url: nativeResponse.url,
           redirected: nativeResponse.redirected,
-          streamId: streamId2
+          streamId,
+          nullBody: isNullBody
         };
-        stateMap.set(instanceId3, state3);
-        return instanceId3;
+        stateMap.set(instanceId2, state2);
+        return instanceId2;
       }
-      const streamId = streamRegistry.create();
-      const instanceId2 = nextInstanceId++;
-      const state2 = {
+      const responseBody = await nativeResponse.arrayBuffer();
+      const responseBodyArray = Array.from(new Uint8Array(responseBody));
+      const instanceId = nextInstanceId++;
+      const state = {
         status: nativeResponse.status,
         statusText: nativeResponse.statusText,
         headers: Array.from(nativeResponse.headers.entries()),
-        body: new Uint8Array(0),
+        body: new Uint8Array(responseBodyArray),
         bodyUsed: false,
         type: "default",
         url: nativeResponse.url,
         redirected: nativeResponse.redirected,
-        streamId
+        streamId: null,
+        nullBody: isNullBody
       };
-      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;
+      stateMap.set(instanceId, state);
+      return instanceId;
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error("[AbortError]The operation was aborted.");
+      }
+      throw err;
+    } finally {
+      fetchAbortControllers.delete(fetchId);
     }
-    const responseBody = await nativeResponse.arrayBuffer();
-    const responseBodyArray = Array.from(new Uint8Array(responseBody));
-    const instanceId = nextInstanceId++;
-    const state = {
-      status: nativeResponse.status,
-      statusText: nativeResponse.statusText,
-      headers: Array.from(nativeResponse.headers.entries()),
-      body: new Uint8Array(responseBodyArray),
-      bodyUsed: false,
-      type: "default",
-      url: nativeResponse.url,
-      redirected: nativeResponse.redirected,
-      streamId: null
-    };
-    stateMap.set(instanceId, state);
-    return instanceId;
   });
   global.setSync("__fetch_ref", fetchRef);
   const fetchCode = `
@@ -1540,7 +1580,28 @@ function setupFetchFunction(context, stateMap, streamRegistry, options) {
     return err;
   }
 
-  globalThis.fetch = function(input, init = {}) {
+  let __nextFetchId = 1;
+
+  globalThis.fetch = async function(input, init = {}) {
+    // Handle Blob and ReadableStream bodies before creating Request
+    if (init.body instanceof Blob && !(init.body instanceof File)) {
+      const buf = await init.body.arrayBuffer();
+      init = Object.assign({}, init, { body: new Uint8Array(buf) });
+    } else if (init.body instanceof ReadableStream) {
+      const reader = init.body.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+      const total = chunks.reduce((s, c) => s + c.length, 0);
+      const buf = new Uint8Array(total);
+      let off = 0;
+      for (const c of chunks) { buf.set(c, off); off += c.length; }
+      init = Object.assign({}, init, { body: buf });
+    }
+
     // Create Request from input
     const request = input instanceof Request ? input : new Request(input, init);
 
@@ -1548,20 +1609,34 @@ function setupFetchFunction(context, stateMap, streamRegistry, options) {
     const signal = init.signal ?? request.signal;
     const signalAborted = signal?.aborted ?? false;
 
+    // Assign a fetch ID for abort tracking
+    const fetchId = __nextFetchId++;
+
+    // Register abort listener if signal exists
+    if (signal && !signalAborted) {
+      signal.addEventListener('abort', () => { __fetch_abort(fetchId); });
+    }
+
     // Serialize headers and body to JSON for transfer
     const headersJson = JSON.stringify(Array.from(request.headers.entries()));
     const bodyBytes = request._getBodyBytes();
     const bodyJson = bodyBytes ? JSON.stringify(bodyBytes) : null;
 
+    // Short-circuit: if signal is already aborted, throw without calling host
+    if (signalAborted) {
+      throw new DOMException('The operation was aborted.', 'AbortError');
+    }
+
     // Call host - returns just the response instance ID
     try {
-      const instanceId = __fetch_ref.applySyncPromise(undefined, [
+      const instanceId = await __fetch_ref.apply(undefined, [
         request.url,
         request.method,
         headersJson,
         bodyJson,
-        signalAborted
-      ]);
+        signalAborted,
+        fetchId
+      ], { result: { promise: true, copy: true } });
 
       // Construct Response from the instance ID
       return Response._fromInstanceId(instanceId);
@@ -1678,7 +1753,7 @@ async function setupFetch(context, options) {
   context.evalSync(multipartCode);
   setupStreamCallbacks(context, streamRegistry);
   context.evalSync(hostBackedStreamCode);
-  setupResponse(context, stateMap);
+  setupResponse(context, stateMap, streamRegistry);
   setupRequest(context, stateMap);
   setupFetchFunction(context, stateMap, streamRegistry, options);
   const serveState = {
@@ -1801,8 +1876,7 @@ async function setupFetch(context, options) {
             },
             cancel() {
               streamDone = true;
-              streamRegistry.error(responseStreamId, new Error("Stream cancelled"));
-              streamRegistry.delete(responseStreamId);
+              streamRegistry.cancel(responseStreamId);
             }
           });
           const responseHeaders2 = new Headers(responseState.headers);
@@ -1951,4 +2025,4 @@ async function setupFetch(context, options) {
   };
 }
 
-//# debugId=B1E0412945057BF364756E2164756E21
+//# debugId=E8993FE5C4E862A664756E2164756E21