@ricsam/isolate-client 0.1.1 → 0.1.5

package/dist/cjs/connection.cjs

@@ -35,7 +35,9 @@ __export(exports_connection, {
 module.exports = __toCommonJS(exports_connection);
 var import_node_net = require("net");
 var import_isolate_protocol = require("@ricsam/isolate-protocol");
+var import_client = require("@ricsam/isolate-playwright/client");
 var DEFAULT_TIMEOUT = 30000;
+var isolateWsCallbacks = new Map;
 async function connect(options = {}) {
   const socket = await createSocket(options);
   const state = {
@@ -44,8 +46,10 @@ async function connect(options = {}) {
     callbacks: new Map,
     nextRequestId: 1,
     nextCallbackId: 1,
+    nextStreamId: 1,
     connected: true,
-    playwrightEventHandlers: new Map
+    streamResponses: new Map,
+    uploadStreams: new Map
   };
   const parser = import_isolate_protocol.createFrameParser();
   socket.on("data", (data) => {
@@ -140,21 +144,157 @@ function handleMessage(message, state) {
     }
     case import_isolate_protocol.MessageType.PONG:
       break;
-    case import_isolate_protocol.MessageType.PLAYWRIGHT_EVENT: {
-      const event = message;
-      const handler = state.playwrightEventHandlers.get(event.isolateId);
-      if (handler) {
-        switch (event.eventType) {
-          case "consoleLog":
-            handler.onConsoleLog?.(event.payload);
-            break;
-          case "networkRequest":
-            handler.onNetworkRequest?.(event.payload);
-            break;
-          case "networkResponse":
-            handler.onNetworkResponse?.(event.payload);
-            break;
+    case import_isolate_protocol.MessageType.WS_COMMAND: {
+      const msg = message;
+      const callbacks = isolateWsCallbacks.get(msg.isolateId);
+      if (callbacks) {
+        let data;
+        if (msg.command.data instanceof Uint8Array) {
+          data = msg.command.data.buffer.slice(msg.command.data.byteOffset, msg.command.data.byteOffset + msg.command.data.byteLength);
+        } else {
+          data = msg.command.data;
         }
+        const cmd = {
+          type: msg.command.type,
+          connectionId: msg.command.connectionId,
+          data,
+          code: msg.command.code,
+          reason: msg.command.reason
+        };
+        for (const cb of callbacks) {
+          cb(cmd);
+        }
+      }
+      break;
+    }
+    case import_isolate_protocol.MessageType.RESPONSE_STREAM_START: {
+      const msg = message;
+      const receiver = {
+        streamId: msg.streamId,
+        requestId: msg.requestId,
+        metadata: msg.metadata,
+        controller: null,
+        state: "active",
+        pendingChunks: []
+      };
+      const readableStream = new ReadableStream({
+        start(controller) {
+          receiver.controller = controller;
+        },
+        pull(_controller) {
+          while (receiver.pendingChunks.length > 0) {
+            const chunk = receiver.pendingChunks.shift();
+            receiver.controller.enqueue(chunk);
+          }
+          if (receiver.state === "closed") {
+            receiver.controller.close();
+            return;
+          }
+          if (receiver.state === "errored") {
+            return;
+          }
+          sendMessage(state.socket, {
+            type: import_isolate_protocol.MessageType.STREAM_PULL,
+            streamId: msg.streamId,
+            maxBytes: import_isolate_protocol.STREAM_DEFAULT_CREDIT
+          });
+          return new Promise((resolve) => {
+            receiver.pullResolver = resolve;
+          });
+        },
+        cancel(_reason) {
+          receiver.state = "errored";
+          sendMessage(state.socket, {
+            type: import_isolate_protocol.MessageType.STREAM_ERROR,
+            streamId: msg.streamId,
+            error: "Stream cancelled by consumer"
+          });
+          state.streamResponses.delete(msg.streamId);
+        }
+      });
+      state.streamResponses.set(msg.streamId, receiver);
+      const pending = state.pendingRequests.get(msg.requestId);
+      if (pending) {
+        state.pendingRequests.delete(msg.requestId);
+        if (pending.timeoutId)
+          clearTimeout(pending.timeoutId);
+        const response = new Response(readableStream, {
+          status: msg.metadata?.status ?? 200,
+          statusText: msg.metadata?.statusText ?? "OK",
+          headers: msg.metadata?.headers
+        });
+        pending.resolve({ response, __streaming: true });
+      }
+      sendMessage(state.socket, {
+        type: import_isolate_protocol.MessageType.STREAM_PULL,
+        streamId: msg.streamId,
+        maxBytes: import_isolate_protocol.STREAM_DEFAULT_CREDIT
+      });
+      break;
+    }
+    case import_isolate_protocol.MessageType.RESPONSE_STREAM_CHUNK: {
+      const msg = message;
+      const receiver = state.streamResponses.get(msg.streamId);
+      if (receiver && receiver.state === "active") {
+        if (receiver.pullResolver) {
+          receiver.controller.enqueue(msg.chunk);
+          const resolver = receiver.pullResolver;
+          receiver.pullResolver = undefined;
+          resolver();
+        } else {
+          receiver.pendingChunks.push(msg.chunk);
+        }
+      }
+      break;
+    }
+    case import_isolate_protocol.MessageType.RESPONSE_STREAM_END: {
+      const msg = message;
+      const receiver = state.streamResponses.get(msg.streamId);
+      if (receiver) {
+        receiver.state = "closed";
+        while (receiver.pendingChunks.length > 0) {
+          const chunk = receiver.pendingChunks.shift();
+          receiver.controller.enqueue(chunk);
+        }
+        receiver.controller.close();
+        if (receiver.pullResolver) {
+          const resolver = receiver.pullResolver;
+          receiver.pullResolver = undefined;
+          resolver();
+        }
+        state.streamResponses.delete(msg.streamId);
+      }
+      break;
+    }
+    case import_isolate_protocol.MessageType.STREAM_PULL: {
+      const msg = message;
+      const session = state.uploadStreams.get(msg.streamId);
+      if (session) {
+        session.credit += msg.maxBytes;
+        if (session.creditResolver) {
+          session.creditResolver();
+          session.creditResolver = undefined;
+        }
+      }
+      break;
+    }
+    case import_isolate_protocol.MessageType.STREAM_ERROR: {
+      const msg = message;
+      const uploadSession = state.uploadStreams.get(msg.streamId);
+      if (uploadSession) {
+        uploadSession.state = "closed";
+        state.uploadStreams.delete(msg.streamId);
+      }
+      const receiver = state.streamResponses.get(msg.streamId);
+      if (receiver) {
+        receiver.state = "errored";
+        receiver.controller.error(new Error(msg.error));
+        if (receiver.pullResolver) {
+          const resolver = receiver.pullResolver;
+          receiver.pullResolver = undefined;
+          resolver();
+        }
+        state.streamResponses.delete(msg.streamId);
       }
       break;
     }
@@ -222,64 +362,291 @@ async function createRuntime(state, options = {}) {
   if (options.fs) {
     callbacks.fs = registerFsCallbacks(state, options.fs);
   }
+  if (options.moduleLoader) {
+    callbacks.moduleLoader = registerModuleLoaderCallback(state, options.moduleLoader);
+  }
+  if (options.customFunctions) {
+    callbacks.custom = registerCustomFunctions(state, options.customFunctions);
+  }
+  let playwrightHandler;
+  if (options.playwright) {
+    playwrightHandler = import_client.createPlaywrightHandler(options.playwright.page, {
+      timeout: options.playwright.timeout,
+      baseUrl: options.playwright.baseUrl
+    });
+    const handlerCallbackId = state.nextCallbackId++;
+    state.callbacks.set(handlerCallbackId, async (opJson) => {
+      const op = JSON.parse(opJson);
+      const result2 = await playwrightHandler(op);
+      return JSON.stringify(result2);
+    });
+    const hasOnEvent = !!options.playwright.onEvent;
+    const hasConsoleHandler = options.playwright.console && options.console?.onEntry;
+    let browserConsoleLogCallbackId;
+    if (hasOnEvent || hasConsoleHandler) {
+      browserConsoleLogCallbackId = registerEventCallback(state, (entry) => {
+        const browserEntry = entry;
+        if (options.playwright.onEvent) {
+          options.playwright.onEvent({
+            type: "browserConsoleLog",
+            level: browserEntry.level,
+            args: browserEntry.args,
+            timestamp: browserEntry.timestamp
+          });
+        }
+        if (options.playwright.console && options.console?.onEntry) {
+          options.console.onEntry({
+            type: "browserOutput",
+            level: browserEntry.level,
+            args: browserEntry.args,
+            timestamp: browserEntry.timestamp
+          });
+        }
+      });
+    }
+    let networkRequestCallbackId;
+    if (hasOnEvent) {
+      networkRequestCallbackId = registerEventCallback(state, (info) => {
+        const reqInfo = info;
+        options.playwright.onEvent({
+          type: "networkRequest",
+          url: reqInfo.url,
+          method: reqInfo.method,
+          headers: reqInfo.headers,
+          postData: reqInfo.postData,
+          resourceType: reqInfo.resourceType,
+          timestamp: reqInfo.timestamp
+        });
+      });
+    }
+    let networkResponseCallbackId;
+    if (hasOnEvent) {
+      networkResponseCallbackId = registerEventCallback(state, (info) => {
+        const resInfo = info;
+        options.playwright.onEvent({
+          type: "networkResponse",
+          url: resInfo.url,
+          status: resInfo.status,
+          statusText: resInfo.statusText,
+          headers: resInfo.headers,
+          timestamp: resInfo.timestamp
+        });
+      });
+    }
+    callbacks.playwright = {
+      handlerCallbackId,
+      console: options.playwright.console && !options.console?.onEntry,
+      onBrowserConsoleLogCallbackId: browserConsoleLogCallbackId,
+      onNetworkRequestCallbackId: networkRequestCallbackId,
+      onNetworkResponseCallbackId: networkResponseCallbackId
+    };
+  }
+  let testEnvironmentOption;
+  if (options.testEnvironment) {
+    if (typeof options.testEnvironment === "object") {
+      const testEnvOptions = options.testEnvironment;
+      const testEnvCallbacks = {};
+      if (testEnvOptions.onEvent) {
+        const userOnEvent = testEnvOptions.onEvent;
+        const onEventCallbackId = registerEventCallback(state, (eventJson) => {
+          const event = JSON.parse(eventJson);
+          userOnEvent(event);
+        });
+        testEnvCallbacks.onEvent = {
+          callbackId: onEventCallbackId,
+          name: "testEnvironment.onEvent",
+          type: "sync"
+        };
+      }
+      testEnvironmentOption = {
+        callbacks: testEnvCallbacks,
+        testTimeout: testEnvOptions.testTimeout
+      };
+    } else {
+      testEnvironmentOption = true;
+    }
+  }
   const requestId = state.nextRequestId++;
   const request = {
     type: import_isolate_protocol.MessageType.CREATE_RUNTIME,
     requestId,
     options: {
-      memoryLimit: options.memoryLimit,
-      callbacks
+      memoryLimitMB: options.memoryLimitMB,
+      cwd: options.cwd,
+      callbacks,
+      testEnvironment: testEnvironmentOption
     }
   };
   const result = await sendRequest(state, request);
   const isolateId = result.isolateId;
-  return {
-    isolateId,
-    eval: async (code, filename) => {
+  const wsCommandCallbacks = new Set;
+  isolateWsCallbacks.set(isolateId, wsCommandCallbacks);
+  const fetchHandle = {
+    async dispatchRequest(req, opts) {
+      const reqId = state.nextRequestId++;
+      const serialized = await serializeRequestWithStreaming(state, req);
+      const { bodyStream, ...serializableRequest } = serialized;
+      const request2 = {
+        type: import_isolate_protocol.MessageType.DISPATCH_REQUEST,
+        requestId: reqId,
+        isolateId,
+        request: serializableRequest,
+        options: opts
+      };
+      const handleResponse = (res) => {
+        if (res.__streaming && res.response instanceof Response) {
+          return res.response;
+        }
+        return deserializeResponse(res.response);
+      };
+      if (serialized.bodyStreamId !== undefined && bodyStream) {
+        const streamId = serialized.bodyStreamId;
+        const responsePromise = sendRequest(state, request2, opts?.timeout ?? DEFAULT_TIMEOUT);
+        await sendBodyStream(state, streamId, bodyStream);
+        const res = await responsePromise;
+        return handleResponse(res);
+      } else {
+        const res = await sendRequest(state, request2, opts?.timeout ?? DEFAULT_TIMEOUT);
+        return handleResponse(res);
+      }
+    },
+    async getUpgradeRequest() {
       const reqId = state.nextRequestId++;
       const req = {
-        type: import_isolate_protocol.MessageType.EVAL,
+        type: import_isolate_protocol.MessageType.FETCH_GET_UPGRADE_REQUEST,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    },
+    async dispatchWebSocketOpen(connectionId) {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_isolate_protocol.MessageType.WS_OPEN,
         requestId: reqId,
         isolateId,
-        code,
-        filename
+        connectionId
       };
-      const res = await sendRequest(state, req);
-      return res.value;
+      await sendRequest(state, req);
     },
-    dispatchRequest: async (request2, dispatchOptions) => {
+    async dispatchWebSocketMessage(connectionId, message) {
       const reqId = state.nextRequestId++;
-      const serialized = await serializeRequest(request2);
+      const data = message instanceof ArrayBuffer ? new Uint8Array(message) : message;
       const req = {
-        type: import_isolate_protocol.MessageType.DISPATCH_REQUEST,
+        type: import_isolate_protocol.MessageType.WS_MESSAGE,
+        requestId: reqId,
+        isolateId,
+        connectionId,
+        data
+      };
+      await sendRequest(state, req);
+    },
+    async dispatchWebSocketClose(connectionId, code, reason) {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_isolate_protocol.MessageType.WS_CLOSE,
         requestId: reqId,
         isolateId,
-        request: serialized,
-        options: dispatchOptions
+        connectionId,
+        code,
+        reason
       };
-      const res = await sendRequest(state, req, dispatchOptions?.timeout ?? DEFAULT_TIMEOUT);
-      return deserializeResponse(res.response);
+      await sendRequest(state, req);
     },
-    tick: async (ms) => {
+    async dispatchWebSocketError(connectionId, error) {
       const reqId = state.nextRequestId++;
       const req = {
-        type: import_isolate_protocol.MessageType.TICK,
+        type: import_isolate_protocol.MessageType.FETCH_WS_ERROR,
         requestId: reqId,
         isolateId,
-        ms
+        connectionId,
+        error: error.message
       };
       await sendRequest(state, req);
     },
-    setupTestEnvironment: async () => {
+    onWebSocketCommand(callback) {
+      wsCommandCallbacks.add(callback);
+      return () => {
+        wsCommandCallbacks.delete(callback);
+      };
+    },
+    async hasServeHandler() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_isolate_protocol.MessageType.FETCH_HAS_SERVE_HANDLER,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    },
+    async hasActiveConnections() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_isolate_protocol.MessageType.FETCH_HAS_ACTIVE_CONNECTIONS,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    }
+  };
+  const timersHandle = {
+    async clearAll() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_isolate_protocol.MessageType.TIMERS_CLEAR_ALL,
+        requestId: reqId,
+        isolateId
+      };
+      await sendRequest(state, req);
+    }
+  };
+  const consoleHandle = {
+    async reset() {
       const reqId = state.nextRequestId++;
       const req = {
-        type: import_isolate_protocol.MessageType.SETUP_TEST_ENV,
+        type: import_isolate_protocol.MessageType.CONSOLE_RESET,
         requestId: reqId,
         isolateId
       };
       await sendRequest(state, req);
     },
-    runTests: async (timeout) => {
+    async getTimers() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_isolate_protocol.MessageType.CONSOLE_GET_TIMERS,
+        requestId: reqId,
+        isolateId
+      };
+      const result2 = await sendRequest(state, req);
+      return new Map(Object.entries(result2));
+    },
+    async getCounters() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_isolate_protocol.MessageType.CONSOLE_GET_COUNTERS,
+        requestId: reqId,
+        isolateId
+      };
+      const result2 = await sendRequest(state, req);
+      return new Map(Object.entries(result2));
+    },
+    async getGroupDepth() {
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_isolate_protocol.MessageType.CONSOLE_GET_GROUP_DEPTH,
+        requestId: reqId,
+        isolateId
+      };
+      return sendRequest(state, req);
+    }
+  };
+  const testEnvironmentEnabled = !!options.testEnvironment;
+  const playwrightEnabled = !!options.playwright;
+  const testEnvironmentHandle = {
+    async runTests(timeout) {
+      if (!testEnvironmentEnabled) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
       const reqId = state.nextRequestId++;
       const req = {
         type: import_isolate_protocol.MessageType.RUN_TESTS,
@@ -289,47 +656,48 @@ async function createRuntime(state, options = {}) {
       };
       return sendRequest(state, req, timeout ?? DEFAULT_TIMEOUT);
     },
-    setupPlaywright: async (playwrightOptions) => {
+    async hasTests() {
+      if (!testEnvironmentEnabled) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
       const reqId = state.nextRequestId++;
       const req = {
-        type: import_isolate_protocol.MessageType.SETUP_PLAYWRIGHT,
+        type: import_isolate_protocol.MessageType.HAS_TESTS,
         requestId: reqId,
-        isolateId,
-        options: {
-          browserType: playwrightOptions?.browserType,
-          headless: playwrightOptions?.headless,
-          baseURL: playwrightOptions?.baseURL
-        }
+        isolateId
       };
-      if (playwrightOptions?.onConsoleLog || playwrightOptions?.onNetworkRequest || playwrightOptions?.onNetworkResponse) {
-        state.playwrightEventHandlers.set(isolateId, {
-          onConsoleLog: playwrightOptions.onConsoleLog,
-          onNetworkRequest: playwrightOptions.onNetworkRequest,
-          onNetworkResponse: playwrightOptions.onNetworkResponse
-        });
-      }
-      await sendRequest(state, req);
+      return sendRequest(state, req);
     },
-    runPlaywrightTests: async (timeout) => {
+    async getTestCount() {
+      if (!testEnvironmentEnabled) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
       const reqId = state.nextRequestId++;
       const req = {
-        type: import_isolate_protocol.MessageType.RUN_PLAYWRIGHT_TESTS,
+        type: import_isolate_protocol.MessageType.GET_TEST_COUNT,
         requestId: reqId,
-        isolateId,
-        timeout
+        isolateId
       };
-      return sendRequest(state, req, timeout ?? DEFAULT_TIMEOUT);
+      return sendRequest(state, req);
     },
-    resetPlaywrightTests: async () => {
+    async reset() {
+      if (!testEnvironmentEnabled) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
       const reqId = state.nextRequestId++;
       const req = {
-        type: import_isolate_protocol.MessageType.RESET_PLAYWRIGHT_TESTS,
+        type: import_isolate_protocol.MessageType.RESET_TEST_ENV,
         requestId: reqId,
         isolateId
       };
       await sendRequest(state, req);
-    },
-    getCollectedData: async () => {
+    }
+  };
+  const playwrightHandle = {
+    async getCollectedData() {
+      if (!playwrightEnabled) {
+        throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
+      }
       const reqId = state.nextRequestId++;
       const req = {
         type: import_isolate_protocol.MessageType.GET_COLLECTED_DATA,
@@ -338,8 +706,43 @@ async function createRuntime(state, options = {}) {
       };
       return sendRequest(state, req);
     },
+    async clearCollectedData() {
+      if (!playwrightEnabled) {
+        throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
+      }
+      const reqId = state.nextRequestId++;
+      const req = {
+        type: import_isolate_protocol.MessageType.CLEAR_COLLECTED_DATA,
+        requestId: reqId,
+        isolateId
+      };
+      await sendRequest(state, req);
+    }
+  };
+  return {
+    id: isolateId,
+    isolateId,
+    fetch: fetchHandle,
+    timers: timersHandle,
+    console: consoleHandle,
+    testEnvironment: testEnvironmentHandle,
+    playwright: playwrightHandle,
+    eval: async (code, filenameOrOptions) => {
+      const reqId = state.nextRequestId++;
+      const options2 = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions } : filenameOrOptions;
+      const req = {
+        type: import_isolate_protocol.MessageType.EVAL,
+        requestId: reqId,
+        isolateId,
+        code,
+        filename: options2?.filename,
+        maxExecutionMs: options2?.maxExecutionMs,
+        module: true
+      };
+      await sendRequest(state, req);
+    },
     dispose: async () => {
-      state.playwrightEventHandlers.delete(isolateId);
+      isolateWsCallbacks.delete(isolateId);
       const reqId = state.nextRequestId++;
       const req = {
         type: import_isolate_protocol.MessageType.DISPOSE_RUNTIME,
@@ -350,27 +753,23 @@ async function createRuntime(state, options = {}) {
     }
   };
 }
+function registerEventCallback(state, handler) {
+  const callbackId = state.nextCallbackId++;
+  state.callbacks.set(callbackId, (data) => {
+    handler(data);
+    return;
+  });
+  return callbackId;
+}
 function registerConsoleCallbacks(state, callbacks) {
   const registrations = {};
-  const register = (name, fn) => {
+  if (callbacks.onEntry) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, (_level, ...args) => {
-      fn(...args);
+    state.callbacks.set(callbackId, (entry) => {
+      callbacks.onEntry(entry);
     });
-    registrations[name] = { callbackId, name, async: false };
-  };
-  if (callbacks.log)
-    register("log", callbacks.log);
-  if (callbacks.warn)
-    register("warn", callbacks.warn);
-  if (callbacks.error)
-    register("error", callbacks.error);
-  if (callbacks.info)
-    register("info", callbacks.info);
-  if (callbacks.debug)
-    register("debug", callbacks.debug);
-  if (callbacks.dir)
-    register("dir", callbacks.dir);
+    registrations.onEntry = { callbackId, name: "onEntry", type: "sync" };
+  }
   return registrations;
 }
 function registerFetchCallback(state, callback) {
@@ -380,7 +779,7 @@ function registerFetchCallback(state, callback) {
     const response = await callback(request);
     return serializeResponse(response);
   });
-  return { callbackId, name: "fetch", async: true };
+  return { callbackId, name: "fetch", type: "async" };
 }
 function registerFsCallbacks(state, callbacks) {
   const registrations = {};
@@ -390,7 +789,7 @@ function registerFsCallbacks(state, callbacks) {
       const result = await callbacks.readFile(path);
       return new Uint8Array(result);
     });
-    registrations.readFile = { callbackId, name: "readFile", async: true };
+    registrations.readFile = { callbackId, name: "readFile", type: "async" };
   }
   if (callbacks.writeFile) {
     const callbackId = state.nextCallbackId++;
@@ -407,67 +806,251 @@ function registerFsCallbacks(state, callbacks) {
       }
       await callbacks.writeFile(path, buffer);
     });
-    registrations.writeFile = { callbackId, name: "writeFile", async: true };
+    registrations.writeFile = { callbackId, name: "writeFile", type: "async" };
   }
   if (callbacks.unlink) {
     const callbackId = state.nextCallbackId++;
     state.callbacks.set(callbackId, async (path) => {
       await callbacks.unlink(path);
     });
-    registrations.unlink = { callbackId, name: "unlink", async: true };
+    registrations.unlink = { callbackId, name: "unlink", type: "async" };
   }
   if (callbacks.readdir) {
     const callbackId = state.nextCallbackId++;
     state.callbacks.set(callbackId, async (path) => {
       return callbacks.readdir(path);
     });
-    registrations.readdir = { callbackId, name: "readdir", async: true };
+    registrations.readdir = { callbackId, name: "readdir", type: "async" };
   }
   if (callbacks.mkdir) {
     const callbackId = state.nextCallbackId++;
     state.callbacks.set(callbackId, async (path, options) => {
       await callbacks.mkdir(path, options);
     });
-    registrations.mkdir = { callbackId, name: "mkdir", async: true };
+    registrations.mkdir = { callbackId, name: "mkdir", type: "async" };
   }
   if (callbacks.rmdir) {
     const callbackId = state.nextCallbackId++;
     state.callbacks.set(callbackId, async (path) => {
       await callbacks.rmdir(path);
     });
-    registrations.rmdir = { callbackId, name: "rmdir", async: true };
+    registrations.rmdir = { callbackId, name: "rmdir", type: "async" };
   }
   if (callbacks.stat) {
     const callbackId = state.nextCallbackId++;
     state.callbacks.set(callbackId, async (path) => {
       return callbacks.stat(path);
     });
-    registrations.stat = { callbackId, name: "stat", async: true };
+    registrations.stat = { callbackId, name: "stat", type: "async" };
   }
   if (callbacks.rename) {
     const callbackId = state.nextCallbackId++;
     state.callbacks.set(callbackId, async (from, to) => {
       await callbacks.rename(from, to);
     });
-    registrations.rename = { callbackId, name: "rename", async: true };
+    registrations.rename = { callbackId, name: "rename", type: "async" };
   }
   return registrations;
 }
-async function serializeRequest(request) {
-  const headers = [];
-  request.headers.forEach((value, key) => {
-    headers.push([key, value]);
+function registerModuleLoaderCallback(state, callback) {
+  const callbackId = state.nextCallbackId++;
+  state.callbacks.set(callbackId, async (moduleName) => {
+    return callback(moduleName);
   });
-  let body = null;
-  if (request.body) {
-    body = new Uint8Array(await request.arrayBuffer());
+  return { callbackId, name: "moduleLoader", type: "async" };
+}
+var clientIteratorSessions = new Map;
+var nextClientIteratorId = 1;
+var returnedPromiseRegistry = new Map;
+var returnedIteratorRegistry = new Map;
+function isPromiseRef(value) {
+  return typeof value === "object" && value !== null && value.__type === "PromiseRef";
+}
+function isAsyncIteratorRef(value) {
+  return typeof value === "object" && value !== null && value.__type === "AsyncIteratorRef";
+}
+function registerCustomFunctions(state, customFunctions) {
+  const registrations = {};
+  for (const [name, def] of Object.entries(customFunctions)) {
+    if (def.type === "asyncIterator") {
+      const startCallbackId = state.nextCallbackId++;
+      state.callbacks.set(startCallbackId, async (...args) => {
+        try {
+          const fn = def.fn;
+          const iterator = fn(...args);
+          const iteratorId = nextClientIteratorId++;
+          clientIteratorSessions.set(iteratorId, { iterator });
+          return { iteratorId };
+        } catch (error) {
+          throw error;
+        }
+      });
+      const nextCallbackId = state.nextCallbackId++;
+      state.callbacks.set(nextCallbackId, async (iteratorId) => {
+        const session = clientIteratorSessions.get(iteratorId);
+        if (!session) {
+          throw new Error(`Iterator session ${iteratorId} not found`);
+        }
+        try {
+          const result = await session.iterator.next();
+          if (result.done) {
+            clientIteratorSessions.delete(iteratorId);
+          }
+          return { done: result.done, value: await import_isolate_protocol.marshalValue(result.value) };
+        } catch (error) {
+          clientIteratorSessions.delete(iteratorId);
+          throw error;
+        }
+      });
+      const returnCallbackId = state.nextCallbackId++;
+      state.callbacks.set(returnCallbackId, async (iteratorId, value) => {
+        const session = clientIteratorSessions.get(iteratorId);
+        if (!session) {
+          return { done: true, value: await import_isolate_protocol.marshalValue(undefined) };
+        }
+        try {
+          const result = await session.iterator.return?.(value);
+          clientIteratorSessions.delete(iteratorId);
+          return { done: true, value: await import_isolate_protocol.marshalValue(result?.value) };
+        } catch (error) {
+          clientIteratorSessions.delete(iteratorId);
+          throw error;
+        }
+      });
+      const throwCallbackId = state.nextCallbackId++;
+      state.callbacks.set(throwCallbackId, async (iteratorId, errorData) => {
+        const session = clientIteratorSessions.get(iteratorId);
+        if (!session) {
+          throw new Error(`Iterator session ${iteratorId} not found`);
+        }
+        try {
+          const errInfo = errorData;
+          const error = Object.assign(new Error(errInfo.message), { name: errInfo.name });
+          const result = await session.iterator.throw?.(error);
+          clientIteratorSessions.delete(iteratorId);
+          return { done: result?.done ?? true, value: await import_isolate_protocol.marshalValue(result?.value) };
+        } catch (error) {
+          clientIteratorSessions.delete(iteratorId);
+          throw error;
+        }
+      });
+      registrations[`${name}:start`] = { callbackId: startCallbackId, name: `${name}:start`, type: "async" };
+      registrations[`${name}:next`] = { callbackId: nextCallbackId, name: `${name}:next`, type: "async" };
+      registrations[`${name}:return`] = { callbackId: returnCallbackId, name: `${name}:return`, type: "async" };
+      registrations[`${name}:throw`] = { callbackId: throwCallbackId, name: `${name}:throw`, type: "async" };
+      registrations[name] = {
+        callbackId: startCallbackId,
+        name,
+        type: "asyncIterator"
+      };
+    } else {
+      const callbackId = state.nextCallbackId++;
+      state.callbacks.set(callbackId, async (...args) => {
+        const result = await def.fn(...args);
+        const addCallbackIdsToRefs = (value) => {
+          if (value === null || typeof value !== "object") {
+            return value;
+          }
+          if (isPromiseRef(value)) {
+            const resolveCallbackId = state.nextCallbackId++;
+            state.callbacks.set(resolveCallbackId, async (...args2) => {
+              const promiseId = args2[0];
+              const promise = returnedPromiseRegistry.get(promiseId);
+              if (!promise) {
+                throw new Error(`Promise ${promiseId} not found`);
+              }
+              const promiseResult = await promise;
+              returnedPromiseRegistry.delete(promiseId);
+              const marshalledResult = await import_isolate_protocol.marshalValue(promiseResult, marshalCtx);
+              return addCallbackIdsToRefs(marshalledResult);
+            });
+            return {
+              ...value,
+              __resolveCallbackId: resolveCallbackId
+            };
+          }
+          if (isAsyncIteratorRef(value)) {
+            const nextCallbackId = state.nextCallbackId++;
+            state.callbacks.set(nextCallbackId, async (...args2) => {
+              const iteratorId = args2[0];
+              const iterator = returnedIteratorRegistry.get(iteratorId);
+              if (!iterator) {
+                throw new Error(`Iterator ${iteratorId} not found`);
+              }
+              const iterResult = await iterator.next();
+              if (iterResult.done) {
+                returnedIteratorRegistry.delete(iteratorId);
+              }
+              const marshalledValue = await import_isolate_protocol.marshalValue(iterResult.value, marshalCtx);
+              return {
+                done: iterResult.done,
+                value: addCallbackIdsToRefs(marshalledValue)
+              };
+            });
+            const returnCallbackId = state.nextCallbackId++;
+            state.callbacks.set(returnCallbackId, async (...args2) => {
+              const iteratorId = args2[0];
+              const returnValue = args2[1];
+              const iterator = returnedIteratorRegistry.get(iteratorId);
+              returnedIteratorRegistry.delete(iteratorId);
+              if (!iterator || !iterator.return) {
+                return { done: true, value: undefined };
+              }
+              const iterResult = await iterator.return(returnValue);
+              const marshalledValue = await import_isolate_protocol.marshalValue(iterResult.value, marshalCtx);
+              return {
+                done: true,
+                value: addCallbackIdsToRefs(marshalledValue)
+              };
+            });
+            return {
+              ...value,
+              __nextCallbackId: nextCallbackId,
+              __returnCallbackId: returnCallbackId
+            };
+          }
+          if (Array.isArray(value)) {
+            return value.map((item) => addCallbackIdsToRefs(item));
+          }
+          const objResult = {};
+          for (const key of Object.keys(value)) {
+            objResult[key] = addCallbackIdsToRefs(value[key]);
+          }
+          return objResult;
+        };
+        const marshalCtx = {
+          registerCallback: (fn) => {
+            const returnedCallbackId = state.nextCallbackId++;
+            state.callbacks.set(returnedCallbackId, async (...args2) => {
+              const fnResult = await fn(...args2);
+              const marshalledResult = await import_isolate_protocol.marshalValue(fnResult, marshalCtx);
+              return addCallbackIdsToRefs(marshalledResult);
+            });
+            return returnedCallbackId;
+          },
+          registerPromise: (promise) => {
+            const promiseId = state.nextCallbackId++;
+            returnedPromiseRegistry.set(promiseId, promise);
+            return promiseId;
+          },
+          registerIterator: (iterator) => {
+            const iteratorId = state.nextCallbackId++;
+            returnedIteratorRegistry.set(iteratorId, iterator);
+            return iteratorId;
+          }
+        };
+        const marshalled = await import_isolate_protocol.marshalValue(result, marshalCtx);
+        const withCallbackIds = addCallbackIdsToRefs(marshalled);
+        return withCallbackIds;
+      });
+      registrations[name] = {
+        callbackId,
+        name,
+        type: def.type
+      };
+    }
   }
-  return {
-    method: request.method,
-    url: request.url,
-    headers,
-    body
-  };
+  return registrations;
 }
 async function serializeResponse(response) {
   const headers = [];
@@ -499,6 +1082,104 @@ function deserializeResponse(data) {
     headers: data.headers
   });
 }
+async function serializeRequestWithStreaming(state, request) {
+  const headers = [];
+  request.headers.forEach((value, key) => {
+    headers.push([key, value]);
+  });
+  let body = null;
+  let bodyStreamId;
+  let bodyStream;
+  if (request.body) {
+    const contentLength = request.headers.get("content-length");
+    const knownSize = contentLength ? parseInt(contentLength, 10) : null;
+    if (knownSize !== null && knownSize > import_isolate_protocol.STREAM_THRESHOLD) {
+      bodyStreamId = state.nextStreamId++;
+      bodyStream = request.body;
+    } else {
+      const clonedRequest = request.clone();
+      try {
+        body = new Uint8Array(await request.arrayBuffer());
+        if (body.length > import_isolate_protocol.STREAM_THRESHOLD) {
+          bodyStreamId = state.nextStreamId++;
+          bodyStream = clonedRequest.body;
+          body = null;
+        }
+      } catch {
+        bodyStreamId = state.nextStreamId++;
+        bodyStream = clonedRequest.body;
+      }
+    }
+  }
+  const result = {
+    method: request.method,
+    url: request.url,
+    headers,
+    body
+  };
+  if (bodyStreamId !== undefined) {
+    result.bodyStreamId = bodyStreamId;
+    result.bodyStream = bodyStream;
+  }
+  return result;
+}
+function waitForUploadCredit(session) {
+  return new Promise((resolve) => {
+    session.creditResolver = resolve;
+  });
+}
+async function sendBodyStream(state, streamId, body) {
+  const session = {
+    streamId,
+    requestId: 0,
+    state: "active",
+    bytesTransferred: 0,
+    credit: 0
+  };
+  state.uploadStreams.set(streamId, session);
+  const reader = body.getReader();
+  try {
+    while (true) {
+      if (session.state !== "active") {
+        throw new Error("Stream cancelled");
+      }
+      while (session.credit < import_isolate_protocol.STREAM_CHUNK_SIZE && session.state === "active") {
+        await waitForUploadCredit(session);
+      }
+      if (session.state !== "active") {
+        throw new Error("Stream cancelled");
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        sendMessage(state.socket, {
+          type: import_isolate_protocol.MessageType.STREAM_CLOSE,
+          streamId
+        });
+        break;
+      }
+      for (let offset = 0;offset < value.length; offset += import_isolate_protocol.STREAM_CHUNK_SIZE) {
+        const chunk = value.slice(offset, offset + import_isolate_protocol.STREAM_CHUNK_SIZE);
+        sendMessage(state.socket, {
+          type: import_isolate_protocol.MessageType.STREAM_PUSH,
+          streamId,
+          chunk
+        });
+        session.credit -= chunk.length;
+        session.bytesTransferred += chunk.length;
+      }
+    }
+  } catch (err) {
+    sendMessage(state.socket, {
+      type: import_isolate_protocol.MessageType.STREAM_ERROR,
+      streamId,
+      error: err.message
+    });
+    throw err;
+  } finally {
+    reader.releaseLock();
+    state.uploadStreams.delete(streamId);
+  }
+}
 })
 
-//# debugId=AC520FAF0080FE0764756E2164756E21
+//# debugId=5325684CDAEFBA9A64756E2164756E21