@ricsam/isolate-runtime 0.1.14 → 0.1.15

package/dist/mjs/index.mjs

@@ -23,7 +23,9 @@ import {
   hasTests as hasTestsInContext,
   getTestCount as getTestCountInContext
 } from "@ricsam/isolate-test-environment";
-import { setupPlaywright } from "@ricsam/isolate-playwright";
+import {
+  setupPlaywright
+} from "@ricsam/isolate-playwright";
 import {
   marshalValue,
   unmarshalValue
@@ -47,10 +49,10 @@ import {
 } from "@ricsam/isolate-test-environment";
 import {
   setupPlaywright as setupPlaywright2,
-  createPlaywrightHandler
+  createPlaywrightHandler,
+  defaultPlaywrightHandler,
+  getDefaultPlaywrightHandlerMetadata
 } from "@ricsam/isolate-playwright";
-
-export * from "./internal.mjs";
 var iteratorSessions = new Map;
 var nextIteratorId = 1;
 var ISOLATE_MARSHAL_CODE = `
@@ -176,6 +178,68 @@ var ISOLATE_MARSHAL_CODE = `
           }
           return fd;
         }
+        case 'CallbackRef': {
+          // Create a proxy function that invokes the callback
+          const callbackId = value.callbackId;
+          return function(...args) {
+            const argsJson = JSON.stringify(marshalForHost(args));
+            const resultJson = __customFn_invoke.applySyncPromise(undefined, [callbackId, argsJson]);
+            const result = JSON.parse(resultJson);
+            if (result.ok) {
+              return unmarshalFromHost(result.value);
+            } else {
+              const error = new Error(result.error.message);
+              error.name = result.error.name;
+              throw error;
+            }
+          };
+        }
+        case 'PromiseRef': {
+          // Create a proxy Promise that resolves via callback
+          const promiseId = value.promiseId;
+          return new Promise((resolve, reject) => {
+            try {
+              const argsJson = JSON.stringify([promiseId]);
+              const resultJson = __customFn_invoke.applySyncPromise(undefined, [value.__resolveCallbackId, argsJson]);
+              const result = JSON.parse(resultJson);
+              if (result.ok) {
+                resolve(unmarshalFromHost(result.value));
+              } else {
+                reject(new Error(result.error.message));
+              }
+            } catch (e) {
+              reject(e);
+            }
+          });
+        }
+        case 'AsyncIteratorRef': {
+          const iteratorId = value.iteratorId;
+          const nextCallbackId = value.__nextCallbackId;
+          const returnCallbackId = value.__returnCallbackId;
+          return {
+            [Symbol.asyncIterator]() { return this; },
+            async next() {
+              const argsJson = JSON.stringify([iteratorId]);
+              const resultJson = __customFn_invoke.applySyncPromise(undefined, [nextCallbackId, argsJson]);
+              const result = JSON.parse(resultJson);
+              if (!result.ok) {
+                const error = new Error(result.error.message);
+                error.name = result.error.name;
+                throw error;
+              }
+              return {
+                done: result.value.done,
+                value: unmarshalFromHost(result.value.value)
+              };
+            },
+            async return(v) {
+              const argsJson = JSON.stringify([iteratorId, marshalForHost(v)]);
+              const resultJson = __customFn_invoke.applySyncPromise(undefined, [returnCallbackId, argsJson]);
+              const result = JSON.parse(resultJson);
+              return { done: true, value: result.ok ? unmarshalFromHost(result.value) : undefined };
+            }
+          };
+        }
         default:
           // Unknown ref type, return as-is
           break;
@@ -199,9 +263,27 @@ var ISOLATE_MARSHAL_CODE = `
   globalThis.__unmarshalFromHost = unmarshalFromHost;
 })();
 `;
