@ricsam/isolate-fetch 0.1.1 → 0.1.3

package/{src/index.ts → dist/mjs/index.mjs}

@@ -1,121 +1,22 @@
+// @bun
+// packages/fetch/src/index.ts
 import ivm from "isolated-vm";
 import { setupCore, clearAllInstanceState } from "@ricsam/isolate-core";
 import {
   getStreamRegistryForContext,
-  startNativeStreamReader,
-} from "./stream-state.ts";
-import type { StreamStateRegistry } from "./stream-state.ts";
-
-export { clearAllInstanceState };
-
-export interface FetchOptions {
-  /** Handler for fetch requests from the isolate */
-  onFetch?: (request: Request) => Promise<Response>;
-}
-
-// ============================================================================
-// Serve Types
-// ============================================================================
-
-export interface UpgradeRequest {
-  requested: true;
-  connectionId: string;
-}
-
-export interface WebSocketCommand {
-  type: "message" | "close";
-  connectionId: string;
-  data?: string | ArrayBuffer;
-  code?: number;
-  reason?: string;
-}
-
-interface ServeState {
-  pendingUpgrade: UpgradeRequest | null;
-  activeConnections: Map<string, { connectionId: string }>;
-}
-
-export interface DispatchRequestOptions {
-  /** Tick function to pump isolate timers - required for streaming responses */
-  tick?: () => Promise<void>;
-}
-
-export interface FetchHandle {
-  dispose(): void;
-  /** Dispatch an HTTP request to the isolate's serve() handler */
-  dispatchRequest(request: Request, options?: DispatchRequestOptions): Promise<Response>;
-  /** Check if isolate requested WebSocket upgrade */
-  getUpgradeRequest(): UpgradeRequest | null;
-  /** Dispatch WebSocket open event to isolate */
-  dispatchWebSocketOpen(connectionId: string): void;
-  /** Dispatch WebSocket message event to isolate */
-  dispatchWebSocketMessage(connectionId: string, message: string | ArrayBuffer): void;
-  /** Dispatch WebSocket close event to isolate */
-  dispatchWebSocketClose(connectionId: string, code: number, reason: string): void;
-  /** Dispatch WebSocket error event to isolate */
-  dispatchWebSocketError(connectionId: string, error: Error): void;
-  /** Register callback for WebSocket commands from isolate */
-  onWebSocketCommand(callback: (cmd: WebSocketCommand) => void): () => void;
-  /** Check if serve() has been called */
-  hasServeHandler(): boolean;
-  /** Check if there are active WebSocket connections */
-  hasActiveConnections(): boolean;
-}
-
-// ============================================================================
-// Instance State Management
-// ============================================================================
-
-const instanceStateMap = new WeakMap<ivm.Context, Map<number, unknown>>();
-let nextInstanceId = 1;
-
-function getInstanceStateMapForContext(
-  context: ivm.Context
-): Map<number, unknown> {
+  startNativeStreamReader
+} from "./stream-state.mjs";
+var instanceStateMap = new WeakMap;
+var nextInstanceId = 1;
+function getInstanceStateMapForContext(context) {
   let map = instanceStateMap.get(context);
   if (!map) {
-    map = new Map();
+    map = new Map;
     instanceStateMap.set(context, map);
   }
   return map;
 }
