@ricsam/isolate 0.0.1 → 0.1.1

package/dist/cjs/internal/fetch/index.cjs

@@ -0,0 +1,2640 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/internal/fetch/index.ts
+var exports_fetch = {};
+__export(exports_fetch, {
+  setupFetch: () => setupFetch,
+  clearAllInstanceState: () => import_core.clearAllInstanceState
+});
+module.exports = __toCommonJS(exports_fetch);
+var import_isolated_vm = __toESM(require("isolated-vm"));
+var import_core = require("../core/index.cjs");
+var import_stream_state = require("./stream-state.cjs");
+var instanceStateMap = new WeakMap;
+var passthruBodies = new WeakMap;
+var trackedGlobalHandles = new WeakMap;
+var nextInstanceId = 1;
+function getInstanceStateMapForContext(context) {
+  let map = instanceStateMap.get(context);
+  if (!map) {
+    map = new Map;
+    instanceStateMap.set(context, map);
+  }
+  return map;
+}
+function getPassthruBodiesForContext(context) {
+  let map = passthruBodies.get(context);
+  if (!map) {
+    map = new Map;
+    passthruBodies.set(context, map);
+  }
+  return map;
+}
+function getTrackedGlobalHandlesForContext(context) {
+  let handles = trackedGlobalHandles.get(context);
+  if (!handles) {
+    handles = new Set;
+    trackedGlobalHandles.set(context, handles);
+  }
+  return handles;
+}
+function setTrackedGlobal(context, name, value) {
+  if (value instanceof import_isolated_vm.default.Callback || value instanceof import_isolated_vm.default.Reference) {
+    getTrackedGlobalHandlesForContext(context).add(value);
+  }
+  context.global.setSync(name, value);
+}
+function releaseIfSupported(handle) {
+  const maybeHandle = handle;
+  if (typeof maybeHandle.release === "function") {
+    maybeHandle.release();
+  }
+}
+function releaseTrackedGlobalHandles(context) {
+  const handles = trackedGlobalHandles.get(context);
+  if (!handles)
+    return;
+  for (const handle of handles) {
+    try {
+      releaseIfSupported(handle);
+    } catch {}
+  }
+  handles.clear();
+}
+function clearPassthruBodiesForContext(context) {
+  const map = passthruBodies.get(context);
+  if (!map)
+    return;
+  map.clear();
+  passthruBodies.delete(context);
+}
+var headersCode = `
+(function() {
+  class Headers {
+    #headers = new Map(); // lowercase key -> [originalCase, values[]]
+
+    constructor(init) {
+      if (init instanceof Headers) {
+        init.forEach((value, key) => this.append(key, value));
+      } else if (Array.isArray(init)) {
+        for (const pair of init) {
+          if (Array.isArray(pair) && pair.length >= 2) {
+            this.append(pair[0], pair[1]);
+          }
+        }
+      } else if (init && typeof init === 'object') {
+        for (const [key, value] of Object.entries(init)) {
+          this.append(key, value);
+        }
+      }
+    }
+
+    append(name, value) {
+      const key = String(name).toLowerCase();
+      const valueStr = String(value);
+      const existing = this.#headers.get(key);
+      if (existing) {
+        existing[1].push(valueStr);
+      } else {
+        this.#headers.set(key, [String(name), [valueStr]]);
+      }
+    }
+
+    delete(name) {
+      this.#headers.delete(String(name).toLowerCase());
+    }
+
+    get(name) {
+      const entry = this.#headers.get(String(name).toLowerCase());
+      return entry ? entry[1].join(', ') : null;
+    }
+
+    getSetCookie() {
+      const entry = this.#headers.get('set-cookie');
+      return entry ? [...entry[1]] : [];
+    }
+
+    has(name) {
+      return this.#headers.has(String(name).toLowerCase());
+    }
+
+    set(name, value) {
+      const key = String(name).toLowerCase();
+      this.#headers.set(key, [String(name), [String(value)]]);
+    }
+
+    forEach(callback, thisArg) {
+      const sortedKeys = [...this.#headers.keys()].sort();
+      for (const key of sortedKeys) {
+        const [, values] = this.#headers.get(key);
+        if (key === 'set-cookie') {
+          for (const value of values) {
+            callback.call(thisArg, value, key, this);
+          }
+          continue;
+        }
+        callback.call(thisArg, values.join(', '), key, this);
+      }
+    }
+
+    *entries() {
+      const sortedKeys = [...this.#headers.keys()].sort();
+      for (const key of sortedKeys) {
+        const [, values] = this.#headers.get(key);
+        if (key === 'set-cookie') {
+          for (const value of values) {
+            yield [key, value];
+          }
+          continue;
+        }
+        yield [key, values.join(', ')];
+      }
+    }
+
+    *keys() {
+      const sortedKeys = [...this.#headers.keys()].sort();
+      for (const key of sortedKeys) {
+        yield key;
+      }
+    }
+
+    *values() {
+      const sortedKeys = [...this.#headers.keys()].sort();
+      for (const key of sortedKeys) {
+        const [, values] = this.#headers.get(key);
+        if (key === 'set-cookie') {
+          for (const value of values) {
+            yield value;
+          }
+          continue;
+        }
+        yield values.join(', ');
+      }
+    }
+
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  }
+
+  globalThis.Headers = Headers;
+})();
+`;
+var formDataCode = `
+(function() {
+  class FormData {
+    #entries = []; // Array of [name, value]
+
+    append(name, value, filename) {
+      let finalValue = value;
+      if (value instanceof Blob && !(value instanceof File)) {
+        if (filename !== undefined) {
+          finalValue = new File([value], String(filename), { type: value.type });
+        }
+      } else if (value instanceof File && filename !== undefined) {
+        finalValue = new File([value], String(filename), {
+          type: value.type,
+          lastModified: value.lastModified
+        });
+      }
+      this.#entries.push([String(name), finalValue]);
+    }
+
+    delete(name) {
+      const nameStr = String(name);
+      this.#entries = this.#entries.filter(([n]) => n !== nameStr);
+    }
+
+    get(name) {
+      const nameStr = String(name);
+      const entry = this.#entries.find(([n]) => n === nameStr);
+      return entry ? entry[1] : null;
+    }
+
+    getAll(name) {
+      const nameStr = String(name);
+      return this.#entries.filter(([n]) => n === nameStr).map(([, v]) => v);
+    }
+
+    has(name) {
+      return this.#entries.some(([n]) => n === String(name));
+    }
+
+    set(name, value, filename) {
+      const nameStr = String(name);
+      this.delete(nameStr);
+      this.append(nameStr, value, filename);
+    }
+
+    *entries() {
+      for (const [name, value] of this.#entries) {
+        yield [name, value];
+      }
+    }
+
+    *keys() {
+      for (const [name] of this.#entries) {
+        yield name;
+      }
+    }
+
+    *values() {
+      for (const [, value] of this.#entries) {
+        yield value;
+      }
+    }
+
+    forEach(callback, thisArg) {
+      for (const [name, value] of this.#entries) {
+        callback.call(thisArg, value, name, this);
+      }
+    }
+
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  }
+
+  globalThis.FormData = FormData;
+})();
+`;
+var multipartCode = `
+(function() {
+  // Find byte sequence in Uint8Array
+  function findSequence(haystack, needle, start = 0) {
+    outer: for (let i = start; i <= haystack.length - needle.length; i++) {
+      for (let j = 0; j < needle.length; j++) {
+        if (haystack[i + j] !== needle[j]) continue outer;
+      }
+      return i;
+    }
+    return -1;
+  }
+
+  // Parse header lines into object
+  function parseHeaders(text) {
+    const headers = {};
+    for (const line of text.split(/\\r?\\n/)) {
+      const colonIdx = line.indexOf(':');
+      if (colonIdx > 0) {
+        const name = line.slice(0, colonIdx).trim().toLowerCase();
+        const value = line.slice(colonIdx + 1).trim();
+        headers[name] = value;
+      }
+    }
+    return headers;
+  }
+
+  // Parse multipart/form-data body into FormData
+  globalThis.__parseMultipartFormData = function(bodyBytes, contentType) {
+    const formData = new FormData();
+
+    // Extract boundary from Content-Type
+    const boundaryMatch = contentType.match(/boundary=([^;]+)/i);
+    if (!boundaryMatch) return formData;
+
+    const boundary = boundaryMatch[1].replace(/^["']|["']$/g, '');
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    const boundaryBytes = encoder.encode('--' + boundary);
+
+    // Find first boundary
+    let pos = findSequence(bodyBytes, boundaryBytes, 0);
+    if (pos === -1) return formData;
+    pos += boundaryBytes.length;
+
+    while (pos < bodyBytes.length) {
+      // Skip CRLF after boundary
+      if (bodyBytes[pos] === 0x0d && bodyBytes[pos + 1] === 0x0a) pos += 2;
+      else if (bodyBytes[pos] === 0x0a) pos += 1;
+
+      // Check for closing boundary (--)
+      if (bodyBytes[pos] === 0x2d && bodyBytes[pos + 1] === 0x2d) break;
+
+      // Find header/body separator (CRLFCRLF)
+      const crlfcrlf = encoder.encode('\\r\\n\\r\\n');
+      const headersEnd = findSequence(bodyBytes, crlfcrlf, pos);
+      if (headersEnd === -1) break;
+
+      // Parse headers
+      const headersText = decoder.decode(bodyBytes.slice(pos, headersEnd));
+      const headers = parseHeaders(headersText);
+      pos = headersEnd + 4;
+
+      // Find next boundary
+      const nextBoundary = findSequence(bodyBytes, boundaryBytes, pos);
+      if (nextBoundary === -1) break;
+
+      // Extract content (minus trailing CRLF)
+      let contentEnd = nextBoundary;
+      if (contentEnd > 0 && bodyBytes[contentEnd - 1] === 0x0a) contentEnd--;
+      if (contentEnd > 0 && bodyBytes[contentEnd - 1] === 0x0d) contentEnd--;
+      const content = bodyBytes.slice(pos, contentEnd);
+
+      // Parse Content-Disposition
+      const disposition = headers['content-disposition'] || '';
+      const nameMatch = disposition.match(/name="([^"]+)"/);
+      const filenameMatch = disposition.match(/filename="([^"]+)"/);
+
+      if (nameMatch) {
+        const name = nameMatch[1];
+        if (filenameMatch) {
+          const filename = filenameMatch[1];
+          const mimeType = headers['content-type'] || 'application/octet-stream';
+          const file = new File([content], filename, { type: mimeType });
+          formData.append(name, file);
+        } else {
+          formData.append(name, decoder.decode(content));
+        }
+      }
+
+      pos = nextBoundary + boundaryBytes.length;
+    }
+
+    return formData;
+  };
+
+  // Serialize FormData to multipart/form-data format
+  globalThis.__serializeFormData = function(formData) {
+    const boundary = '----FormDataBoundary' + Math.random().toString(36).slice(2) +
+                     Math.random().toString(36).slice(2);
+    const encoder = new TextEncoder();
+    const parts = [];
+
+    for (const [name, value] of formData.entries()) {
+      if (value instanceof File) {
+        const header = [
+          '--' + boundary,
+          'Content-Disposition: form-data; name="' + name + '"; filename="' + value.name + '"',
+          'Content-Type: ' + (value.type || 'application/octet-stream'),
+          '',
+          ''
+        ].join('\\r\\n');
+        parts.push(encoder.encode(header));
+        // Use existing __Blob_bytes callback (File extends Blob)
+        parts.push(__Blob_bytes(value._getInstanceId()));
+        parts.push(encoder.encode('\\r\\n'));
+      } else if (value instanceof Blob) {
+        const header = [
+          '--' + boundary,
+          'Content-Disposition: form-data; name="' + name + '"; filename="blob"',
+          'Content-Type: ' + (value.type || 'application/octet-stream'),
+          '',
+          ''
+        ].join('\\r\\n');
+        parts.push(encoder.encode(header));
+        parts.push(__Blob_bytes(value._getInstanceId()));
+        parts.push(encoder.encode('\\r\\n'));
+      } else {
+        const header = [
+          '--' + boundary,
+          'Content-Disposition: form-data; name="' + name + '"',
+          '',
+          ''
+        ].join('\\r\\n');
+        parts.push(encoder.encode(header));
+        parts.push(encoder.encode(String(value)));
+        parts.push(encoder.encode('\\r\\n'));
+      }
+    }
+
+    // Closing boundary
+    parts.push(encoder.encode('--' + boundary + '--\\r\\n'));
+
+    // Concatenate all parts
+    const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
+    const body = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const part of parts) {
+      body.set(part, offset);
+      offset += part.length;
+    }
+
+    return {
+      body: body,
+      contentType: 'multipart/form-data; boundary=' + boundary
+    };
+  };
+})();
+`;
+function setupStreamCallbacks(context, streamRegistry) {
+  setTrackedGlobal(context, "__Stream_create", new import_isolated_vm.default.Callback(() => {
+    return streamRegistry.create();
+  }));
+  setTrackedGlobal(context, "__Stream_push", new import_isolated_vm.default.Callback((streamId, chunkArray) => {
+    const chunk = new Uint8Array(chunkArray);
+    return streamRegistry.push(streamId, chunk);
+  }));
+  setTrackedGlobal(context, "__Stream_close", new import_isolated_vm.default.Callback((streamId) => {
+    streamRegistry.close(streamId);
+  }));
+  setTrackedGlobal(context, "__Stream_error", new import_isolated_vm.default.Callback((streamId, message) => {
+    streamRegistry.error(streamId, new Error(message));
+  }));
+  setTrackedGlobal(context, "__Stream_isQueueFull", new import_isolated_vm.default.Callback((streamId) => {
+    return streamRegistry.isQueueFull(streamId);
+  }));
+  setTrackedGlobal(context, "__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) {
+      return JSON.stringify({ done: true });
+    }
+    return JSON.stringify({ done: false, value: Array.from(result.value) });
+  });
+  setTrackedGlobal(context, "__Stream_pull_ref", pullRef);
+}
+var hostBackedStreamCode = `
+(function() {
+  const _streamIds = new WeakMap();
+
+  // 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();
+      }
+
+      let closed = false;
+
+      super({
+        async pull(controller) {
+          if (closed) return;
+
+          const resultJson = await __Stream_pull_ref.apply(undefined, [streamId], { result: { promise: true, copy: true } });
+          const result = JSON.parse(resultJson);
+
+          if (result.done) {
+            closed = true;
+            controller.close();
+            return;
+          }
+          controller.enqueue(new Uint8Array(result.value));
+        },
+        cancel(reason) {
+          closed = true;
+          __Stream_cancel(streamId);
+        }
+      });
+
+      _streamIds.set(this, streamId);
+    }
+
+    // Override to report as ReadableStream for spec compliance
+    get [Symbol.toStringTag]() {
+      return 'ReadableStream';
+    }
+
+    _getStreamId() {
+      return _streamIds.get(this);
+    }
+
+    static _fromStreamId(streamId) {
+      return new HostBackedReadableStream(streamId);
+    }
+  }
+
+  // Make constructor.name return 'ReadableStream' for spec compliance
+  Object.defineProperty(HostBackedReadableStream, 'name', { value: 'ReadableStream' });
+
+  globalThis.HostBackedReadableStream = HostBackedReadableStream;
+})();
+`;
+function setupResponse(context, stateMap, streamRegistry) {
+  setTrackedGlobal(context, "__Response_construct", new import_isolated_vm.default.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;
+  }));
+  setTrackedGlobal(context, "__Response_constructStreaming", new import_isolated_vm.default.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;
+  }));
+  setTrackedGlobal(context, "__Response_constructFromFetch", new import_isolated_vm.default.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;
+  }));
+  setTrackedGlobal(context, "__Response_get_status", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.status ?? 200;
+  }));
+  setTrackedGlobal(context, "__Response_get_statusText", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.statusText ?? "";
+  }));
+  setTrackedGlobal(context, "__Response_get_headers", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.headers ?? [];
+  }));
+  setTrackedGlobal(context, "__Response_get_bodyUsed", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.bodyUsed ?? false;
+  }));
+  setTrackedGlobal(context, "__Response_get_url", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.url ?? "";
+  }));
+  setTrackedGlobal(context, "__Response_get_redirected", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.redirected ?? false;
+  }));
+  setTrackedGlobal(context, "__Response_get_type", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.type ?? "default";
+  }));
+  setTrackedGlobal(context, "__Response_get_nullBody", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.nullBody ?? false;
+  }));
+  setTrackedGlobal(context, "__Response_setType", new import_isolated_vm.default.Callback((instanceId, type) => {
+    const state = stateMap.get(instanceId);
+    if (state) {
+      state.type = type;
+    }
+  }));
+  setTrackedGlobal(context, "__Response_markBodyUsed", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (state) {
+      if (state.bodyUsed) {
+        throw new Error("[TypeError]Body has already been consumed");
+      }
+      state.bodyUsed = true;
+    }
+  }));
+  setTrackedGlobal(context, "__Response_text", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body)
+      return "";
+    return new TextDecoder().decode(state.body);
+  }));
+  setTrackedGlobal(context, "__Response_arrayBuffer", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body) {
+      return new import_isolated_vm.default.ExternalCopy(new ArrayBuffer(0)).copyInto();
+    }
+    return new import_isolated_vm.default.ExternalCopy(state.body.buffer.slice(state.body.byteOffset, state.body.byteOffset + state.body.byteLength)).copyInto();
+  }));
+  setTrackedGlobal(context, "__Response_clone", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    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,
+      body: state.body ? new Uint8Array(state.body) : null,
+      bodyUsed: false
+    };
+    stateMap.set(newId, newState);
+    return newId;
+  }));
+  setTrackedGlobal(context, "__Response_getStreamId", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.streamId ?? null;
+  }));
+  const responseCode = `
+(function() {
+  const _responseInstanceIds = new WeakMap();
+
+  function __decodeError(err) {
+    if (!(err instanceof Error)) return err;
+    const match = err.message.match(/^\\[(TypeError|RangeError|SyntaxError|ReferenceError|URIError|EvalError|Error)\\](.*)$/);
+    if (match) {
+      const ErrorType = globalThis[match[1]] || Error;
+      return new ErrorType(match[2]);
+    }
+    return err;
+  }
+
+  function __prepareBody(body) {
+    if (body === null || body === undefined) return null;
+    if (typeof body === 'string') {
+      const encoder = new TextEncoder();
+      return Array.from(encoder.encode(body));
+    }
+    if (body instanceof ArrayBuffer) {
+      return Array.from(new Uint8Array(body));
+    }
+    if (body instanceof Uint8Array) {
+      return Array.from(body);
+    }
+    if (ArrayBuffer.isView(body)) {
+      return Array.from(new Uint8Array(body.buffer, body.byteOffset, body.byteLength));
+    }
+    if (body instanceof Blob) {
+      // Mark as needing async Blob handling - will be read in constructor
+      return { __isBlob: true, blob: body };
+    }
+    // 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
+    return Array.from(new TextEncoder().encode(String(body)));
+  }
+
+  class Response {
+    #instanceId;
+    #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
+      if (typeof body === 'number' && init === null) {
+        this.#instanceId = body;
+        this.#headers = new Headers(__Response_get_headers(body));
+        this.#streamId = __Response_getStreamId(body);
+        return;
+      }
+
+      const preparedBody = __prepareBody(body);
+
+      // Handle Blob body - create streaming response and push blob data
+      if (preparedBody && preparedBody.__isBlob) {
+        this.#streamId = __Stream_create();
+        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;
+
+        // Start async blob initialization and stream pumping
+        const streamId = this.#streamId;
+        const blob = preparedBody.blob;
+        this.#blobInitPromise = (async () => {
+          try {
+            const buffer = await blob.arrayBuffer();
+            __Stream_push(streamId, Array.from(new Uint8Array(buffer)));
+            __Stream_close(streamId);
+          } catch (error) {
+            __Stream_error(streamId, String(error));
+          }
+        })();
+        return;
+      }
+
+      // 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;
+        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;
+
+        // Start pumping the source stream to host queue (fire-and-forget)
+        this._startStreamPump(preparedBody.stream);
+        return;
+      }
+
+      // Existing buffered body handling
+      const bodyBytes = preparedBody;
+      const status = init.status ?? 200;
+      const statusText = init.statusText ?? '';
+      const headersInit = init.headers;
+      const headers = new Headers(headersInit);
+      const headersArray = Array.from(headers.entries());
+
+      this.#instanceId = __Response_construct(bodyBytes, status, statusText, headersArray);
+      this.#headers = headers;
+    }
+
+    async _startStreamPump(sourceStream) {
+      const streamId = this.#streamId;
+      try {
+        const reader = sourceStream.getReader();
+        while (true) {
+          // Check backpressure - wait if queue is full
+          while (__Stream_isQueueFull(streamId)) {
+            await new Promise(r => setTimeout(r, 1));
+          }
+
+          const { done, value } = await reader.read();
+          if (done) {
+            __Stream_close(streamId);
+            break;
+          }
+          if (value) {
+            __Stream_push(streamId, Array.from(value));
+          }
+        }
+      } catch (error) {
+        __Stream_error(streamId, String(error));
+      }
+    }
+
+    _getInstanceId() {
+      return this.#instanceId;
+    }
+
+    static _fromInstanceId(instanceId) {
+      return new Response(instanceId, null);
+    }
+
+    get status() {
+      return __Response_get_status(this.#instanceId);
+    }
+
+    get statusText() {
+      return __Response_get_statusText(this.#instanceId);
+    }
+
+    get ok() {
+      const status = this.status;
+      return status >= 200 && status < 300;
+    }
+
+    get headers() {
+      return this.#headers;
+    }
+
+    get bodyUsed() {
+      return __Response_get_bodyUsed(this.#instanceId);
+    }
+
+    get url() {
+      return __Response_get_url(this.#instanceId);
+    }
+
+    get redirected() {
+      return __Response_get_redirected(this.#instanceId);
+    }
+
+    get type() {
+      return __Response_get_type(this.#instanceId);
+    }
+
+    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;
+      }
+
+      const streamId = __Response_getStreamId(this.#instanceId);
+      if (streamId !== null) {
+        this.#cachedBody = HostBackedReadableStream._fromStreamId(streamId);
+        return this.#cachedBody;
+      }
+
+      // Fallback: create host-backed stream from buffered body
+      const instanceId = this.#instanceId;
+      const newStreamId = __Stream_create();
+      const buffer = __Response_arrayBuffer(instanceId);
+
+      if (buffer.byteLength > 0) {
+        __Stream_push(newStreamId, Array.from(new Uint8Array(buffer)));
+      }
+      __Stream_close(newStreamId);
+
+      this.#cachedBody = HostBackedReadableStream._fromStreamId(newStreamId);
+      return this.#cachedBody;
+    }
+
+    async text() {
+      try {
+        __Response_markBodyUsed(this.#instanceId);
+      } 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);
+    }
+
+    async json() {
+      const text = await this.text();
+      return JSON.parse(text);
+    }
+
+    async arrayBuffer() {
+      try {
+        __Response_markBodyUsed(this.#instanceId);
+      } catch (err) {
+        throw __decodeError(err);
+      }
+
+      // For streaming responses (including Blob bodies), consume the stream
+      if (this.#streamId !== null) {
+        // Wait for blob init to complete if needed
+        if (this.#blobInitPromise) {
+          await this.#blobInitPromise;
+          this.#blobInitPromise = null;
+        }
+
+        const reader = this.body.getReader();
+        const chunks = [];
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value) chunks.push(value);
+        }
+        // Concatenate all chunks
+        const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          result.set(chunk, offset);
+          offset += chunk.length;
+        }
+        return result.buffer;
+      }
+
+      return __Response_arrayBuffer(this.#instanceId);
+    }
+
+    async blob() {
+      const buffer = await this.arrayBuffer();
+      const contentType = this.headers.get('content-type') || '';
+      return new Blob([buffer], { type: contentType });
+    }
+
+    async formData() {
+      const contentType = this.headers.get('content-type') || '';
+
+      // Parse multipart/form-data
+      if (contentType.includes('multipart/form-data')) {
+        const buffer = await this.arrayBuffer();
+        return __parseMultipartFormData(new Uint8Array(buffer), contentType);
+      }
+
+      // Parse application/x-www-form-urlencoded
+      if (contentType.includes('application/x-www-form-urlencoded')) {
+        const text = await this.text();
+        const formData = new FormData();
+        const params = new URLSearchParams(text);
+        for (const [key, value] of params) {
+          formData.append(key, value);
+        }
+        return formData;
+      }
+
+      throw new TypeError('Unsupported content type for formData()');
+    }
+
+    clone() {
+      if (this.bodyUsed) {
+        throw new TypeError('Cannot clone a Response that has already been used');
+      }
+      const newId = __Response_clone(this.#instanceId);
+      const cloned = Response._fromInstanceId(newId);
+      return cloned;
+    }
+
+    static json(data, init = {}) {
+      const body = JSON.stringify(data);
+      const headers = new Headers(init.headers);
+      if (!headers.has('content-type')) {
+        headers.set('content-type', 'application/json');
+      }
+      return new Response(body, { ...init, headers });
+    }
+
+    static redirect(url, status = 302) {
+      if (![301, 302, 303, 307, 308].includes(status)) {
+        throw new RangeError('Invalid redirect status code');
+      }
+      const headers = new Headers({ Location: String(url) });
+      return new Response(null, { status, headers });
+    }
+
+    static error() {
+      const response = new Response(null, { status: 0, statusText: '' });
+      __Response_setType(response._getInstanceId(), 'error');
+      return response;
+    }
+  }
+
+  globalThis.Response = Response;
+})();
+`;
+  context.evalSync(responseCode);
+}
+function setupRequest(context, stateMap) {
+  setTrackedGlobal(context, "__Request_construct", new import_isolated_vm.default.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,
+      signalAborted: false,
+      mode,
+      credentials,
+      cache,
+      redirect,
+      referrer,
+      integrity
+    };
+    stateMap.set(instanceId, state);
+    return instanceId;
+  }));
+  setTrackedGlobal(context, "__Request_get_method", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.method ?? "GET";
+  }));
+  setTrackedGlobal(context, "__Request_get_url", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.url ?? "";
+  }));
+  setTrackedGlobal(context, "__Request_get_headers", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.headers ?? [];
+  }));
+  setTrackedGlobal(context, "__Request_get_bodyUsed", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.bodyUsed ?? false;
+  }));
+  setTrackedGlobal(context, "__Request_get_mode", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.mode ?? "cors";
+  }));
+  setTrackedGlobal(context, "__Request_get_credentials", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.credentials ?? "same-origin";
+  }));
+  setTrackedGlobal(context, "__Request_get_cache", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.cache ?? "default";
+  }));
+  setTrackedGlobal(context, "__Request_get_redirect", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.redirect ?? "follow";
+  }));
+  setTrackedGlobal(context, "__Request_get_referrer", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.referrer ?? "about:client";
+  }));
+  setTrackedGlobal(context, "__Request_get_integrity", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.integrity ?? "";
+  }));
+  setTrackedGlobal(context, "__Request_markBodyUsed", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (state) {
+      if (state.bodyUsed) {
+        throw new Error("[TypeError]Body has already been consumed");
+      }
+      state.bodyUsed = true;
+    }
+  }));
+  setTrackedGlobal(context, "__Request_text", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body)
+      return "";
+    return new TextDecoder().decode(state.body);
+  }));
+  setTrackedGlobal(context, "__Request_arrayBuffer", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body) {
+      return new import_isolated_vm.default.ExternalCopy(new ArrayBuffer(0)).copyInto();
+    }
+    return new import_isolated_vm.default.ExternalCopy(state.body.buffer.slice(state.body.byteOffset, state.body.byteOffset + state.body.byteLength)).copyInto();
+  }));
+  setTrackedGlobal(context, "__Request_getBodyBytes", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    if (!state || !state.body)
+      return null;
+    return Array.from(state.body);
+  }));
+  setTrackedGlobal(context, "__Request_clone", new import_isolated_vm.default.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;
+  }));
+  setTrackedGlobal(context, "__Request_getStreamId", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.streamId ?? null;
+  }));
+  setTrackedGlobal(context, "__Request_get_signalAborted", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.signalAborted ?? false;
+  }));
+  const requestCode = `
+(function() {
+  function __decodeError(err) {
+    if (!(err instanceof Error)) return err;
+    const match = err.message.match(/^\\[(TypeError|RangeError|SyntaxError|ReferenceError|URIError|EvalError|Error)\\](.*)$/);
+    if (match) {
+      const ErrorType = globalThis[match[1]] || Error;
+      return new ErrorType(match[2]);
+    }
+    return err;
+  }
+
+  function __prepareBody(body) {
+    if (body === null || body === undefined) return null;
+    if (typeof body === 'string') {
+      const encoder = new TextEncoder();
+      return Array.from(encoder.encode(body));
+    }
+    if (body instanceof ArrayBuffer) {
+      return Array.from(new Uint8Array(body));
+    }
+    if (body instanceof Uint8Array) {
+      return Array.from(body);
+    }
+    if (ArrayBuffer.isView(body)) {
+      return Array.from(new Uint8Array(body.buffer, body.byteOffset, body.byteLength));
+    }
+    if (body instanceof URLSearchParams) {
+      return Array.from(new TextEncoder().encode(body.toString()));
+    }
+    if (body instanceof FormData) {
+      // 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)));
+  }
+
+  // Helper to consume a HostBackedReadableStream and concatenate all chunks
+  async function __consumeStream(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let totalLength = 0;
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      totalLength += value.length;
+    }
+
+    // Concatenate all chunks
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+
+  const __requestSignalControllers = new Map();
+
+  class Request {
+    #instanceId;
+    #headers;
+    #signal;
+    #streamId;
+    #cachedBody = null;
+
+    constructor(input, init = {}) {
+      // Handle internal construction from instance ID
+      if (typeof input === 'number' && init === null) {
+        const controller = new AbortController();
+        if (__Request_get_signalAborted(input)) {
+          controller.abort();
+        }
+        __requestSignalControllers.set(input, controller);
+
+        this.#instanceId = input;
+        this.#headers = new Headers(__Request_get_headers(input));
+        this.#signal = controller.signal;
+        this.#streamId = __Request_getStreamId(input);
+        return;
+      }
+
+      let url;
+      let method = 'GET';
+      let headers;
+      let body = null;
+      let signal = new AbortController().signal;
+      let mode = 'cors';
+      let credentials = 'same-origin';
+      let cache = 'default';
+      let redirect = 'follow';
+      let referrer = 'about:client';
+      let integrity = '';
+
+      if (input instanceof Request) {
+        url = input.url;
+        method = input.method;
+        headers = new Headers(input.headers);
+        signal = input.signal;
+        mode = input.mode;
+        credentials = input.credentials;
+        cache = input.cache;
+        redirect = input.redirect;
+        referrer = input.referrer;
+        integrity = input.integrity;
+        // Note: We don't copy the body from the input Request
+      } else {
+        url = String(input);
+        headers = new Headers();
+      }
+
+      // Apply init overrides
+      if (init.method !== undefined) method = String(init.method).toUpperCase();
+      if (init.headers !== undefined) headers = new Headers(init.headers);
+      if (init.body !== undefined) body = init.body;
+      if (init.signal !== undefined) signal = init.signal;
+      if (init.mode !== undefined) mode = init.mode;
+      if (init.credentials !== undefined) credentials = init.credentials;
+      if (init.cache !== undefined) cache = init.cache;
+      if (init.redirect !== undefined) redirect = init.redirect;
+      if (init.referrer !== undefined) referrer = init.referrer;
+      if (init.integrity !== undefined) integrity = init.integrity;
+
+      // Ensure signal is always a valid AbortSignal
+      if (signal == null) {
+        signal = new AbortController().signal;
+      }
+
+      // Validate: body with GET/HEAD
+      if (body !== null && (method === 'GET' || method === 'HEAD')) {
+        throw new TypeError('Request with GET/HEAD method cannot have body');
+      }
+
+      const bodyBytes = __prepareBody(body);
+
+      // Handle Content-Type for FormData
+      if (globalThis.__pendingFormDataContentType) {
+        headers.set('content-type', globalThis.__pendingFormDataContentType);
+        delete globalThis.__pendingFormDataContentType;
+      } else if (body instanceof URLSearchParams && !headers.has('content-type')) {
+        headers.set('content-type', 'application/x-www-form-urlencoded');
+      }
+
+      const headersArray = Array.from(headers.entries());
+
+      this.#instanceId = __Request_construct(
+        url, method, headersArray, bodyBytes,
+        mode, credentials, cache, redirect, referrer, integrity
+      );
+      this.#headers = headers;
+      this.#signal = signal;
+      this.#streamId = null;
+    }
+
+    _getInstanceId() {
+      return this.#instanceId;
+    }
+
+    static _fromInstanceId(instanceId) {
+      return new Request(instanceId, null);
+    }
+
+    get method() {
+      return __Request_get_method(this.#instanceId);
+    }
+
+    get url() {
+      return __Request_get_url(this.#instanceId);
+    }
+
+    get headers() {
+      return this.#headers;
+    }
+
+    get bodyUsed() {
+      return __Request_get_bodyUsed(this.#instanceId);
+    }
+
+    get signal() {
+      return this.#signal;
+    }
+
+    get mode() {
+      return __Request_get_mode(this.#instanceId);
+    }
+
+    get credentials() {
+      return __Request_get_credentials(this.#instanceId);
+    }
+
+    get cache() {
+      return __Request_get_cache(this.#instanceId);
+    }
+
+    get redirect() {
+      return __Request_get_redirect(this.#instanceId);
+    }
+
+    get referrer() {
+      return __Request_get_referrer(this.#instanceId);
+    }
+
+    get integrity() {
+      return __Request_get_integrity(this.#instanceId);
+    }
+
+    get body() {
+      // Per WHATWG Fetch spec: GET/HEAD requests cannot have a body
+      const method = __Request_get_method(this.#instanceId);
+      if (method === 'GET' || method === 'HEAD') {
+        return null;
+      }
+
+      // Return cached body if available
+      if (this.#cachedBody !== null) {
+        return this.#cachedBody;
+      }
+
+      // If we have a stream ID, create and cache the stream
+      if (this.#streamId !== null) {
+        this.#cachedBody = HostBackedReadableStream._fromStreamId(this.#streamId);
+        return this.#cachedBody;
+      }
+
+      // Check if there's any buffered body data
+      const buffer = __Request_arrayBuffer(this.#instanceId);
+      if (buffer.byteLength === 0) {
+        return null;  // Return null per WHATWG Fetch spec for empty body
+      }
+
+      // Create stream from non-empty buffered body
+      const newStreamId = __Stream_create();
+      __Stream_push(newStreamId, Array.from(new Uint8Array(buffer)));
+      __Stream_close(newStreamId);
+
+      this.#cachedBody = HostBackedReadableStream._fromStreamId(newStreamId);
+      return this.#cachedBody;
+    }
+
+    async text() {
+      try {
+        __Request_markBodyUsed(this.#instanceId);
+      } catch (err) {
+        throw __decodeError(err);
+      }
+
+      // If streaming, consume the stream
+      if (this.#streamId !== null) {
+        const bytes = await __consumeStream(this.body);
+        return new TextDecoder().decode(bytes);
+      }
+
+      // Fallback to host callback for buffered body
+      return __Request_text(this.#instanceId);
+    }
+
+    async json() {
+      const text = await this.text();
+      return JSON.parse(text);
+    }
+
+    async arrayBuffer() {
+      try {
+        __Request_markBodyUsed(this.#instanceId);
+      } catch (err) {
+        throw __decodeError(err);
+      }
+
+      // If streaming, consume the stream
+      if (this.#streamId !== null) {
+        const bytes = await __consumeStream(this.body);
+        return bytes.buffer;
+      }
+
+      return __Request_arrayBuffer(this.#instanceId);
+    }
+
+    async blob() {
+      const buffer = await this.arrayBuffer();
+      const contentType = this.headers.get('content-type') || '';
+      return new Blob([buffer], { type: contentType });
+    }
+
+    async formData() {
+      const contentType = this.headers.get('content-type') || '';
+
+      // Parse multipart/form-data
+      if (contentType.includes('multipart/form-data')) {
+        const buffer = await this.arrayBuffer();
+        return __parseMultipartFormData(new Uint8Array(buffer), contentType);
+      }
+
+      // Parse application/x-www-form-urlencoded
+      if (contentType.includes('application/x-www-form-urlencoded')) {
+        const text = await this.text();
+        const formData = new FormData();
+        const params = new URLSearchParams(text);
+        for (const [key, value] of params) {
+          formData.append(key, value);
+        }
+        return formData;
+      }
+
+      throw new TypeError('Unsupported content type for formData()');
+    }
+
+    clone() {
+      if (this.bodyUsed) {
+        throw new TypeError('Cannot clone a Request that has already been used');
+      }
+      const newId = __Request_clone(this.#instanceId);
+      const cloned = Request._fromInstanceId(newId);
+      cloned.#signal = this.#signal;
+      return cloned;
+    }
+
+    _getBodyBytes() {
+      return __Request_getBodyBytes(this.#instanceId);
+    }
+  }
+
+  globalThis.__Request_abortSignalByInstanceId = function(instanceId) {
+    const controller = __requestSignalControllers.get(instanceId);
+    if (controller && !controller.signal.aborted) {
+      controller.abort();
+    }
+  };
+
+  globalThis.Request = Request;
+})();
+`;
+  context.evalSync(requestCode);
+  return context.evalSync("globalThis.__Request_abortSignalByInstanceId", { reference: true });
+}
+var FETCH_STREAM_THRESHOLD = 64 * 1024;
+function setupFetchFunction(context, stateMap, streamRegistry, options) {
+  const fetchAbortControllers = new Map;
+  setTrackedGlobal(context, "__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 rawBody = bodyBytes ? new Uint8Array(bodyBytes) : null;
+    const init = {
+      method,
+      headers,
+      rawBody,
+      body: rawBody,
+      signal: hostController.signal
+    };
+    const onFetch = options?.onFetch ?? ((url2, init2) => fetch(url2, {
+      method: init2.method,
+      headers: init2.headers,
+      body: init2.body,
+      signal: init2.signal
+    }));
+    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(url, init), 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()),
+          body: new Uint8Array(0),
+          bodyUsed: false,
+          type: "default",
+          url: nativeResponse.url,
+          redirected: nativeResponse.redirected,
+          streamId,
+          nullBody: isNullBody
+        };
+        stateMap.set(instanceId2, state2);
+        return instanceId2;
+      }
+      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,
+        nullBody: isNullBody
+      };
+      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);
+    }
+  });
+  setTrackedGlobal(context, "__fetch_ref", fetchRef);
+  const fetchCode = `
+(function() {
+  function __decodeError(err) {
+    if (!(err instanceof Error)) return err;
+    const match = err.message.match(/^\\[(TypeError|RangeError|AbortError|Error)\\](.*)$/);
+    if (match) {
+      if (match[1] === 'AbortError') {
+        return new DOMException(match[2], 'AbortError');
+      }
+      const ErrorType = globalThis[match[1]] || Error;
+      return new ErrorType(match[2]);
+    }
+    return err;
+  }
+
+  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);
+
+    // Get signal info
+    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 = await __fetch_ref.apply(undefined, [
+        request.url,
+        request.method,
+        headersJson,
+        bodyJson,
+        signalAborted,
+        fetchId
+      ], { result: { promise: true, copy: true } });
+
+      // Construct Response from the instance ID
+      return Response._fromInstanceId(instanceId);
+    } catch (err) {
+      throw __decodeError(err);
+    }
+  };
+})();
+`;
+  context.evalSync(fetchCode);
+}
+function setupServer(context, serveState) {
+  context.evalSync(`
+    globalThis.__upgradeRegistry__ = new Map();
+    globalThis.__upgradeIdCounter__ = 0;
+  `);
+  setTrackedGlobal(context, "__setPendingUpgrade__", new import_isolated_vm.default.Callback((connectionId) => {
+    serveState.pendingUpgrade = { requested: true, connectionId };
+  }));
+  context.evalSync(`
+(function() {
+  class Server {
+    upgrade(request, options) {
+      const data = options?.data;
+      const connectionId = String(++globalThis.__upgradeIdCounter__);
+      globalThis.__upgradeRegistry__.set(connectionId, data);
+      __setPendingUpgrade__(connectionId);
+      return true;
+    }
+  }
+  globalThis.__Server__ = Server;
+})();
+  `);
+}
+function setupServerWebSocket(context, wsCommandCallbacks) {
+  setTrackedGlobal(context, "__ServerWebSocket_send", new import_isolated_vm.default.Callback((connectionId, data) => {
+    const cmd = { type: "message", connectionId, data };
+    for (const cb of wsCommandCallbacks)
+      cb(cmd);
+  }));
+  setTrackedGlobal(context, "__ServerWebSocket_close", new import_isolated_vm.default.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();
+
+  class ServerWebSocket {
+    constructor(connectionId) {
+      _wsInstanceData.set(this, { connectionId, readyState: 1 });
+    }
+
+    get data() {
+      const state = _wsInstanceData.get(this);
+      return globalThis.__upgradeRegistry__.get(state.connectionId);
+    }
+
+    get readyState() {
+      return _wsInstanceData.get(this).readyState;
+    }
+
+    send(message) {
+      const state = _wsInstanceData.get(this);
+      if (state.readyState !== 1) throw new Error("WebSocket is not open");
+      // Convert ArrayBuffer/Uint8Array to string for transfer
+      let data = message;
+      if (message instanceof ArrayBuffer) {
+        data = new TextDecoder().decode(message);
+      } else if (message instanceof Uint8Array) {
+        data = new TextDecoder().decode(message);
+      }
+      __ServerWebSocket_send(state.connectionId, data);
+    }
+
+    close(code, reason) {
+      const state = _wsInstanceData.get(this);
+      if (state.readyState === 3) return;
+      state.readyState = 2; // CLOSING
+      __ServerWebSocket_close(state.connectionId, code, reason);
+    }
+
+    _setReadyState(readyState) {
+      _wsInstanceData.get(this).readyState = readyState;
+    }
+  }
+
+  globalThis.__ServerWebSocket__ = ServerWebSocket;
+})();
+  `);
+}
+function setupClientWebSocket(context, clientWsCommandCallbacks) {
+  setTrackedGlobal(context, "__WebSocket_connect", new import_isolated_vm.default.Callback((socketId, url, protocols) => {
+    const cmd = {
+      type: "connect",
+      socketId,
+      url,
+      protocols
+    };
+    for (const cb of clientWsCommandCallbacks)
+      cb(cmd);
+  }));
+  setTrackedGlobal(context, "__WebSocket_send", new import_isolated_vm.default.Callback((socketId, data) => {
+    const cmd = { type: "send", socketId, data };
+    for (const cb of clientWsCommandCallbacks)
+      cb(cmd);
+  }));
+  setTrackedGlobal(context, "__WebSocket_close", new import_isolated_vm.default.Callback((socketId, code, reason) => {
+    const cmd = { type: "close", socketId, code, reason };
+    for (const cb of clientWsCommandCallbacks)
+      cb(cmd);
+  }));
+  context.evalSync(`
+(function() {
+  // Socket ID counter
+  let __nextSocketId = 1;
+
+  // Active sockets registry
+  const __clientWebSockets = new Map();
+
+  // Simple Event class (if not defined globally)
+  const _Event = globalThis.Event || class Event {
+    constructor(type, options = {}) {
+      this.type = type;
+      this.bubbles = options.bubbles || false;
+      this.cancelable = options.cancelable || false;
+      this.defaultPrevented = false;
+      this.timeStamp = Date.now();
+      this.target = null;
+      this.currentTarget = null;
+    }
+    preventDefault() {
+      if (this.cancelable) this.defaultPrevented = true;
+    }
+    stopPropagation() {}
+    stopImmediatePropagation() {}
+  };
+
+  // MessageEvent class for WebSocket messages
+  const _MessageEvent = globalThis.MessageEvent || class MessageEvent extends _Event {
+    constructor(type, options = {}) {
+      super(type, options);
+      this.data = options.data !== undefined ? options.data : null;
+      this.origin = options.origin || '';
+      this.lastEventId = options.lastEventId || '';
+      this.source = options.source || null;
+      this.ports = options.ports || [];
+    }
+  };
+
+  // CloseEvent class for WebSocket close
+  const _CloseEvent = globalThis.CloseEvent || class CloseEvent extends _Event {
+    constructor(type, options = {}) {
+      super(type, options);
+      this.code = options.code !== undefined ? options.code : 0;
+      this.reason = options.reason !== undefined ? options.reason : '';
+      this.wasClean = options.wasClean !== undefined ? options.wasClean : false;
+    }
+  };
+
+  // Helper to dispatch events
+  function dispatchEvent(ws, event) {
+    const listeners = ws._listeners.get(event.type) || [];
+    for (const listener of listeners) {
+      try {
+        listener.call(ws, event);
+      } catch (e) {
+        console.error('WebSocket event listener error:', e);
+      }
+    }
+    // Also call on* handler if set
+    const handler = ws['on' + event.type];
+    if (typeof handler === 'function') {
+      try {
+        handler.call(ws, event);
+      } catch (e) {
+        console.error('WebSocket handler error:', e);
+      }
+    }
+  }
+
+  class WebSocket {
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSING = 2;
+    static CLOSED = 3;
+
+    #socketId;
+    #url;
+    #readyState = WebSocket.CONNECTING;
+    #bufferedAmount = 0;
+    #extensions = '';
+    #protocol = '';
+    #binaryType = 'blob';
+    _listeners = new Map();
+
+    // Event handlers
+    onopen = null;
+    onmessage = null;
+    onerror = null;
+    onclose = null;
+
+    constructor(url, protocols) {
+      // Validate URL
+      let parsedUrl;
+      try {
+        parsedUrl = new URL(url);
+      } catch (e) {
+        throw new DOMException("Failed to construct 'WebSocket': The URL '" + url + "' is invalid.", 'SyntaxError');
+      }
+
+      if (parsedUrl.protocol !== 'ws:' && parsedUrl.protocol !== 'wss:') {
+        throw new DOMException("Failed to construct 'WebSocket': The URL's scheme must be either 'ws' or 'wss'.", 'SyntaxError');
+      }
+
+      // Per WHATWG spec, fragments must be stripped from WebSocket URLs
+      parsedUrl.hash = '';
+      this.#url = parsedUrl.href;
+      this.#socketId = String(__nextSocketId++);
+
+      // Normalize protocols to array
+      let protocolArray = [];
+      if (protocols !== undefined) {
+        if (typeof protocols === 'string') {
+          protocolArray = [protocols];
+        } else if (Array.isArray(protocols)) {
+          protocolArray = protocols;
+        } else {
+          protocolArray = [String(protocols)];
+        }
+      }
+
+      // Check for duplicate protocols
+      const seen = new Set();
+      for (const p of protocolArray) {
+        if (seen.has(p)) {
+          throw new DOMException("Failed to construct 'WebSocket': The subprotocol '" + p + "' is duplicated.", 'SyntaxError');
+        }
+        seen.add(p);
+      }
+
+      // Register socket
+      __clientWebSockets.set(this.#socketId, this);
+
+      // Call host to create connection
+      __WebSocket_connect(this.#socketId, this.#url, protocolArray);
+    }
+
+    get url() {
+      return this.#url;
+    }
+
+    get readyState() {
+      return this.#readyState;
+    }
+
+    get bufferedAmount() {
+      return this.#bufferedAmount;
+    }
+
+    get extensions() {
+      return this.#extensions;
+    }
+
+    get protocol() {
+      return this.#protocol;
+    }
+
+    get binaryType() {
+      return this.#binaryType;
+    }
+
+    set binaryType(value) {
+      if (value !== 'blob' && value !== 'arraybuffer') {
+        throw new DOMException("Failed to set the 'binaryType' property: '" + value + "' is not a valid value.", 'SyntaxError');
+      }
+      this.#binaryType = value;
+    }
+
+    // ReadyState constants
+    get CONNECTING() { return WebSocket.CONNECTING; }
+    get OPEN() { return WebSocket.OPEN; }
+    get CLOSING() { return WebSocket.CLOSING; }
+    get CLOSED() { return WebSocket.CLOSED; }
+
+    send(data) {
+      if (this.#readyState === WebSocket.CONNECTING) {
+        throw new DOMException("Failed to execute 'send' on 'WebSocket': Still in CONNECTING state.", 'InvalidStateError');
+      }
+
+      if (this.#readyState !== WebSocket.OPEN) {
+        // Silently discard if not open (per spec)
+        return;
+      }
+
+      // Convert data to string for transfer
+      let dataStr;
+      if (typeof data === 'string') {
+        dataStr = data;
+      } else if (data instanceof ArrayBuffer) {
+        // Convert ArrayBuffer to base64 for transfer
+        const bytes = new Uint8Array(data);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+          binary += String.fromCharCode(bytes[i]);
+        }
+        dataStr = '__BINARY__' + btoa(binary);
+      } else if (ArrayBuffer.isView(data)) {
+        const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+          binary += String.fromCharCode(bytes[i]);
+        }
+        dataStr = '__BINARY__' + btoa(binary);
+      } else if (data instanceof Blob) {
+        // Blob.arrayBuffer() is async, but send() is sync
+        // For now, throw - this is a limitation
+        throw new DOMException("Failed to execute 'send' on 'WebSocket': Blob data is not supported in this environment.", 'NotSupportedError');
+      } else {
+        dataStr = String(data);
+      }
+
+      __WebSocket_send(this.#socketId, dataStr);
+    }
+
+    close(code, reason) {
+      if (code !== undefined) {
+        if (typeof code !== 'number' || code !== Math.floor(code)) {
+          throw new DOMException("Failed to execute 'close' on 'WebSocket': The code must be an integer.", 'InvalidAccessError');
+        }
+        if (code !== 1000 && (code < 3000 || code > 4999)) {
+          throw new DOMException("Failed to execute 'close' on 'WebSocket': The code must be either 1000, or between 3000 and 4999.", 'InvalidAccessError');
+        }
+      }
+
+      if (reason !== undefined) {
+        const encoder = new TextEncoder();
+        if (encoder.encode(reason).byteLength > 123) {
+          throw new DOMException("Failed to execute 'close' on 'WebSocket': The message must not be greater than 123 bytes.", 'SyntaxError');
+        }
+      }
+
+      if (this.#readyState === WebSocket.CLOSING || this.#readyState === WebSocket.CLOSED) {
+        return;
+      }
+
+      this.#readyState = WebSocket.CLOSING;
+      __WebSocket_close(this.#socketId, code ?? 1000, reason ?? '');
+    }
+
+    // EventTarget interface
+    addEventListener(type, listener, options) {
+      if (typeof listener !== 'function') return;
+      let listeners = this._listeners.get(type);
+      if (!listeners) {
+        listeners = [];
+        this._listeners.set(type, listeners);
+      }
+      if (!listeners.includes(listener)) {
+        listeners.push(listener);
+      }
+    }
+
+    removeEventListener(type, listener, options) {
+      const listeners = this._listeners.get(type);
+      if (!listeners) return;
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+
+    dispatchEvent(event) {
+      dispatchEvent(this, event);
+      return !event.defaultPrevented;
+    }
+
+    // Internal methods called from host
+    _setProtocol(protocol) {
+      this.#protocol = protocol;
+    }
+
+    _setExtensions(extensions) {
+      this.#extensions = extensions;
+    }
+
+    _setReadyState(state) {
+      this.#readyState = state;
+    }
+
+    _dispatchOpen() {
+      this.#readyState = WebSocket.OPEN;
+      const event = new _Event('open');
+      dispatchEvent(this, event);
+    }
+
+    _dispatchMessage(data) {
+      // Handle binary data
+      let messageData = data;
+      if (typeof data === 'string' && data.startsWith('__BINARY__')) {
+        const base64 = data.slice(10);
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+          bytes[i] = binary.charCodeAt(i);
+        }
+        if (this.#binaryType === 'arraybuffer') {
+          messageData = bytes.buffer;
+        } else {
+          messageData = new Blob([bytes]);
+        }
+      }
+
+      const event = new _MessageEvent('message', { data: messageData });
+      dispatchEvent(this, event);
+    }
+
+    _dispatchError() {
+      const event = new _Event('error');
+      dispatchEvent(this, event);
+    }
+
+    _dispatchClose(code, reason, wasClean) {
+      this.#readyState = WebSocket.CLOSED;
+      const event = new _CloseEvent('close', { code, reason, wasClean });
+      dispatchEvent(this, event);
+      __clientWebSockets.delete(this.#socketId);
+    }
+  }
+
+  // Helper to dispatch events from host to a socket by ID
+  globalThis.__dispatchClientWebSocketEvent = function(socketId, eventType, data) {
+    const ws = __clientWebSockets.get(socketId);
+    if (!ws) return;
+
+    switch (eventType) {
+      case 'open':
+        ws._setProtocol(data.protocol || '');
+        ws._setExtensions(data.extensions || '');
+        ws._dispatchOpen();
+        break;
+      case 'message':
+        ws._dispatchMessage(data.data);
+        break;
+      case 'error':
+        ws._dispatchError();
+        break;
+      case 'close':
+        ws._dispatchClose(data.code, data.reason, data.wasClean);
+        break;
+    }
+  };
+
+  globalThis.WebSocket = WebSocket;
+})();
+  `);
+}
+function setupServe(context) {
+  context.evalSync(`
+(function() {
+  globalThis.__serveOptions__ = null;
+
+  function serve(options) {
+    globalThis.__serveOptions__ = options;
+  }
+
+  globalThis.serve = serve;
+})();
+  `);
+}
+async function setupFetch(context, options) {
+  await import_core.setupCore(context);
+  const stateMap = getInstanceStateMapForContext(context);
+  const streamRegistry = import_stream_state.getStreamRegistryForContext(context);
+  context.evalSync(headersCode);
+  context.evalSync(formDataCode);
+  context.evalSync(multipartCode);
+  setupStreamCallbacks(context, streamRegistry);
+  context.evalSync(hostBackedStreamCode);
+  setupResponse(context, stateMap, streamRegistry);
+  const requestAbortSignalRef = setupRequest(context, stateMap);
+  setupFetchFunction(context, stateMap, streamRegistry, options);
+  const serveState = {
+    pendingUpgrade: null,
+    activeConnections: new Map
+  };
+  const wsCommandCallbacks = new Set;
+  const clientWsCommandCallbacks = new Set;
+  setupServer(context, serveState);
+  setupServerWebSocket(context, wsCommandCallbacks);
+  setupServe(context);
+  setupClientWebSocket(context, clientWsCommandCallbacks);
+  const eventCallbacks = new Set;
+  setTrackedGlobal(context, "__emit", new import_isolated_vm.default.Callback((eventName, payloadJson) => {
+    const payload = JSON.parse(payloadJson);
+    for (const cb of eventCallbacks)
+      cb(eventName, payload);
+  }));
+  context.evalSync(`
+(function() {
+  const __eventListeners = new Map();
+
+  globalThis.__on = function(event, callback) {
+    let listeners = __eventListeners.get(event);
+    if (!listeners) {
+      listeners = new Set();
+      __eventListeners.set(event, listeners);
+    }
+    listeners.add(callback);
+    return function() {
+      listeners.delete(callback);
+      if (listeners.size === 0) {
+        __eventListeners.delete(event);
+      }
+    };
+  };
+
+  globalThis.__dispatchExternalEvent = function(event, payloadJson) {
+    const listeners = __eventListeners.get(event);
+    if (!listeners) return;
+    const payload = JSON.parse(payloadJson);
+    for (const cb of listeners) {
+      try { cb(payload); } catch (e) { console.error('Event listener error:', e); }
+    }
+  };
+})();
+  `);
+  return {
+    dispose() {
+      stateMap.clear();
+      clearPassthruBodiesForContext(context);
+      import_stream_state.clearStreamRegistryForContext(context);
+      context.evalSync(`globalThis.__upgradeRegistry__.clear()`);
+      serveState.activeConnections.clear();
+      serveState.pendingUpgrade = null;
+      releaseTrackedGlobalHandles(context);
+      try {
+        requestAbortSignalRef.release();
+      } catch {}
+    },
+    async dispatchRequest(request, dispatchOptions) {
+      if (serveState.pendingUpgrade) {
+        const oldConnectionId = serveState.pendingUpgrade.connectionId;
+        context.evalSync(`globalThis.__upgradeRegistry__.delete("${oldConnectionId}")`);
+        serveState.pendingUpgrade = null;
+      }
+      const hasHandler = context.evalSync(`!!globalThis.__serveOptions__?.fetch`);
+      if (!hasHandler) {
+        throw new Error("No serve() handler registered");
+      }
+      const forwardedSignal = dispatchOptions?.signal ?? request.signal;
+      const forwardedSignalInitiallyAborted = forwardedSignal?.aborted ?? false;
+      let requestStreamId = null;
+      let requestInstanceId = null;
+      let streamCleanup = null;
+      let onForwardedSignalAbort;
+      const canHaveBody = !["GET", "HEAD"].includes(request.method.toUpperCase());
+      if (canHaveBody && request.body) {
+        requestStreamId = streamRegistry.create();
+        streamCleanup = import_stream_state.startNativeStreamReader(request.body, requestStreamId, streamRegistry);
+      }
+      try {
+        const headersArray = Array.from(request.headers.entries());
+        requestInstanceId = nextInstanceId++;
+        const requestState = {
+          url: request.url,
+          method: request.method,
+          headers: headersArray,
+          body: null,
+          bodyUsed: false,
+          streamId: requestStreamId,
+          signalAborted: forwardedSignalInitiallyAborted,
+          mode: request.mode,
+          credentials: request.credentials,
+          cache: request.cache,
+          redirect: request.redirect,
+          referrer: request.referrer,
+          integrity: request.integrity
+        };
+        stateMap.set(requestInstanceId, requestState);
+        if (forwardedSignal && !forwardedSignalInitiallyAborted) {
+          onForwardedSignalAbort = () => {
+            if (requestInstanceId == null)
+              return;
+            const currentState = stateMap.get(requestInstanceId);
+            if (!currentState || currentState.signalAborted) {
+              return;
+            }
+            currentState.signalAborted = true;
+            try {
+              requestAbortSignalRef.applyIgnored(undefined, [requestInstanceId], {
+                arguments: { copy: true }
+              });
+            } catch {}
+          };
+          forwardedSignal.addEventListener("abort", onForwardedSignalAbort, { once: true });
+          if (forwardedSignal.aborted) {
+            onForwardedSignalAbort();
+          }
+        }
+        const responseInstanceId = await context.eval(`
+          (async function() {
+            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 });
+        const responseState = stateMap.get(responseInstanceId);
+        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 hasNullBodyStatus2 = responseState.status === 101 || responseState.status === 103 || responseState.status === 204 || responseState.status === 205 || responseState.status === 304;
+            const response2 = new Response(hasNullBodyStatus2 ? null : 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;
+          const pumpedStream = new ReadableStream({
+            async pull(controller) {
+              if (streamDone)
+                return;
+              while (!streamDone) {
+                const state = streamRegistry.get(responseStreamId);
+                if (!state) {
+                  controller.close();
+                  streamDone = true;
+                  return;
+                }
+                if (state.queue.length > 0 || state.closed || state.errored) {
+                  break;
+                }
+                await new Promise((r) => setTimeout(r, 1));
+              }
+              try {
+                const result = await streamRegistry.pull(responseStreamId);
+                if (result.done) {
+                  controller.close();
+                  streamDone = true;
+                  streamRegistry.delete(responseStreamId);
+                  return;
+                }
+                controller.enqueue(result.value);
+              } catch (error) {
+                controller.error(error);
+                streamDone = true;
+                streamRegistry.delete(responseStreamId);
+              }
+            },
+            cancel() {
+              streamDone = true;
+              streamRegistry.cancel(responseStreamId);
+            }
+          });
+          const responseHeaders2 = new Headers(responseState.headers);
+          const status2 = responseState.status === 101 ? 200 : responseState.status;
+          const hasNullBodyStatus2 = responseState.status === 101 || responseState.status === 103 || responseState.status === 204 || responseState.status === 205 || responseState.status === 304;
+          if (hasNullBodyStatus2) {
+            streamRegistry.cancel(responseStreamId);
+            streamRegistry.delete(responseStreamId);
+          }
+          const response2 = new Response(hasNullBodyStatus2 ? null : pumpedStream, {
+            status: status2,
+            statusText: responseState.statusText,
+            headers: responseHeaders2
+          });
+          response2._originalStatus = responseState.status;
+          return response2;
+        }
+        const responseHeaders = new Headers(responseState.headers);
+        const hasNullBodyStatus = responseState.status === 101 || responseState.status === 103 || responseState.status === 204 || responseState.status === 205 || responseState.status === 304;
+        const responseBody = hasNullBodyStatus ? null : responseState.body;
+        const status = responseState.status === 101 ? 200 : responseState.status;
+        const response = new Response(responseBody, {
+          status,
+          statusText: responseState.statusText,
+          headers: responseHeaders
+        });
+        response._originalStatus = responseState.status;
+        return response;
+      } finally {
+        if (forwardedSignal && onForwardedSignalAbort) {
+          forwardedSignal.removeEventListener("abort", onForwardedSignalAbort);
+        }
+        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();
+        }
+      }
+    },
+    getUpgradeRequest() {
+      const result = serveState.pendingUpgrade;
+      return result;
+    },
+    dispatchWebSocketOpen(connectionId) {
+      serveState.activeConnections.set(connectionId, { connectionId });
+      const hasOpenHandler = context.evalSync(`!!globalThis.__serveOptions__?.websocket?.open`);
+      context.evalSync(`
+        (function() {
+          const ws = new __ServerWebSocket__("${connectionId}");
+          globalThis.__activeWs_${connectionId}__ = ws;
+        })()
+      `);
+      if (hasOpenHandler) {
+        context.evalSync(`
+          (function() {
+            const ws = globalThis.__activeWs_${connectionId}__;
+            __serveOptions__.websocket.open(ws);
+          })()
+        `);
+      }
+      if (serveState.pendingUpgrade?.connectionId === connectionId) {
+        serveState.pendingUpgrade = null;
+      }
+    },
+    dispatchWebSocketMessage(connectionId, message) {
+      if (!serveState.activeConnections.has(connectionId)) {
+        return;
+      }
+      const hasMessageHandler = context.evalSync(`!!globalThis.__serveOptions__?.websocket?.message`);
+      if (!hasMessageHandler) {
+        return;
+      }
+      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")}");
+          })()
+        `);
+      } else {
+        const bytes = Array.from(new Uint8Array(message));
+        context.evalSync(`
+          (function() {
+            const ws = globalThis.__activeWs_${connectionId}__;
+            if (ws) {
+              const bytes = new Uint8Array([${bytes.join(",")}]);
+              __serveOptions__.websocket.message(ws, bytes.buffer);
+            }
+          })()
+        `);
+      }
+    },
+    dispatchWebSocketClose(connectionId, code, reason) {
+      if (!serveState.activeConnections.has(connectionId)) {
+        return;
+      }
+      context.evalSync(`
+        (function() {
+          const ws = globalThis.__activeWs_${connectionId}__;
+          if (ws) ws._setReadyState(3);
+        })()
+      `);
+      const hasCloseHandler = context.evalSync(`!!globalThis.__serveOptions__?.websocket?.close`);
+      if (hasCloseHandler) {
+        const safeReason = reason.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
+        context.evalSync(`
+          (function() {
+            const ws = globalThis.__activeWs_${connectionId}__;
+            if (ws) __serveOptions__.websocket.close(ws, ${code}, "${safeReason}");
+          })()
+        `);
+      }
+      context.evalSync(`
+        delete globalThis.__activeWs_${connectionId}__;
+        globalThis.__upgradeRegistry__.delete("${connectionId}");
+      `);
+      serveState.activeConnections.delete(connectionId);
+    },
+    dispatchWebSocketError(connectionId, error) {
+      if (!serveState.activeConnections.has(connectionId)) {
+        return;
+      }
+      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");
+      context.evalSync(`
+        (function() {
+          const ws = globalThis.__activeWs_${connectionId}__;
+          if (ws) {
+            const error = { name: "${safeName}", message: "${safeMessage}" };
+            __serveOptions__.websocket.error(ws, error);
+          }
+        })()
+      `);
+    },
+    onWebSocketCommand(callback) {
+      wsCommandCallbacks.add(callback);
+      return () => wsCommandCallbacks.delete(callback);
+    },
+    hasServeHandler() {
+      return context.evalSync(`!!globalThis.__serveOptions__?.fetch`);
+    },
+    hasActiveConnections() {
+      return serveState.activeConnections.size > 0;
+    },
+    dispatchClientWebSocketOpen(socketId, protocol, extensions) {
+      const safeProtocol = protocol.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+      const safeExtensions = extensions.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+      context.evalSync(`
+        __dispatchClientWebSocketEvent("${socketId}", "open", {
+          protocol: "${safeProtocol}",
+          extensions: "${safeExtensions}"
+        });
+      `);
+    },
+    dispatchClientWebSocketMessage(socketId, data) {
+      if (typeof data === "string") {
+        const safeData = data.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+        context.evalSync(`
+          __dispatchClientWebSocketEvent("${socketId}", "message", { data: "${safeData}" });
+        `);
+      } else {
+        const bytes = new Uint8Array(data);
+        let binary = "";
+        for (let i = 0;i < bytes.byteLength; i++) {
+          binary += String.fromCharCode(bytes[i]);
+        }
+        const base64 = Buffer.from(binary, "binary").toString("base64");
+        context.evalSync(`
+          __dispatchClientWebSocketEvent("${socketId}", "message", { data: "__BINARY__${base64}" });
+        `);
+      }
+    },
+    dispatchClientWebSocketClose(socketId, code, reason, wasClean) {
+      const safeReason = reason.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
+      context.evalIgnored(`
+        __dispatchClientWebSocketEvent("${socketId}", "close", {
+          code: ${code},
+          reason: "${safeReason}",
+          wasClean: ${wasClean}
+        });
+      `);
+    },
+    dispatchClientWebSocketError(socketId) {
+      context.evalIgnored(`
+        __dispatchClientWebSocketEvent("${socketId}", "error", {});
+      `);
+    },
+    onClientWebSocketCommand(callback) {
+      clientWsCommandCallbacks.add(callback);
+      return () => clientWsCommandCallbacks.delete(callback);
+    },
+    onEvent(callback) {
+      eventCallbacks.add(callback);
+      return () => eventCallbacks.delete(callback);
+    },
+    dispatchEvent(event, payload) {
+      const json = JSON.stringify(payload);
+      const safeEvent = JSON.stringify(event);
+      const safeJson = JSON.stringify(json);
+      context.evalSync(`__dispatchExternalEvent(${safeEvent}, ${safeJson});`);
+    }
+  };
+}
+
+//# debugId=C7AE0924BFE61B3564756E2164756E21