-async function setupCustomFunctions(context, customFunctions) {
+async function setupCustomFunctions(context, customFunctions, marshalOptions) {
   const global = context.global;
-  const invokeCallbackRef = new ivm.Reference(async (name, argsJson) => {
+  const invokeCallbackRef = new ivm.Reference(async (nameOrId, argsJson) => {
+    if (typeof nameOrId === "number" && marshalOptions) {
+      const rawArgs2 = JSON.parse(argsJson);
+      const args2 = unmarshalValue(rawArgs2);
+      try {
+        const result = await marshalOptions.invokeCallback(nameOrId, args2);
+        const ctx = marshalOptions.createMarshalContext();
+        const marshalledResult = await marshalValue(result, ctx);
+        const processedResult = marshalOptions.addCallbackIdsToRefs(marshalledResult);
+        return JSON.stringify({ ok: true, value: processedResult });
+      } catch (error) {
+        const err = error;
+        return JSON.stringify({
+          ok: false,
+          error: { message: err.message, name: err.name }
+        });
+      }
+    }
+    const name = String(nameOrId);
     const def = customFunctions[name];
     if (!def) {
       return JSON.stringify({
@@ -215,7 +297,13 @@ async function setupCustomFunctions(context, customFunctions) {
     const rawArgs = JSON.parse(argsJson);
     const args = unmarshalValue(rawArgs);
     try {
-      const result = def.type === "async" ? await def.fn(...args) : def.fn(...args);
+      const result = await def.fn(...args);
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        const marshalledResult2 = await marshalValue(result, ctx);
+        const processedResult = marshalOptions.addCallbackIdsToRefs(marshalledResult2);
+        return JSON.stringify({ ok: true, value: processedResult });
+      }
       const marshalledResult = await marshalValue(result);
       return JSON.stringify({ ok: true, value: marshalledResult });
     } catch (error) {
@@ -271,7 +359,14 @@ async function setupCustomFunctions(context, customFunctions) {
       if (result.done) {
         iteratorSessions.delete(iteratorId);
       }
-      const marshalledValue = await marshalValue(result.value);
+      let marshalledValue;
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        marshalledValue = await marshalValue(result.value, ctx);
+        marshalledValue = marshalOptions.addCallbackIdsToRefs(marshalledValue);
+      } else {
+        marshalledValue = await marshalValue(result.value);
+      }
       return JSON.stringify({
         ok: true,
         done: result.done,
@@ -297,7 +392,14 @@ async function setupCustomFunctions(context, customFunctions) {
       const value = unmarshalValue(rawValue);
       const result = await session.iterator.return?.(value);
       iteratorSessions.delete(iteratorId);
-      const marshalledValue = await marshalValue(result?.value);
+      let marshalledValue;
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        marshalledValue = await marshalValue(result?.value, ctx);
+        marshalledValue = marshalOptions.addCallbackIdsToRefs(marshalledValue);
+      } else {
+        marshalledValue = await marshalValue(result?.value);
+      }
       return JSON.stringify({ ok: true, done: true, value: marshalledValue });
     } catch (error) {
       const err = error;
@@ -327,7 +429,14 @@ async function setupCustomFunctions(context, customFunctions) {
       });
       const result = await session.iterator.throw?.(error);
       iteratorSessions.delete(iteratorId);
-      const marshalledValue = await marshalValue(result?.value);
+      let marshalledValue;
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        marshalledValue = await marshalValue(result?.value, ctx);
+        marshalledValue = marshalOptions.addCallbackIdsToRefs(marshalledValue);
+      } else {
+        marshalledValue = await marshalValue(result?.value);
+      }
       return JSON.stringify({
         ok: true,
         done: result?.done ?? true,
@@ -418,8 +527,114 @@ async function setupCustomFunctions(context, customFunctions) {
   }
   return invokeCallbackRef;
 }
+function createLocalCustomFunctionsMarshalOptions() {
+  const returnedCallbacks = new Map;
+  const returnedPromises = new Map;
+  const returnedIterators = new Map;
+  let nextLocalCallbackId = 1e6;
+  const createMarshalContext = () => ({
+    registerCallback: (fn) => {
+      const callbackId = nextLocalCallbackId++;
+      returnedCallbacks.set(callbackId, fn);
+      return callbackId;
+    },
+    registerPromise: (promise) => {
+      const promiseId = nextLocalCallbackId++;
+      returnedPromises.set(promiseId, promise);
+      return promiseId;
+    },
+    registerIterator: (iterator) => {
+      const iteratorId = nextLocalCallbackId++;
+      returnedIterators.set(iteratorId, iterator);
+      return iteratorId;
+    }
+  });
+  const isPromiseRef = (value) => typeof value === "object" && value !== null && value.__type === "PromiseRef";
+  const isAsyncIteratorRef = (value) => typeof value === "object" && value !== null && value.__type === "AsyncIteratorRef";
+  const addCallbackIdsToRefs = (value) => {
+    if (value === null || typeof value !== "object")
+      return value;
+    if (isPromiseRef(value)) {
+      if ("__resolveCallbackId" in value)
+        return value;
+      const resolveCallbackId = nextLocalCallbackId++;
+      returnedCallbacks.set(resolveCallbackId, async (promiseId) => {
+        const promise = returnedPromises.get(promiseId);
+        if (!promise) {
+          throw new Error(`Promise ${promiseId} not found`);
+        }
+        const result2 = await promise;
+        returnedPromises.delete(promiseId);
+        const ctx = createMarshalContext();
+        const marshalled = await marshalValue(result2, ctx);
+        return addCallbackIdsToRefs(marshalled);
+      });
+      return { ...value, __resolveCallbackId: resolveCallbackId };
+    }
+    if (isAsyncIteratorRef(value)) {
+      if ("__nextCallbackId" in value)
+        return value;
+      const nextCallbackId = nextLocalCallbackId++;
+      returnedCallbacks.set(nextCallbackId, async (iteratorId) => {
+        const iterator = returnedIterators.get(iteratorId);
+        if (!iterator) {
+          throw new Error(`Iterator ${iteratorId} not found`);
+        }
+        const result2 = await iterator.next();
+        if (result2.done) {
+          returnedIterators.delete(iteratorId);
+        }
+        const ctx = createMarshalContext();
+        const marshalledValue = await marshalValue(result2.value, ctx);
+        return {
+          done: result2.done,
+          value: addCallbackIdsToRefs(marshalledValue)
+        };
+      });
+      const returnCallbackId = nextLocalCallbackId++;
+      returnedCallbacks.set(returnCallbackId, async (iteratorId, returnValue) => {
+        const iterator = returnedIterators.get(iteratorId);
+        returnedIterators.delete(iteratorId);
+        if (!iterator || !iterator.return) {
+          return { done: true, value: undefined };
+        }
+        const result2 = await iterator.return(returnValue);
+        const ctx = createMarshalContext();
+        const marshalledValue = await marshalValue(result2.value, ctx);
+        return {
+          done: true,
+          value: addCallbackIdsToRefs(marshalledValue)
+        };
+      });
+      return {
+        ...value,
+        __nextCallbackId: nextCallbackId,
+        __returnCallbackId: returnCallbackId
+      };
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => addCallbackIdsToRefs(item));
+    }
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = addCallbackIdsToRefs(value[key]);
+    }
+    return result;
+  };
+  const invokeCallback = async (callbackId, args) => {
+    const callback = returnedCallbacks.get(callbackId);
+    if (!callback) {
+      throw new Error(`Local callback ${callbackId} not found`);
+    }
+    return await callback(...args);
+  };
+  return { createMarshalContext, addCallbackIdsToRefs, invokeCallback };
+}
 function createModuleResolver(state) {
   return async (specifier, referrer) => {
+    const staticCached = state.staticModuleCache.get(specifier);
+    if (staticCached)
+      return staticCached;
     const cached = state.moduleCache.get(specifier);
     if (cached)
       return cached;
@@ -428,16 +643,21 @@ function createModuleResolver(state) {
     }
     const importerPath = state.moduleToFilename.get(referrer) ?? "<unknown>";
     const importerResolveDir = path.posix.dirname(importerPath);
-    const { code, resolveDir } = await state.moduleLoader(specifier, {
+    const result = await state.moduleLoader(specifier, {
       path: importerPath,
       resolveDir: importerResolveDir
     });
+    const { code, resolveDir } = result;
     const hash = contentHash(code);
     const cacheKey = `${specifier}:${hash}`;
     const hashCached = state.moduleCache.get(cacheKey);
     if (hashCached)
       return hashCached;
-    const transformed = await transformModuleCode(code, specifier);
+    let transformed = state.transformCache.get(hash);
+    if (!transformed) {
+      transformed = await transformModuleCode(code, specifier);
+      state.transformCache.set(hash, transformed);
+    }
     if (transformed.sourceMap) {
       state.sourceMaps.set(specifier, transformed.sourceMap);
     }
@@ -446,8 +666,12 @@ function createModuleResolver(state) {
     });
     const resolvedPath = path.posix.join(resolveDir, path.posix.basename(specifier));
     state.moduleToFilename.set(mod, resolvedPath);
-    state.moduleCache.set(specifier, mod);
-    state.moduleCache.set(cacheKey, mod);
+    if (result.static) {
+      state.staticModuleCache.set(specifier, mod);
+    } else {
+      state.moduleCache.set(specifier, mod);
+      state.moduleCache.set(cacheKey, mod);
+    }
     const resolver = createModuleResolver(state);
     await mod.instantiate(state.context, resolver);
     return mod;
@@ -458,8 +682,8 @@ function convertFetchCallback(callback) {
     return {};
   }
   return {
-    onFetch: async (request) => {
-      return Promise.resolve(callback(request));
+    onFetch: async (url, init) => {
+      return Promise.resolve(callback(url, init));
     }
   };
 }
@@ -475,8 +699,11 @@ async function createRuntime(options) {
     context,
     handles: {},
     moduleCache: new Map,
+    staticModuleCache: new Map,
+    transformCache: new Map,
     moduleToFilename: new Map,
     sourceMaps: new Map,
+    pendingCallbacks: [],
     moduleLoader: opts.moduleLoader,
     customFunctions: opts.customFunctions
   };
@@ -491,13 +718,17 @@ async function createRuntime(options) {
     state.handles.fs = await setupFs(context, opts.fs);
   }
   if (opts.customFunctions) {
-    state.customFnInvokeRef = await setupCustomFunctions(context, opts.customFunctions);
+    const customMarshalOptions = opts.customFunctionsMarshalOptions ?? createLocalCustomFunctionsMarshalOptions();
+    state.customFnInvokeRef = await setupCustomFunctions(context, opts.customFunctions, customMarshalOptions);
   }
   if (opts.testEnvironment) {
     const testEnvOptions = typeof opts.testEnvironment === "object" ? opts.testEnvironment : undefined;
     state.handles.testEnvironment = await setupTestEnvironment(context, testEnvOptions);
   }
   if (opts.playwright) {
+    if (!opts.playwright.handler) {
+      throw new Error("Playwright configured without handler. Provide playwright.handler in createRuntime options.");
+    }
     let eventCallback = opts.playwright.onEvent;
     if (opts.playwright.console && opts.console?.onEntry) {
       const originalCallback = eventCallback;
@@ -516,12 +747,13 @@ async function createRuntime(options) {
         }
       };
     }
-    state.handles.playwright = await setupPlaywright(context, {
-      page: opts.playwright.page,
+    const playwrightSetupOptions = {
+      handler: opts.playwright.handler,
       timeout: opts.playwright.timeout,
       console: opts.playwright.console && !opts.console?.onEntry,
       onEvent: eventCallback
-    });
+    };
+    state.handles.playwright = await setupPlaywright(context, playwrightSetupOptions);
   }
   const fetchHandle = {
     async dispatchRequest(request, options2) {
@@ -577,6 +809,36 @@ async function createRuntime(options) {
         throw new Error("Fetch handle not available");
       }
       return state.handles.fetch.hasActiveConnections();
+    },
+    dispatchClientWebSocketOpen(socketId, protocol, extensions) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketOpen(socketId, protocol, extensions);
+    },
+    dispatchClientWebSocketMessage(socketId, data) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketMessage(socketId, data);
+    },
+    dispatchClientWebSocketClose(socketId, code, reason, wasClean) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketClose(socketId, code, reason, wasClean);
+    },
+    dispatchClientWebSocketError(socketId) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketError(socketId);
+    },
+    onClientWebSocketCommand(callback) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.onClientWebSocketCommand(callback);
     }
   };
   const timersHandle = {
@@ -599,11 +861,27 @@ async function createRuntime(options) {
     }
   };
   const testEnvironmentHandle = {
-    async runTests(_timeout) {
+    async runTests(timeout) {
       if (!state.handles.testEnvironment) {
         throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
       }
-      return runTestsInContext(state.context);
+      if (timeout === undefined) {
+        return runTestsInContext(state.context);
+      }
+      let timeoutId;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error("Test timeout")), timeout);
+      });
+      try {
+        return await Promise.race([
+          runTestsInContext(state.context),
+          timeoutPromise
+        ]);
+      } finally {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      }
     },
     hasTests() {
       if (!state.handles.testEnvironment) {
@@ -624,7 +902,7 @@ async function createRuntime(options) {
   const playwrightHandle = {
     getCollectedData() {
       if (!state.handles.playwright) {
-        throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
+        throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
       }
       return {
         browserConsoleLogs: state.handles.playwright.getBrowserConsoleLogs(),
@@ -638,6 +916,7 @@ async function createRuntime(options) {
   };
   return {
     id,
+    pendingCallbacks: state.pendingCallbacks,
     fetch: fetchHandle,
     timers: timersHandle,
     console: consoleHandle,
@@ -668,6 +947,10 @@ async function createRuntime(options) {
         } finally {
           runRef.release();
         }
+        if (state.pendingCallbacks.length > 0) {
+          await Promise.all(state.pendingCallbacks);
+          state.pendingCallbacks.length = 0;
+        }
       } catch (err) {
         const error = err;
         if (error.stack && state.sourceMaps.size > 0) {
@@ -676,6 +959,11 @@ async function createRuntime(options) {
         throw error;
       }
     },
+    clearModuleCache() {
+      state.moduleCache.clear();
+      state.moduleToFilename.clear();
+      state.sourceMaps.clear();
+    },
     async dispose() {
       if (state.customFnInvokeRef) {
         state.customFnInvokeRef.release();
@@ -712,9 +1000,11 @@ export {
   normalizeEntryFilename2 as normalizeEntryFilename,
   hasTests,
   getTestCount,
+  getDefaultPlaywrightHandlerMetadata,
+  defaultPlaywrightHandler,
   createRuntime,
   createPlaywrightHandler,
   createNodeFileSystemHandler
 };
 
-//# debugId=5B1C4DA72893C8FA64756E2164756E21
+//# debugId=D363252DB857D59164756E2164756E21