-
-// ============================================================================
-// State Types
-// ============================================================================
-
-interface ResponseState {
-  status: number;
-  statusText: string;
-  headers: [string, string][];
-  body: Uint8Array | null;
-  bodyUsed: boolean;
-  type: string;
-  url: string;
-  redirected: boolean;
-  streamId: number | null;
-}
-
-interface RequestState {
-  method: string;
-  url: string;
-  headers: [string, string][];
-  body: Uint8Array | null;
-  bodyUsed: boolean;
-  streamId: number | null;
-  mode: string;
-  credentials: string;
-  cache: string;
-  redirect: string;
-  referrer: string;
-  integrity: string;
-}
-
-// ============================================================================
-// Headers Implementation (Pure JS)
-// ============================================================================
-
-const headersCode = `
+var headersCode = `
 (function() {
   class Headers {
     #headers = new Map(); // lowercase key -> [originalCase, values[]]
@@ -202,12 +103,7 @@ const headersCode = `
   globalThis.Headers = Headers;
 })();
 `;
-
-// ============================================================================
-// FormData Implementation (Pure JS)
-// ============================================================================
-
-const formDataCode = `
+var formDataCode = `
 (function() {
   class FormData {
     #entries = []; // Array of [name, value]
@@ -285,12 +181,7 @@ const formDataCode = `
   globalThis.FormData = FormData;
 })();
 `;
-
-// ============================================================================
-// Multipart FormData Parsing/Serialization (Pure JS)
-// ============================================================================
-
-const multipartCode = `
+var multipartCode = `
 (function() {
   // Find byte sequence in Uint8Array
   function findSequence(haystack, needle, start = 0) {
@@ -449,60 +340,25 @@ const multipartCode = `
   };
 })();
 `;
-
-// ============================================================================
-// Stream Callbacks (Host State)
-// ============================================================================
-
-function setupStreamCallbacks(
-  context: ivm.Context,
-  streamRegistry: StreamStateRegistry
-): void {
+function setupStreamCallbacks(context, streamRegistry) {
   const global = context.global;
-
-  // Create stream (returns ID)
-  global.setSync(
-    "__Stream_create",
-    new ivm.Callback(() => {
-      return streamRegistry.create();
-    })
-  );
-
-  // Push chunk (sync) - receives number[] from isolate
-  global.setSync(
-    "__Stream_push",
-    new ivm.Callback((streamId: number, chunkArray: number[]) => {
-      const chunk = new Uint8Array(chunkArray);
-      return streamRegistry.push(streamId, chunk);
-    })
-  );
-
-  // Close stream (sync)
-  global.setSync(
-    "__Stream_close",
-    new ivm.Callback((streamId: number) => {
-      streamRegistry.close(streamId);
-    })
-  );
-
-  // Error stream (sync)
-  global.setSync(
-    "__Stream_error",
-    new ivm.Callback((streamId: number, message: string) => {
-      streamRegistry.error(streamId, new Error(message));
-    })
-  );
-
-  // Check backpressure (sync)
-  global.setSync(
-    "__Stream_isQueueFull",
-    new ivm.Callback((streamId: number) => {
-      return streamRegistry.isQueueFull(streamId);
-    })
-  );
-
-  // Pull chunk (async with applySyncPromise)
-  const pullRef = new ivm.Reference(async (streamId: number) => {
+  global.setSync("__Stream_create", new ivm.Callback(() => {
+    return streamRegistry.create();
+  }));
+  global.setSync("__Stream_push", new ivm.Callback((streamId, chunkArray) => {
+    const chunk = new Uint8Array(chunkArray);
+    return streamRegistry.push(streamId, chunk);
+  }));
+  global.setSync("__Stream_close", new ivm.Callback((streamId) => {
+    streamRegistry.close(streamId);
+  }));
+  global.setSync("__Stream_error", new ivm.Callback((streamId, message) => {
+    streamRegistry.error(streamId, new Error(message));
+  }));
+  global.setSync("__Stream_isQueueFull", new ivm.Callback((streamId) => {
+    return streamRegistry.isQueueFull(streamId);
+  }));
+  const pullRef = new ivm.Reference(async (streamId) => {
     const result = await streamRegistry.pull(streamId);
     if (result.done) {
       return JSON.stringify({ done: true });
@@ -511,12 +367,7 @@ function setupStreamCallbacks(
   });
   global.setSync("__Stream_pull_ref", pullRef);
 }
-
-// ============================================================================
-// Host-Backed ReadableStream (Isolate Code)
-// ============================================================================
-
-const hostBackedStreamCode = `
+var hostBackedStreamCode = `
 (function() {
   const _streamIds = new WeakMap();
 
@@ -581,233 +432,132 @@ const hostBackedStreamCode = `
   globalThis.HostBackedReadableStream = HostBackedReadableStream;
 })();
 `;
-
-// ============================================================================
-// Response Implementation (Host State + Isolate Class)
-// ============================================================================
-
-function setupResponse(
-  context: ivm.Context,
-  stateMap: Map<number, unknown>
-): void {
+function setupResponse(context, stateMap) {
   const global = context.global;
-
-  // Register host callbacks
-  global.setSync(
-    "__Response_construct",
-    new ivm.Callback(
-      (
-        bodyBytes: number[] | null,
-        status: number,
-        statusText: string,
-        headers: [string, string][]
-      ) => {
-        const instanceId = nextInstanceId++;
-        const body = bodyBytes ? new Uint8Array(bodyBytes) : null;
-        const state: ResponseState = {
-          status,
-          statusText,
-          headers,
-          body,
-          bodyUsed: false,
-          type: "default",
-          url: "",
-          redirected: false,
-          streamId: null,
-        };
-        stateMap.set(instanceId, state);
-        return instanceId;
-      }
-    )
-  );
-
-  // Streaming Response constructor - creates Response with stream ID but no buffered body
-  global.setSync(
-    "__Response_constructStreaming",
-    new ivm.Callback(
-      (
-        streamId: number,
-        status: number,
-        statusText: string,
-        headers: [string, string][]
-      ) => {
-        const instanceId = nextInstanceId++;
-        const state: ResponseState = {
-          status,
-          statusText,
-          headers,
-          body: null, // No buffered body - using stream
-          bodyUsed: false,
-          type: "default",
-          url: "",
-          redirected: false,
-          streamId, // Stream ID for body
-        };
-        stateMap.set(instanceId, state);
-        return instanceId;
-      }
-    )
-  );
-
-  global.setSync(
-    "__Response_constructFromFetch",
-    new ivm.Callback(
-      (
-        bodyBytes: number[] | null,
-        status: number,
-        statusText: string,
-        headers: [string, string][],
-        url: string,
-        redirected: boolean
-      ) => {
-        const instanceId = nextInstanceId++;
-        const body = bodyBytes ? new Uint8Array(bodyBytes) : null;
-        const state: ResponseState = {
-          status,
-          statusText,
-          headers,
-          body,
-          bodyUsed: false,
-          type: "default",
-          url,
-          redirected,
-          streamId: null,
-        };
-        stateMap.set(instanceId, state);
-        return instanceId;
-      }
-    )
-  );
-
-  global.setSync(
-    "__Response_get_status",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      return state?.status ?? 200;
-    })
-  );
-
-  global.setSync(
-    "__Response_get_statusText",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      return state?.statusText ?? "";
-    })
-  );
-
-  global.setSync(
-    "__Response_get_headers",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      return state?.headers ?? [];
-    })
-  );
-
-  global.setSync(
-    "__Response_get_bodyUsed",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      return state?.bodyUsed ?? false;
-    })
-  );
-
-  global.setSync(
-    "__Response_get_url",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      return state?.url ?? "";
-    })
-  );
-
-  global.setSync(
-    "__Response_get_redirected",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      return state?.redirected ?? false;
-    })
-  );
-
-  global.setSync(
-    "__Response_get_type",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      return state?.type ?? "default";
-    })
-  );
-
-  global.setSync(
-    "__Response_setType",
-    new ivm.Callback((instanceId: number, type: string) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      if (state) {
-        state.type = type;
-      }
-    })
-  );
-
-  global.setSync(
-    "__Response_markBodyUsed",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      if (state) {
-        if (state.bodyUsed) {
-          throw new Error("[TypeError]Body has already been consumed");
-        }
-        state.bodyUsed = true;
-      }
-    })
-  );
-
-  global.setSync(
-    "__Response_text",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      if (!state || !state.body) return "";
-      return new TextDecoder().decode(state.body);
-    })
-  );
-
-  global.setSync(
-    "__Response_arrayBuffer",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      if (!state || !state.body) {
-        return new ivm.ExternalCopy(new ArrayBuffer(0)).copyInto();
-      }
-      return new ivm.ExternalCopy(state.body.buffer.slice(
-        state.body.byteOffset,
-        state.body.byteOffset + state.body.byteLength
-      )).copyInto();
-    })
-  );
-
-  global.setSync(
-    "__Response_clone",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      if (!state) {
-        throw new Error("[TypeError]Cannot clone invalid Response");
-      }
-      const newId = nextInstanceId++;
-      const newState: ResponseState = {
-        ...state,
-        body: state.body ? new Uint8Array(state.body) : null,
-        bodyUsed: false,
-      };
-      stateMap.set(newId, newState);
-      return newId;
-    })
-  );
-
-  global.setSync(
-    "__Response_getStreamId",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as ResponseState | undefined;
-      return state?.streamId ?? null;
-    })
-  );
-
-  // Inject Response class
+  global.setSync("__Response_construct", new ivm.Callback((bodyBytes, status, statusText, headers) => {
+    const instanceId = nextInstanceId++;
+    const body = bodyBytes ? new Uint8Array(bodyBytes) : null;
+    const state = {
+      status,
+      statusText,
+      headers,
+      body,
+      bodyUsed: false,
+      type: "default",
+      url: "",
+      redirected: false,
+      streamId: null
+    };
+    stateMap.set(instanceId, state);
+    return instanceId;
+  }));
+  global.setSync("__Response_constructStreaming", new ivm.Callback((streamId, status, statusText, headers) => {
+    const instanceId = nextInstanceId++;
+    const state = {
+      status,
+      statusText,
+      headers,
+      body: null,
+      bodyUsed: false,
+      type: "default",
+      url: "",
+      redirected: false,
+      streamId
+    };
+    stateMap.set(instanceId, state);
+    return instanceId;
+  }));
+  global.setSync("__Response_constructFromFetch", new ivm.Callback((bodyBytes, status, statusText, headers, url, redirected) => {
+    const instanceId = nextInstanceId++;
+    const body = bodyBytes ? new Uint8Array(bodyBytes) : null;
+    const state = {
+      status,
+      statusText,
+      headers,
+      body,
+      bodyUsed: false,
+      type: "default",
+      url,
+      redirected,
+      streamId: null
+    };
+    stateMap.set(instanceId, state);
+    return instanceId;
+  }));
+  global.setSync("__Response_get_status", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.status ?? 200;
+  }));
+  global.setSync("__Response_get_statusText", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.statusText ?? "";
+  }));
+  global.setSync("__Response_get_headers", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.headers ?? [];
+  }));
+  global.setSync("__Response_get_bodyUsed", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.bodyUsed ?? false;
+  }));
+  global.setSync("__Response_get_url", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.url ?? "";
+  }));
+  global.setSync("__Response_get_redirected", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.redirected ?? false;
+  }));
+  global.setSync("__Response_get_type", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.type ?? "default";
+  }));
+  global.setSync("__Response_setType", new ivm.Callback((instanceId, type) => {
+    const state = stateMap.get(instanceId);
+    if (state) {
+      state.type = type;
+    }
+  }));
+  global.setSync("__Response_markBodyUsed", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (state) {
+      if (state.bodyUsed) {
+        throw new Error("[TypeError]Body has already been consumed");
+      }
+      state.bodyUsed = true;
+    }
+  }));
+  global.setSync("__Response_text", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body)
+      return "";
+    return new TextDecoder().decode(state.body);
+  }));
+  global.setSync("__Response_arrayBuffer", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body) {
+      return new ivm.ExternalCopy(new ArrayBuffer(0)).copyInto();
+    }
+    return new ivm.ExternalCopy(state.body.buffer.slice(state.body.byteOffset, state.body.byteOffset + state.body.byteLength)).copyInto();
+  }));
+  global.setSync("__Response_clone", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[TypeError]Cannot clone invalid Response");
+    }
+    const newId = nextInstanceId++;
+    const newState = {
+      ...state,
+      body: state.body ? new Uint8Array(state.body) : null,
+      bodyUsed: false
+    };
+    stateMap.set(newId, newState);
+    return newId;
+  }));
+  global.setSync("__Response_getStreamId", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.streamId ?? null;
+  }));
   const responseCode = `
 (function() {
   const _responseInstanceIds = new WeakMap();
@@ -1129,210 +879,116 @@ function setupResponse(
   globalThis.Response = Response;
 })();
 `;
