@ricsam/isolate-fetch 0.1.12 → 0.1.14

package/dist/cjs/index.cjs

@@ -124,25 +124,32 @@ var headersCode = `
     }
 
     forEach(callback, thisArg) {
-      for (const [key, [originalName, values]] of this.#headers) {
-        callback.call(thisArg, values.join(', '), originalName, this);
+      const sortedKeys = [...this.#headers.keys()].sort();
+      for (const key of sortedKeys) {
+        const [, values] = this.#headers.get(key);
+        callback.call(thisArg, values.join(', '), key, this);
       }
     }
 
     *entries() {
-      for (const [key, [name, values]] of this.#headers) {
-        yield [name, values.join(', ')];
+      const sortedKeys = [...this.#headers.keys()].sort();
+      for (const key of sortedKeys) {
+        const [, values] = this.#headers.get(key);
+        yield [key, values.join(', ')];
       }
     }
 
     *keys() {
-      for (const [key, [name]] of this.#headers) {
-        yield name;
+      const sortedKeys = [...this.#headers.keys()].sort();
+      for (const key of sortedKeys) {
+        yield key;
       }
     }
 
     *values() {
-      for (const [key, [name, values]] of this.#headers) {
+      const sortedKeys = [...this.#headers.keys()].sort();
+      for (const key of sortedKeys) {
+        const [, values] = this.#headers.get(key);
         yield values.join(', ');
       }
     }
@@ -410,6 +417,9 @@ function setupStreamCallbacks(context, streamRegistry) {
   global.setSync("__Stream_isQueueFull", new import_isolated_vm.default.Callback((streamId) => {
     return streamRegistry.isQueueFull(streamId);
   }));
+  global.setSync("__Stream_cancel", new import_isolated_vm.default.Callback((streamId) => {
+    streamRegistry.cancel(streamId);
+  }));
   const pullRef = new import_isolated_vm.default.Reference(async (streamId) => {
     const result = await streamRegistry.pull(streamId);
     if (result.done) {
@@ -460,7 +470,7 @@ var hostBackedStreamCode = `
         async pull(controller) {
           if (closed) return;
 
-          const resultJson = __Stream_pull_ref.applySyncPromise(undefined, [streamId]);
+          const resultJson = await __Stream_pull_ref.apply(undefined, [streamId], { result: { promise: true, copy: true } });
           const result = JSON.parse(resultJson);
 
           if (result.done) {
@@ -472,7 +482,7 @@ var hostBackedStreamCode = `
         },
         cancel(reason) {
           closed = true;
-          __Stream_error(streamId, String(reason || "cancelled"));
+          __Stream_cancel(streamId);
         }
       });
 
@@ -499,7 +509,7 @@ var hostBackedStreamCode = `
   globalThis.HostBackedReadableStream = HostBackedReadableStream;
 })();
 `;
-function setupResponse(context, stateMap) {
+function setupResponse(context, stateMap, streamRegistry) {
   const global = context.global;
   global.setSync("__Response_construct", new import_isolated_vm.default.Callback((bodyBytes, status, statusText, headers) => {
     const instanceId = nextInstanceId++;
@@ -579,6 +589,10 @@ function setupResponse(context, stateMap) {
     const state = stateMap.get(instanceId);
     return state?.type ?? "default";
   }));
+  global.setSync("__Response_get_nullBody", new import_isolated_vm.default.Callback((instanceId) => {
+    const state = stateMap.get(instanceId);
+    return state?.nullBody ?? false;
+  }));
   global.setSync("__Response_setType", new import_isolated_vm.default.Callback((instanceId, type) => {
     const state = stateMap.get(instanceId);
     if (state) {
@@ -612,6 +626,38 @@ function setupResponse(context, stateMap) {
     if (!state) {
       throw new Error("[TypeError]Cannot clone invalid Response");
     }
+    if (state.streamId !== null) {
+      const streamId1 = streamRegistry.create();
+      const streamId2 = streamRegistry.create();
+      const origStreamId = state.streamId;
+      (async () => {
+        try {
+          while (true) {
+            const result = await streamRegistry.pull(origStreamId);
+            if (result.done) {
+              streamRegistry.close(streamId1);
+              streamRegistry.close(streamId2);
+              break;
+            }
+            streamRegistry.push(streamId1, new Uint8Array(result.value));
+            streamRegistry.push(streamId2, new Uint8Array(result.value));
+          }
+        } catch (err) {
+          streamRegistry.error(streamId1, err);
+          streamRegistry.error(streamId2, err);
+        }
+      })();
+      state.streamId = streamId1;
+      const newId2 = nextInstanceId++;
+      const newState2 = {
+        ...state,
+        streamId: streamId2,
+        body: state.body ? new Uint8Array(state.body) : null,
+        bodyUsed: false
+      };
+      stateMap.set(newId2, newState2);
+      return newId2;
+    }
     const newId = nextInstanceId++;
     const newState = {
       ...state,
@@ -838,6 +884,11 @@ function setupResponse(context, stateMap) {
     }
 
     get body() {
+      // Null-body responses (204, 304, HEAD) must return null
+      if (__Response_get_nullBody(this.#instanceId)) {
+        return null;
+      }
+
       // Return cached body if available (WHATWG spec requires same object on repeated access)
       if (this.#cachedBody !== null) {
         return this.#cachedBody;
@@ -869,6 +920,26 @@ function setupResponse(context, stateMap) {
       } catch (err) {
         throw __decodeError(err);
       }
+      if (__Response_get_nullBody(this.#instanceId)) {
+        return "";
+      }
+      if (this.#streamId !== null) {
+        const reader = this.body.getReader();
+        const chunks = [];
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value) chunks.push(value);
+        }
+        const totalLength = chunks.reduce((acc, c) => acc + c.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          result.set(chunk, offset);
+          offset += chunk.length;
+        }
+        return new TextDecoder().decode(result);
+      }
       return __Response_text(this.#instanceId);
     }
 
@@ -1119,30 +1190,10 @@ function setupRequest(context, stateMap) {
       return Array.from(new TextEncoder().encode(body.toString()));
     }
     if (body instanceof FormData) {
-      // Check if FormData has any File/Blob entries
-      let hasFiles = false;
-      for (const [, value] of body.entries()) {
-        if (value instanceof File || value instanceof Blob) {
-          hasFiles = true;
-          break;
-        }
-      }
-
-      if (hasFiles) {
-        // Serialize as multipart/form-data
-        const { body: bytes, contentType } = __serializeFormData(body);
-        globalThis.__pendingFormDataContentType = contentType;
-        return Array.from(bytes);
-      }
-
-      // URL-encoded for string-only FormData
-      const parts = [];
-      body.forEach((value, key) => {
-        if (typeof value === 'string') {
-          parts.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));
-        }
-      });
-      return Array.from(new TextEncoder().encode(parts.join('&')));
+      // Always serialize as multipart/form-data per spec
+      const { body: bytes, contentType } = __serializeFormData(body);
+      globalThis.__pendingFormDataContentType = contentType;
+      return Array.from(bytes);
     }
     // Try to convert to string
     return Array.from(new TextEncoder().encode(String(body)));
@@ -1240,7 +1291,7 @@ function setupRequest(context, stateMap) {
       if (globalThis.__pendingFormDataContentType) {
         headers.set('content-type', globalThis.__pendingFormDataContentType);
         delete globalThis.__pendingFormDataContentType;
-      } else if (body instanceof FormData && !headers.has('content-type')) {
+      } else if (body instanceof URLSearchParams && !headers.has('content-type')) {
         headers.set('content-type', 'application/x-www-form-urlencoded');
       }
 
@@ -1430,32 +1481,62 @@ function setupRequest(context, stateMap) {
 var FETCH_STREAM_THRESHOLD = 64 * 1024;
 function setupFetchFunction(context, stateMap, streamRegistry, options) {
   const global = context.global;
-  const fetchRef = new import_isolated_vm.default.Reference(async (url, method, headersJson, bodyJson, signalAborted) => {
+  const fetchAbortControllers = new Map;
+  global.setSync("__fetch_abort", new import_isolated_vm.default.Callback((fetchId) => {
+    const controller = fetchAbortControllers.get(fetchId);
+    if (controller) {
+      setImmediate(() => controller.abort());
+    }
+  }));
+  const fetchRef = new import_isolated_vm.default.Reference(async (url, method, headersJson, bodyJson, signalAborted, fetchId) => {
     if (signalAborted) {
       throw new Error("[AbortError]The operation was aborted.");
     }
+    const hostController = new AbortController;
+    fetchAbortControllers.set(fetchId, hostController);
     const headers = JSON.parse(headersJson);
     const bodyBytes = bodyJson ? JSON.parse(bodyJson) : null;
-    const body = bodyBytes ? new Uint8Array(bodyBytes) : null;
-    const nativeRequest = new Request(url, {
+    const rawBody = bodyBytes ? new Uint8Array(bodyBytes) : null;
+    const init = {
       method,
       headers,
-      body
-    });
-    const onFetch = options?.onFetch ?? fetch;
-    const nativeResponse = await onFetch(nativeRequest);
-    const contentLength = nativeResponse.headers.get("content-length");
-    const knownSize = contentLength ? parseInt(contentLength, 10) : null;
-    const isCallbackStream = nativeResponse.__isCallbackStream;
-    const isNetworkResponse = nativeResponse.url && (nativeResponse.url.startsWith("http://") || nativeResponse.url.startsWith("https://"));
-    const shouldStream = nativeResponse.body && (isCallbackStream || isNetworkResponse && (knownSize === null || knownSize > FETCH_STREAM_THRESHOLD));
-    if (shouldStream && nativeResponse.body) {
-      if (isCallbackStream) {
-        const streamId2 = streamRegistry.create();
-        const passthruMap = getPassthruBodiesForContext(context);
-        passthruMap.set(streamId2, nativeResponse.body);
-        const instanceId3 = nextInstanceId++;
-        const state3 = {
+      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()),
@@ -1464,65 +1545,37 @@ function setupFetchFunction(context, stateMap, streamRegistry, options) {
           type: "default",
           url: nativeResponse.url,
           redirected: nativeResponse.redirected,
-          streamId: streamId2
+          streamId,
+          nullBody: isNullBody
         };
-        stateMap.set(instanceId3, state3);
-        return instanceId3;
+        stateMap.set(instanceId2, state2);
+        return instanceId2;
       }
-      const streamId = streamRegistry.create();
-      const instanceId2 = nextInstanceId++;
-      const state2 = {
+      const responseBody = await nativeResponse.arrayBuffer();
+      const responseBodyArray = Array.from(new Uint8Array(responseBody));
+      const instanceId = nextInstanceId++;
+      const state = {
         status: nativeResponse.status,
         statusText: nativeResponse.statusText,
         headers: Array.from(nativeResponse.headers.entries()),
-        body: new Uint8Array(0),
+        body: new Uint8Array(responseBodyArray),
         bodyUsed: false,
         type: "default",
         url: nativeResponse.url,
         redirected: nativeResponse.redirected,
-        streamId
+        streamId: null,
+        nullBody: isNullBody
       };
-      stateMap.set(instanceId2, state2);
-      const reader = nativeResponse.body.getReader();
-      (async () => {
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              streamRegistry.close(streamId);
-              break;
-            }
-            if (value) {
-              while (streamRegistry.isQueueFull(streamId)) {
-                await new Promise((r) => setTimeout(r, 1));
-              }
-              streamRegistry.push(streamId, value);
-            }
-          }
-        } catch (err) {
-          streamRegistry.error(streamId, err);
-        } finally {
-          reader.releaseLock();
-        }
-      })();
-      return instanceId2;
+      stateMap.set(instanceId, state);
+      return instanceId;
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error("[AbortError]The operation was aborted.");
+      }
+      throw err;
+    } finally {
+      fetchAbortControllers.delete(fetchId);
     }
-    const responseBody = await nativeResponse.arrayBuffer();
-    const responseBodyArray = Array.from(new Uint8Array(responseBody));
-    const instanceId = nextInstanceId++;
-    const state = {
-      status: nativeResponse.status,
-      statusText: nativeResponse.statusText,
-      headers: Array.from(nativeResponse.headers.entries()),
-      body: new Uint8Array(responseBodyArray),
-      bodyUsed: false,
-      type: "default",
-      url: nativeResponse.url,
-      redirected: nativeResponse.redirected,
-      streamId: null
-    };
-    stateMap.set(instanceId, state);
-    return instanceId;
   });
   global.setSync("__fetch_ref", fetchRef);
   const fetchCode = `
@@ -1540,7 +1593,28 @@ function setupFetchFunction(context, stateMap, streamRegistry, options) {
     return err;
   }
 
-  globalThis.fetch = function(input, init = {}) {
+  let __nextFetchId = 1;
+
+  globalThis.fetch = async function(input, init = {}) {
+    // Handle Blob and ReadableStream bodies before creating Request
+    if (init.body instanceof Blob && !(init.body instanceof File)) {
+      const buf = await init.body.arrayBuffer();
+      init = Object.assign({}, init, { body: new Uint8Array(buf) });
+    } else if (init.body instanceof ReadableStream) {
+      const reader = init.body.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+      const total = chunks.reduce((s, c) => s + c.length, 0);
+      const buf = new Uint8Array(total);
+      let off = 0;
+      for (const c of chunks) { buf.set(c, off); off += c.length; }
+      init = Object.assign({}, init, { body: buf });
+    }
+
     // Create Request from input
     const request = input instanceof Request ? input : new Request(input, init);
 
@@ -1548,20 +1622,34 @@ function setupFetchFunction(context, stateMap, streamRegistry, options) {
     const signal = init.signal ?? request.signal;
     const signalAborted = signal?.aborted ?? false;
 
+    // Assign a fetch ID for abort tracking
+    const fetchId = __nextFetchId++;
+
+    // Register abort listener if signal exists
+    if (signal && !signalAborted) {
+      signal.addEventListener('abort', () => { __fetch_abort(fetchId); });
+    }
+
     // Serialize headers and body to JSON for transfer
     const headersJson = JSON.stringify(Array.from(request.headers.entries()));
     const bodyBytes = request._getBodyBytes();
     const bodyJson = bodyBytes ? JSON.stringify(bodyBytes) : null;
 
+    // Short-circuit: if signal is already aborted, throw without calling host
+    if (signalAborted) {
+      throw new DOMException('The operation was aborted.', 'AbortError');
+    }
+
     // Call host - returns just the response instance ID
     try {
-      const instanceId = __fetch_ref.applySyncPromise(undefined, [
+      const instanceId = await __fetch_ref.apply(undefined, [
         request.url,
         request.method,
         headersJson,
         bodyJson,
-        signalAborted
-      ]);
+        signalAborted,
+        fetchId
+      ], { result: { promise: true, copy: true } });
 
       // Construct Response from the instance ID
       return Response._fromInstanceId(instanceId);
@@ -1656,6 +1744,373 @@ function setupServerWebSocket(context, wsCommandCallbacks) {
 })();
   `);
 }
+function setupClientWebSocket(context, clientWsCommandCallbacks) {
+  const global = context.global;
+  global.setSync("__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);
+  }));
+  global.setSync("__WebSocket_send", new import_isolated_vm.default.Callback((socketId, data) => {
+    const cmd = { type: "send", socketId, data };
+    for (const cb of clientWsCommandCallbacks)
+      cb(cmd);
+  }));
+  global.setSync("__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() {
@@ -1678,7 +2133,7 @@ async function setupFetch(context, options) {
   context.evalSync(multipartCode);
   setupStreamCallbacks(context, streamRegistry);
   context.evalSync(hostBackedStreamCode);
-  setupResponse(context, stateMap);
+  setupResponse(context, stateMap, streamRegistry);
   setupRequest(context, stateMap);
   setupFetchFunction(context, stateMap, streamRegistry, options);
   const serveState = {
@@ -1686,9 +2141,11 @@ async function setupFetch(context, options) {
     activeConnections: new Map
   };
   const wsCommandCallbacks = new Set;
+  const clientWsCommandCallbacks = new Set;
   setupServer(context, serveState);
   setupServerWebSocket(context, wsCommandCallbacks);
   setupServe(context);
+  setupClientWebSocket(context, clientWsCommandCallbacks);
   return {
     dispose() {
       stateMap.clear();
@@ -1801,8 +2258,7 @@ async function setupFetch(context, options) {
             },
             cancel() {
               streamDone = true;
-              streamRegistry.error(responseStreamId, new Error("Stream cancelled"));
-              streamRegistry.delete(responseStreamId);
+              streamRegistry.cancel(responseStreamId);
             }
           });
           const responseHeaders2 = new Headers(responseState.headers);
@@ -1947,8 +2403,55 @@ async function setupFetch(context, options) {
     },
     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);
     }
   };
 }
 
-//# debugId=B1E0412945057BF364756E2164756E21
+//# debugId=7837D23CACB6E1A364756E2164756E21