-
   context.evalSync(responseCode);
 }
-
-// ============================================================================
-// Request Implementation (Host State + Isolate Class)
-// ============================================================================
-
-function setupRequest(
-  context: ivm.Context,
-  stateMap: Map<number, unknown>
-): void {
+function setupRequest(context, stateMap) {
   const global = context.global;
-
-  // Register host callbacks
-  global.setSync(
-    "__Request_construct",
-    new ivm.Callback(
-      (
-        url: string,
-        method: string,
-        headers: [string, string][],
-        bodyBytes: number[] | null,
-        mode: string,
-        credentials: string,
-        cache: string,
-        redirect: string,
-        referrer: string,
-        integrity: string
-      ) => {
-        const instanceId = nextInstanceId++;
-        const body = bodyBytes ? new Uint8Array(bodyBytes) : null;
-        const state: RequestState = {
-          url,
-          method,
-          headers,
-          body,
-          bodyUsed: false,
-          streamId: null,
-          mode,
-          credentials,
-          cache,
-          redirect,
-          referrer,
-          integrity,
-        };
-        stateMap.set(instanceId, state);
-        return instanceId;
-      }
-    )
-  );
-
-  global.setSync(
-    "__Request_get_method",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.method ?? "GET";
-    })
-  );
-
-  global.setSync(
-    "__Request_get_url",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.url ?? "";
-    })
-  );
-
-  global.setSync(
-    "__Request_get_headers",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.headers ?? [];
-    })
-  );
-
-  global.setSync(
-    "__Request_get_bodyUsed",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.bodyUsed ?? false;
-    })
-  );
-
-  global.setSync(
-    "__Request_get_mode",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.mode ?? "cors";
-    })
-  );
-
-  global.setSync(
-    "__Request_get_credentials",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.credentials ?? "same-origin";
-    })
-  );
-
-  global.setSync(
-    "__Request_get_cache",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.cache ?? "default";
-    })
-  );
-
-  global.setSync(
-    "__Request_get_redirect",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.redirect ?? "follow";
-    })
-  );
-
-  global.setSync(
-    "__Request_get_referrer",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.referrer ?? "about:client";
-    })
-  );
-
-  global.setSync(
-    "__Request_get_integrity",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.integrity ?? "";
-    })
-  );
-
-  global.setSync(
-    "__Request_markBodyUsed",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      if (state) {
-        if (state.bodyUsed) {
-          throw new Error("[TypeError]Body has already been consumed");
-        }
-        state.bodyUsed = true;
-      }
-    })
-  );
-
-  global.setSync(
-    "__Request_text",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      if (!state || !state.body) return "";
-      return new TextDecoder().decode(state.body);
-    })
-  );
-
-  global.setSync(
-    "__Request_arrayBuffer",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      if (!state || !state.body) {
-        return new ivm.ExternalCopy(new ArrayBuffer(0)).copyInto();
-      }
-      return new ivm.ExternalCopy(state.body.buffer.slice(
-        state.body.byteOffset,
-        state.body.byteOffset + state.body.byteLength
-      )).copyInto();
-    })
-  );
-
-  global.setSync(
-    "__Request_getBodyBytes",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      if (!state || !state.body) return null;
-      return Array.from(state.body);
-    })
-  );
-
-  global.setSync(
-    "__Request_clone",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      if (!state) {
-        throw new Error("[TypeError]Cannot clone invalid Request");
-      }
-      const newId = nextInstanceId++;
-      const newState: RequestState = {
-        ...state,
-        body: state.body ? new Uint8Array(state.body) : null,
-        bodyUsed: false,
-      };
-      stateMap.set(newId, newState);
-      return newId;
-    })
-  );
-
-  global.setSync(
-    "__Request_getStreamId",
-    new ivm.Callback((instanceId: number) => {
-      const state = stateMap.get(instanceId) as RequestState | undefined;
-      return state?.streamId ?? null;
-    })
-  );
-
-  // Inject Request class
+  global.setSync("__Request_construct", new ivm.Callback((url, method, headers, bodyBytes, mode, credentials, cache, redirect, referrer, integrity) => {
+    const instanceId = nextInstanceId++;
+    const body = bodyBytes ? new Uint8Array(bodyBytes) : null;
+    const state = {
+      url,
+      method,
+      headers,
+      body,
+      bodyUsed: false,
+      streamId: null,
+      mode,
+      credentials,
+      cache,
+      redirect,
+      referrer,
+      integrity
+    };
+    stateMap.set(instanceId, state);
+    return instanceId;
+  }));
+  global.setSync("__Request_get_method", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.method ?? "GET";
+  }));
+  global.setSync("__Request_get_url", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.url ?? "";
+  }));
+  global.setSync("__Request_get_headers", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.headers ?? [];
+  }));
+  global.setSync("__Request_get_bodyUsed", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.bodyUsed ?? false;
+  }));
+  global.setSync("__Request_get_mode", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.mode ?? "cors";
+  }));
+  global.setSync("__Request_get_credentials", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.credentials ?? "same-origin";
+  }));
+  global.setSync("__Request_get_cache", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.cache ?? "default";
+  }));
+  global.setSync("__Request_get_redirect", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.redirect ?? "follow";
+  }));
+  global.setSync("__Request_get_referrer", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.referrer ?? "about:client";
+  }));
+  global.setSync("__Request_get_integrity", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.integrity ?? "";
+  }));
+  global.setSync("__Request_markBodyUsed", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (state) {
+      if (state.bodyUsed) {
+        throw new Error("[TypeError]Body has already been consumed");
+      }
+      state.bodyUsed = true;
+    }
+  }));
+  global.setSync("__Request_text", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body)
+      return "";
+    return new TextDecoder().decode(state.body);
+  }));
+  global.setSync("__Request_arrayBuffer", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body) {
+      return new ivm.ExternalCopy(new ArrayBuffer(0)).copyInto();
+    }
+    return new ivm.ExternalCopy(state.body.buffer.slice(state.body.byteOffset, state.body.byteOffset + state.body.byteLength)).copyInto();
+  }));
+  global.setSync("__Request_getBodyBytes", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body)
+      return null;
+    return Array.from(state.body);
+  }));
+  global.setSync("__Request_clone", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state) {
+      throw new Error("[TypeError]Cannot clone invalid Request");
+    }
+    const newId = nextInstanceId++;
+    const newState = {
+      ...state,
+      body: state.body ? new Uint8Array(state.body) : null,
+      bodyUsed: false
+    };
+    stateMap.set(newId, newState);
+    return newId;
+  }));
+  global.setSync("__Request_getStreamId", new ivm.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.streamId ?? null;
+  }));
   const requestCode = `
 (function() {
   function __decodeError(err) {
@@ -1661,79 +1317,42 @@ function setupRequest(
   globalThis.Request = Request;
 })();
 `;
-
   context.evalSync(requestCode);
 }
-
-// ============================================================================
-// fetch Implementation
-// ============================================================================
-
-function setupFetchFunction(
-  context: ivm.Context,
-  stateMap: Map<number, unknown>,
-  options?: FetchOptions
-): void {
+function setupFetchFunction(context, stateMap, options) {
   const global = context.global;
-
-  // Create async fetch reference
-  // We use JSON serialization for complex data to avoid transfer issues
-  const fetchRef = new ivm.Reference(
-    async (
-      url: string,
-      method: string,
-      headersJson: string,
-      bodyJson: string | null,
-      signalAborted: boolean
-    ) => {
-      // Check if already aborted
-      if (signalAborted) {
-        throw new Error("[AbortError]The operation was aborted.");
-      }
-
-      // Parse headers and body from JSON
-      const headers = JSON.parse(headersJson) as [string, string][];
-      const bodyBytes = bodyJson ? JSON.parse(bodyJson) as number[] : null;
-
-      // Construct native Request
-      const body = bodyBytes ? new Uint8Array(bodyBytes) : null;
-      const nativeRequest = new Request(url, {
-        method,
-        headers,
-        body,
-      });
-
-      // Call user's onFetch handler or default fetch
-      const onFetch = options?.onFetch ?? fetch;
-      const nativeResponse = await onFetch(nativeRequest);
-
-      // Read response body
-      const responseBody = await nativeResponse.arrayBuffer();
-      const responseBodyArray = Array.from(new Uint8Array(responseBody));
-
-      // Store the response in the state map and return just the ID + metadata
-      const instanceId = nextInstanceId++;
-      const state: ResponseState = {
-        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 only the instance ID - avoid complex object transfer
-      return instanceId;
-    }
-  );
-
+  const fetchRef = new ivm.Reference(async (url, method, headersJson, bodyJson, signalAborted) => {
+    if (signalAborted) {
+      throw new Error("[AbortError]The operation was aborted.");
+    }
+    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
+    });
+    const onFetch = options?.onFetch ?? fetch;
+    const nativeResponse = await onFetch(nativeRequest);
+    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);
-
-  // Inject fetch function
   const fetchCode = `
 (function() {
   function __decodeError(err) {
@@ -1780,35 +1399,17 @@ function setupFetchFunction(
   };
 })();
 `;
-
   context.evalSync(fetchCode);
 }
-
-// ============================================================================
-// Server Implementation (for serve())
-// ============================================================================
-
-function setupServer(
-  context: ivm.Context,
-  serveState: ServeState
-): void {
+function setupServer(context, serveState) {
   const global = context.global;
-
-  // Setup upgrade registry in isolate (data stays in isolate, never marshalled to host)
   context.evalSync(`
     globalThis.__upgradeRegistry__ = new Map();
     globalThis.__upgradeIdCounter__ = 0;
   `);
-
-  // Host callback to notify about pending upgrade
-  global.setSync(
-    "__setPendingUpgrade__",
-    new ivm.Callback((connectionId: string) => {
-      serveState.pendingUpgrade = { requested: true, connectionId };
-    })
-  );
-
-  // Pure JS Server class with upgrade method
+  global.setSync("__setPendingUpgrade__", new ivm.Callback((connectionId) => {
+    serveState.pendingUpgrade = { requested: true, connectionId };
+  }));
   context.evalSync(`
 (function() {
   class Server {
@@ -1824,36 +1425,18 @@ function setupServer(
 })();
   `);
 }
-
-// ============================================================================
-// ServerWebSocket Implementation (for serve())
-// ============================================================================
-
-function setupServerWebSocket(
-  context: ivm.Context,
-  wsCommandCallbacks: Set<(cmd: WebSocketCommand) => void>
-): void {
+function setupServerWebSocket(context, wsCommandCallbacks) {
   const global = context.global;
-
-  // Host callback for ws.send()
-  global.setSync(
-    "__ServerWebSocket_send",
-    new ivm.Callback((connectionId: string, data: string) => {
-      const cmd: WebSocketCommand = { type: "message", connectionId, data };
-      for (const cb of wsCommandCallbacks) cb(cmd);
-    })
-  );
-
-  // Host callback for ws.close()
-  global.setSync(
-    "__ServerWebSocket_close",
-    new ivm.Callback((connectionId: string, code?: number, reason?: string) => {
-      const cmd: WebSocketCommand = { type: "close", connectionId, code, reason };
-      for (const cb of wsCommandCallbacks) cb(cmd);
-    })
-  );
-
-  // Pure JS ServerWebSocket class
+  global.setSync("__ServerWebSocket_send", new ivm.Callback((connectionId, data) => {
+    const cmd = { type: "message", connectionId, data };
+    for (const cb of wsCommandCallbacks)
+      cb(cmd);
+  }));
+  global.setSync("__ServerWebSocket_close", new ivm.Callback((connectionId, code, reason) => {
+    const cmd = { type: "close", connectionId, code, reason };
+    for (const cb of wsCommandCallbacks)
+      cb(cmd);
+  }));
   context.evalSync(`
 (function() {
   const _wsInstanceData = new WeakMap();
@@ -1901,13 +1484,7 @@ function setupServerWebSocket(
 })();
   `);
 }
-
-// ============================================================================
-// serve() Function Implementation
-// ============================================================================
-
-function setupServe(context: ivm.Context): void {
-  // Pure JS serve() that stores options on __serveOptions__ global
+function setupServe(context) {
   context.evalSync(`
 (function() {
   globalThis.__serveOptions__ = null;
@@ -1920,136 +1497,58 @@ function setupServe(context: ivm.Context): void {
 })();
   `);
 }
-
-// ============================================================================
-// Main Setup Function
-// ============================================================================
-
-/**
- * Setup Fetch API in an isolated-vm context
- *
- * Injects fetch, Request, Response, Headers, FormData
- * Also sets up core APIs (Blob, File, AbortController, etc.) if not already present
- *
- * @example
- * const handle = await setupFetch(context, {
- *   onFetch: async (request) => {
- *     // Proxy fetch requests to the host
- *     return fetch(request);
- *   }
- * });
- *
- * await context.eval(`
- *   const response = await fetch("https://example.com");
- *   const text = await response.text();
- * `);
- */
-export async function setupFetch(
-  context: ivm.Context,
-  options?: FetchOptions
-): Promise<FetchHandle> {
-  // Setup core APIs first (Blob, File, AbortController, Streams, etc.)
+async function setupFetch(context, options) {
   await setupCore(context);
-
   const stateMap = getInstanceStateMapForContext(context);
   const streamRegistry = getStreamRegistryForContext(context);
-
-  // Inject Headers (pure JS)
   context.evalSync(headersCode);
-
-  // Inject FormData (pure JS)
   context.evalSync(formDataCode);
-
-  // Inject multipart parsing/serialization (pure JS)
   context.evalSync(multipartCode);
-
-  // Setup stream callbacks and inject HostBackedReadableStream
   setupStreamCallbacks(context, streamRegistry);
   context.evalSync(hostBackedStreamCode);
-
-  // Setup Response (host state + isolate class)
   setupResponse(context, stateMap);
-
-  // Setup Request (host state + isolate class)
   setupRequest(context, stateMap);
-
-  // Setup fetch function
   setupFetchFunction(context, stateMap, options);
-
-  // Setup serve state
-  const serveState: ServeState = {
+  const serveState = {
     pendingUpgrade: null,
-    activeConnections: new Map(),
+    activeConnections: new Map
   };
-
-  // Setup WebSocket command callbacks
-  const wsCommandCallbacks = new Set<(cmd: WebSocketCommand) => void>();
-
-  // Setup Server class
+  const wsCommandCallbacks = new Set;
   setupServer(context, serveState);
-
-  // Setup ServerWebSocket class
   setupServerWebSocket(context, wsCommandCallbacks);
-
-  // Setup serve function
   setupServe(context);
-
   return {
     dispose() {
-      // Clear state for this context
       stateMap.clear();
-      // Clear upgrade registry
       context.evalSync(`globalThis.__upgradeRegistry__.clear()`);
-      // Clear serve state
       serveState.activeConnections.clear();
       serveState.pendingUpgrade = null;
     },
-
-    async dispatchRequest(
-      request: Request,
-      dispatchOptions?: DispatchRequestOptions
-    ): Promise<Response> {
+    async dispatchRequest(request, dispatchOptions) {
       const tick = dispatchOptions?.tick;
-
-      // Clean up previous pending upgrade if not consumed
       if (serveState.pendingUpgrade) {
         const oldConnectionId = serveState.pendingUpgrade.connectionId;
         context.evalSync(`globalThis.__upgradeRegistry__.delete("${oldConnectionId}")`);
         serveState.pendingUpgrade = null;
       }
-
-      // Check if serve handler exists
       const hasHandler = context.evalSync(`!!globalThis.__serveOptions__?.fetch`);
       if (!hasHandler) {
         throw new Error("No serve() handler registered");
       }
-
-      // Setup streaming for request body
-      let requestStreamId: number | null = null;
-      let streamCleanup: (() => Promise<void>) | null = null;
-
+      let requestStreamId = null;
+      let streamCleanup = null;
       if (request.body) {
-        // Create a stream in the registry for the request body
         requestStreamId = streamRegistry.create();
-
-        // Start background reader that pushes from native stream to host queue
-        streamCleanup = startNativeStreamReader(
-          request.body,
-          requestStreamId,
-          streamRegistry
-        );
+        streamCleanup = startNativeStreamReader(request.body, requestStreamId, streamRegistry);
       }
-
       try {
         const headersArray = Array.from(request.headers.entries());
-
-        // Create Request instance in isolate
         const requestInstanceId = nextInstanceId++;
-        const requestState: RequestState = {
+        const requestState = {
           url: request.url,
           method: request.method,
           headers: headersArray,
-          body: null, // No buffered body - using stream
+          body: null,
           bodyUsed: false,
           streamId: requestStreamId,
           mode: request.mode,
@@ -2057,12 +1556,9 @@ export async function setupFetch(
           cache: request.cache,
           redirect: request.redirect,
           referrer: request.referrer,
-          integrity: request.integrity,
+          integrity: request.integrity
         };
         stateMap.set(requestInstanceId, requestState);
-
-        // Call the fetch handler and get response
-        // We use eval with promise: true to handle async handlers
         const responseInstanceId = await context.eval(`
           (async function() {
             const request = Request._fromInstanceId(${requestInstanceId});
@@ -2071,46 +1567,32 @@ export async function setupFetch(
             return response._getInstanceId();
           })()
         `, { promise: true });
-
-        // Get ResponseState from the instance
-        const responseState = stateMap.get(responseInstanceId) as ResponseState | undefined;
+        const responseState = stateMap.get(responseInstanceId);
         if (!responseState) {
           throw new Error("Response state not found");
         }
-
-        // Check if response has streaming body
         if (responseState.streamId !== null) {
           const responseStreamId = responseState.streamId;
           let streamDone = false;
-
-          // Create native stream that pumps isolate timers while waiting
-          const pumpedStream = new ReadableStream<Uint8Array>({
+          const pumpedStream = new ReadableStream({
             async pull(controller) {
-              if (streamDone) return;
-
-              // Pump isolate timers to allow stream pump to progress
+              if (streamDone)
+                return;
               while (!streamDone) {
                 if (tick) {
                   await tick();
                 }
-
-                // Check if data is available
                 const state = streamRegistry.get(responseStreamId);
                 if (!state) {
                   controller.close();
                   streamDone = true;
                   return;
                 }
-
-                // If queue has data or stream is done, break and pull
                 if (state.queue.length > 0 || state.closed || state.errored) {
                   break;
                 }
-
-                // Small delay to avoid busy-waiting
                 await new Promise((r) => setTimeout(r, 1));
               }
-
               try {
                 const result = await streamRegistry.pull(responseStreamId);
                 if (result.done) {
@@ -2128,79 +1610,50 @@ export async function setupFetch(
             },
             cancel() {
               streamDone = true;
-              streamRegistry.error(
-                responseStreamId,
-                new Error("Stream cancelled")
-              );
+              streamRegistry.error(responseStreamId, new Error("Stream cancelled"));
               streamRegistry.delete(responseStreamId);
-            },
+            }
           });
-
-          const responseHeaders = new Headers(responseState.headers);
-          const status =
-            responseState.status === 101 ? 200 : responseState.status;
-          const response = new Response(pumpedStream, {
-            status,
+          const responseHeaders2 = new Headers(responseState.headers);
+          const status2 = responseState.status === 101 ? 200 : responseState.status;
+          const response2 = new Response(pumpedStream, {
+            status: status2,
             statusText: responseState.statusText,
-            headers: responseHeaders,
+            headers: responseHeaders2
           });
-
-          // @ts-expect-error - adding custom property
-          response._originalStatus = responseState.status;
-
-          return response;
+          response2._originalStatus = responseState.status;
+          return response2;
         }
-
-        // Convert to native Response (non-streaming)
         const responseHeaders = new Headers(responseState.headers);
         const responseBody = responseState.body;
-
-        // Note: Status 101 (Switching Protocols) is not valid for Response constructor
-        // We use 200 as the status but preserve the actual status in a custom header
-        // The caller should check getUpgradeRequest() for WebSocket upgrades
         const status = responseState.status === 101 ? 200 : responseState.status;
-        const response = new Response(responseBody as ConstructorParameters<typeof Response>[0], {
+        const response = new Response(responseBody, {
           status,
           statusText: responseState.statusText,
-          headers: responseHeaders,
+          headers: responseHeaders
         });
-
-        // Expose the original status via a property for callers to check
-        // @ts-expect-error - adding custom property
         response._originalStatus = responseState.status;
-
         return response;
       } finally {
-        // Cleanup: cancel stream reader if still running
         if (streamCleanup) {
           await streamCleanup();
         }
-        // Delete stream from registry
         if (requestStreamId !== null) {
           streamRegistry.delete(requestStreamId);
         }
       }
     },
-
-    getUpgradeRequest(): UpgradeRequest | null {
+    getUpgradeRequest() {
       const result = serveState.pendingUpgrade;
-      // Don't clear yet - it will be cleared on next dispatchRequest or consumed by dispatchWebSocketOpen
       return result;
     },
-
-    dispatchWebSocketOpen(connectionId: string): void {
-      // Check if websocket.open handler exists - required for connection tracking
+    dispatchWebSocketOpen(connectionId) {
       const hasOpenHandler = context.evalSync(`!!globalThis.__serveOptions__?.websocket?.open`);
       if (!hasOpenHandler) {
-        // Delete from registry and return - connection NOT tracked
         context.evalSync(`globalThis.__upgradeRegistry__.delete("${connectionId}")`);
         return;
       }
-
-      // Store connection (data stays in isolate registry)
       serveState.activeConnections.set(connectionId, { connectionId });
-
-      // Create ServerWebSocket and call open handler
       context.evalSync(`
         (function() {
           const ws = new __ServerWebSocket__("${connectionId}");
@@ -2208,35 +1661,26 @@ export async function setupFetch(
           __serveOptions__.websocket.open(ws);
         })()
       `);
-
-      // Clear pending upgrade after successful open
       if (serveState.pendingUpgrade?.connectionId === connectionId) {
         serveState.pendingUpgrade = null;
       }
     },
-
-    dispatchWebSocketMessage(connectionId: string, message: string | ArrayBuffer): void {
-      // Check if connection is tracked
+    dispatchWebSocketMessage(connectionId, message) {
       if (!serveState.activeConnections.has(connectionId)) {
-        return; // Silently ignore for unknown connections
+        return;
       }
-
-      // Check if message handler exists
       const hasMessageHandler = context.evalSync(`!!globalThis.__serveOptions__?.websocket?.message`);
       if (!hasMessageHandler) {
         return;
       }
-
-      // Marshal message and call handler
       if (typeof message === "string") {
         context.evalSync(`
           (function() {
             const ws = globalThis.__activeWs_${connectionId}__;
-            if (ws) __serveOptions__.websocket.message(ws, "${message.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}");
+            if (ws) __serveOptions__.websocket.message(ws, "${message.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n")}");
           })()
         `);
       } else {
-        // ArrayBuffer - convert to base64 or pass as array
         const bytes = Array.from(new Uint8Array(message));
         context.evalSync(`
           (function() {
@@ -2249,25 +1693,19 @@ export async function setupFetch(
         `);
       }
     },
-
-    dispatchWebSocketClose(connectionId: string, code: number, reason: string): void {
-      // Check if connection is tracked
+    dispatchWebSocketClose(connectionId, code, reason) {
       if (!serveState.activeConnections.has(connectionId)) {
         return;
       }
-
-      // Update readyState to CLOSED
       context.evalSync(`
         (function() {
           const ws = globalThis.__activeWs_${connectionId}__;
           if (ws) ws._setReadyState(3);
         })()
       `);
-
-      // Check if close handler exists
       const hasCloseHandler = context.evalSync(`!!globalThis.__serveOptions__?.websocket?.close`);
       if (hasCloseHandler) {
-        const safeReason = reason.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+        const safeReason = reason.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
         context.evalSync(`
           (function() {
             const ws = globalThis.__activeWs_${connectionId}__;
@@ -2275,29 +1713,22 @@ export async function setupFetch(
           })()
         `);
       }
-
-      // Cleanup
       context.evalSync(`
         delete globalThis.__activeWs_${connectionId}__;
         globalThis.__upgradeRegistry__.delete("${connectionId}");
       `);
       serveState.activeConnections.delete(connectionId);
     },
-
-    dispatchWebSocketError(connectionId: string, error: Error): void {
-      // Check if connection is tracked
+    dispatchWebSocketError(connectionId, error) {
       if (!serveState.activeConnections.has(connectionId)) {
         return;
       }
-
-      // Check if error handler exists
       const hasErrorHandler = context.evalSync(`!!globalThis.__serveOptions__?.websocket?.error`);
       if (!hasErrorHandler) {
         return;
       }
-
-      const safeName = error.name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-      const safeMessage = error.message.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+      const safeName = error.name.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+      const safeMessage = error.message.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
       context.evalSync(`
         (function() {
           const ws = globalThis.__activeWs_${connectionId}__;
@@ -2308,18 +1739,21 @@ export async function setupFetch(
         })()
       `);
     },
-
-    onWebSocketCommand(callback: (cmd: WebSocketCommand) => void): () => void {
+    onWebSocketCommand(callback) {
       wsCommandCallbacks.add(callback);
       return () => wsCommandCallbacks.delete(callback);
     },
-
-    hasServeHandler(): boolean {
-      return context.evalSync(`!!globalThis.__serveOptions__?.fetch`) as boolean;
+    hasServeHandler() {
+      return context.evalSync(`!!globalThis.__serveOptions__?.fetch`);
     },
-
-    hasActiveConnections(): boolean {
+    hasActiveConnections() {
       return serveState.activeConnections.size > 0;
-    },
+    }
   };
 }
+export {
+  setupFetch,
+  clearAllInstanceState
+};
+
+//# debugId=30AA5852218E953D64756E2164756E21