@ricsam/isolate 0.1.10 → 0.1.12

package/dist/cjs/internal/runtime/index.cjs

@@ -233,6 +233,29 @@ var ISOLATE_MARSHAL_CODE = `
   );
   let __customFn_nextCallbackId = 1;
   const __customFn_callbacks = new Map();
+  let __customFn_nextAsyncRefId = 1;
+  const __customFn_promises = new Map();
+  const __customFn_iterators = new Map();
+
+  function __customFn_attachAsyncIterator(resultPromise, label) {
+    resultPromise[Symbol.asyncIterator] = async function* () {
+      const iterable = await resultPromise;
+      if (iterable && typeof iterable[Symbol.asyncIterator] === 'function') {
+        yield* iterable;
+        return;
+      }
+      if (iterable && typeof iterable[Symbol.iterator] === 'function') {
+        yield* iterable;
+        return;
+      }
+      throw new TypeError(label + '(...) is not async iterable');
+    };
+    return resultPromise;
+  }
+
+  async function __customFn_waitForTurn() {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
 
   function __customFn_registerCallback(callback) {
     const callbackId = __customFn_nextCallbackId++;
@@ -251,7 +274,15 @@ var ISOLATE_MARSHAL_CODE = `
     if (type === 'string' || type === 'number' || type === 'boolean') return value;
     if (type === 'bigint') return { __type: 'BigIntRef', value: value.toString() };
     if (type === 'function') {
-      return { __type: 'CallbackRef', callbackId: __customFn_registerCallback(value) };
+      return {
+        __type: 'CallbackRef',
+        callbackId: __customFn_registerCallback(value),
+        callbackKind:
+          value.__isolateCallbackKind === 'asyncGenerator' ||
+          (value.constructor && value.constructor.name === 'AsyncGeneratorFunction')
+            ? 'asyncGenerator'
+            : undefined,
+      };
     }
     if (type === 'symbol') throw new Error('Cannot marshal Symbol values');
 
@@ -265,6 +296,9 @@ var ISOLATE_MARSHAL_CODE = `
       if (value instanceof URL) {
         return { __type: 'URLRef', href: value.href };
       }
+      if (typeof AbortSignal !== 'undefined' && value instanceof AbortSignal) {
+        return { __type: 'AbortSignalRef', aborted: value.aborted };
+      }
       if (typeof Headers !== 'undefined' && value instanceof Headers) {
         const pairs = [];
         value.forEach((v, k) => pairs.push([k, v]));
@@ -304,6 +338,192 @@ var ISOLATE_MARSHAL_CODE = `
     return value;
   }
 
+  async function marshalForHostAsync(value, depth = 0) {
+    if (depth > 100) throw new Error('Maximum marshalling depth exceeded');
+
+    if (value === null || value === undefined) {
+      return marshalForHost(value, depth);
+    }
+
+    const type = typeof value;
+    if (
+      type === 'string' ||
+      type === 'number' ||
+      type === 'boolean' ||
+      type === 'bigint' ||
+      type === 'function'
+    ) {
+      return marshalForHost(value, depth);
+    }
+    if (type === 'symbol') {
+      throw new Error('Cannot marshal Symbol values');
+    }
+
+    if (value && typeof value.then === 'function') {
+      return await marshalForHostAsync(await value, depth);
+    }
+
+    if (value && typeof value[Symbol.asyncIterator] === 'function') {
+      const iteratorId = __customFn_nextAsyncRefId++;
+      const iterator = value[Symbol.asyncIterator]();
+      __customFn_iterators.set(iteratorId, iterator);
+
+      const nextCallbackId = __customFn_registerCallback(async (id) => {
+        const target = __customFn_iterators.get(id);
+        if (!target) {
+          throw new Error('Iterator ' + id + ' not found');
+        }
+        const result = await target.next();
+        if (result.done) {
+          __customFn_iterators.delete(id);
+        }
+        return {
+          done: result.done,
+          value: await marshalForHostAsync(result.value, depth + 1),
+        };
+      });
+
+      const returnCallbackId = __customFn_registerCallback(async (id, returnValue) => {
+        const target = __customFn_iterators.get(id);
+        __customFn_iterators.delete(id);
+        if (!target || typeof target.return !== 'function') {
+          return {
+            done: true,
+            value: marshalForHost(undefined, depth + 1),
+          };
+        }
+        const result = await target.return(returnValue);
+        return {
+          done: result.done ?? true,
+          value: await marshalForHostAsync(result.value, depth + 1),
+        };
+      });
+
+      const throwCallbackId = __customFn_registerCallback(async (id, errorValue) => {
+        const target = __customFn_iterators.get(id);
+        if (!target) {
+          throw new Error('Iterator ' + id + ' not found');
+        }
+        if (typeof target.throw !== 'function') {
+          throw Object.assign(
+            new Error(errorValue?.message ?? 'Iterator does not support throw()'),
+            { name: errorValue?.name ?? 'Error', stack: errorValue?.stack }
+          );
+        }
+
+        try {
+          const thrown = Object.assign(
+            new Error(errorValue?.message ?? 'Iterator throw()'),
+            { name: errorValue?.name ?? 'Error', stack: errorValue?.stack }
+          );
+          const result = await target.throw(thrown);
+          if (result.done) {
+            __customFn_iterators.delete(id);
+          }
+          return {
+            done: result.done,
+            value: await marshalForHostAsync(result.value, depth + 1),
+          };
+        } catch (error) {
+          __customFn_iterators.delete(id);
+          throw error;
+        }
+      });
+
+      return {
+        __type: 'AsyncIteratorRef',
+        iteratorId,
+        __nextCallbackId: nextCallbackId,
+        __returnCallbackId: returnCallbackId,
+        __throwCallbackId: throwCallbackId,
+      };
+    }
+
+    if (value instanceof Date || value instanceof RegExp || value instanceof URL) {
+      return marshalForHost(value, depth);
+    }
+    if (typeof AbortSignal !== 'undefined' && value instanceof AbortSignal) {
+      return marshalForHost(value, depth);
+    }
+    if (typeof Headers !== 'undefined' && value instanceof Headers) {
+      return marshalForHost(value, depth);
+    }
+    if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
+      return marshalForHost(value, depth);
+    }
+    if (typeof Request !== 'undefined' && value instanceof Request) {
+      const headers = [];
+      value.headers.forEach((headerValue, key) => headers.push([key, headerValue]));
+      const body = value.body
+        ? Array.from(new Uint8Array(await value.clone().arrayBuffer()))
+        : null;
+      return {
+        __type: 'RequestRef',
+        url: value.url,
+        method: value.method,
+        headers,
+        body,
+        mode: value.mode,
+        credentials: value.credentials,
+        cache: value.cache,
+        redirect: value.redirect,
+        referrer: value.referrer,
+        referrerPolicy: value.referrerPolicy,
+        integrity: value.integrity,
+      };
+    }
+    if (typeof Response !== 'undefined' && value instanceof Response) {
+      const headers = [];
+      value.headers.forEach((headerValue, key) => headers.push([key, headerValue]));
+      const body = value.body
+        ? Array.from(new Uint8Array(await value.clone().arrayBuffer()))
+        : null;
+      return {
+        __type: 'ResponseRef',
+        status: value.status,
+        statusText: value.statusText,
+        headers,
+        body,
+      };
+    }
+    if (typeof File !== 'undefined' && value instanceof File) {
+      return {
+        __type: 'FileRef',
+        name: value.name,
+        type: value.type,
+        lastModified: value.lastModified,
+        data: Array.from(new Uint8Array(await value.arrayBuffer())),
+      };
+    }
+    if (typeof Blob !== 'undefined' && value instanceof Blob) {
+      return {
+        __type: 'FileRef',
+        type: value.type,
+        data: Array.from(new Uint8Array(await value.arrayBuffer())),
+      };
+    }
+    if (typeof FormData !== 'undefined' && value instanceof FormData) {
+      const entries = [];
+      for (const [key, entry] of value.entries()) {
+        if (typeof entry === 'string') {
+          entries.push([key, entry]);
+        } else {
+          entries.push([key, await marshalForHostAsync(entry, depth + 1)]);
+        }
+      }
+      return { __type: 'FormDataRef', entries };
+    }
+    if (Array.isArray(value)) {
+      return await Promise.all(value.map((item) => marshalForHostAsync(item, depth + 1)));
+    }
+
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = await marshalForHostAsync(value[key], depth + 1);
+    }
+    return result;
+  }
+
   async function invokeLocalCallback(callbackId, argsJson) {
     const callback = __customFn_callbacks.get(callbackId);
     if (!callback) {
@@ -319,8 +539,8 @@ var ISOLATE_MARSHAL_CODE = `
     try {
       const rawArgs = JSON.parse(argsJson);
       const args = unmarshalFromHost(rawArgs);
-      const result = await callback(...args);
-      return JSON.stringify({ ok: true, value: marshalForHost(result) });
+      const result = callback(...args);
+      return JSON.stringify({ ok: true, value: await marshalForHostAsync(result) });
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       return JSON.stringify({
@@ -347,6 +567,12 @@ var ISOLATE_MARSHAL_CODE = `
         case 'RegExpRef': return new RegExp(value.source, value.flags);
         case 'BigIntRef': return BigInt(value.value);
         case 'URLRef': return new URL(value.href);
+        case 'AbortSignalRef': {
+          if (value.aborted) {
+            return AbortSignal.abort();
+          }
+          return new AbortController().signal;
+        }
         case 'HeadersRef': return new Headers(value.pairs);
         case 'Uint8ArrayRef': return new Uint8Array(value.data);
         case 'RequestRef': {
@@ -450,6 +676,7 @@ var ISOLATE_MARSHAL_CODE = `
                 error.name = result.error.name;
                 throw error;
               }
+              await __customFn_waitForTurn();
               return {
                 done: result.value.done,
                 value: unmarshalFromHost(result.value.value)
@@ -468,6 +695,7 @@ var ISOLATE_MARSHAL_CODE = `
                 error.name = result.error.name;
                 throw error;
               }
+              await __customFn_waitForTurn();
               return {
                 done: result.value.done ?? true,
                 value: unmarshalFromHost(result.value.value ?? result.value),
@@ -492,6 +720,7 @@ var ISOLATE_MARSHAL_CODE = `
                 error.name = result.error.name;
                 throw error;
               }
+              await __customFn_waitForTurn();
               return {
                 done: result.value.done,
                 value: unmarshalFromHost(result.value.value),
@@ -521,6 +750,8 @@ var ISOLATE_MARSHAL_CODE = `
   globalThis.__marshalForHost = marshalForHost;
   globalThis.__unmarshalFromHost = unmarshalFromHost;
   globalThis.__customFn_invokeLocalCallback = invokeLocalCallback;
+  globalThis.__customFn_attachAsyncIterator = __customFn_attachAsyncIterator;
+  globalThis.__customFn_waitForTurn = __customFn_waitForTurn;
 })();
 `;
 async function setupCustomFunctions(context, customFunctions, marshalOptions) {
@@ -578,6 +809,23 @@ async function setupCustomFunctions(context, customFunctions, marshalOptions) {
   global.setSync("__customFn_invoke", invokeCallbackRef);
   context.evalSync(ISOLATE_MARSHAL_CODE);
   const invokeIsolateCallbackRef = context.global.getSync("__customFn_invokeLocalCallback", { reference: true });
+  const normalizeIsolateCallbackResult = async (value) => {
+    if (typeof Response !== "undefined" && value instanceof Response) {
+      const headers = [];
+      value.headers.forEach((headerValue, key) => {
+        headers.push([key, headerValue]);
+      });
+      const body = value.body ? Array.from(new Uint8Array(await value.clone().arrayBuffer())) : null;
+      return {
+        __type: "ResponseRef",
+        status: value.status,
+        statusText: value.statusText,
+        headers,
+        body
+      };
+    }
+    return value;
+  };
   isolateUnmarshalContext.getCallback = (callbackId) => {
     return async (...args) => {
       let marshalledArgs;
@@ -591,31 +839,110 @@ async function setupCustomFunctions(context, customFunctions, marshalOptions) {
       const resultJson = await invokeIsolateCallbackRef.apply(undefined, [callbackId, JSON.stringify(marshalledArgs)], { result: { promise: true, copy: true } });
       const result = JSON.parse(resultJson);
       if (result.ok) {
-        return import_protocol3.unmarshalValue(result.value, isolateUnmarshalContext);
+        const unmarshalled = import_protocol3.unmarshalValue(result.value, isolateUnmarshalContext);
+        return await normalizeIsolateCallbackResult(unmarshalled);
       }
       const error = new Error(result.error?.message ?? `Callback ${callbackId} failed`);
       error.name = result.error?.name ?? "Error";
       throw error;
     };
   };
+  isolateUnmarshalContext.createPromiseProxy = (promiseId, ref) => {
+    const resolveCallbackId = ref?.__resolveCallbackId;
+    if (typeof resolveCallbackId !== "number") {
+      throw new Error(`Promise ${promiseId} is missing a resolve callback`);
+    }
+    return (async () => {
+      const resultJson = await invokeIsolateCallbackRef.apply(undefined, [resolveCallbackId, JSON.stringify([promiseId])], { result: { promise: true, copy: true } });
+      const result = JSON.parse(resultJson);
+      if (result.ok) {
+        return import_protocol3.unmarshalValue(result.value, isolateUnmarshalContext);
+      }
+      const error = new Error(result.error?.message ?? `Promise ${promiseId} failed`);
+      error.name = result.error?.name ?? "Error";
+      throw error;
+    })();
+  };
+  isolateUnmarshalContext.createIteratorProxy = (iteratorId, ref) => {
+    const nextCallbackId = ref?.__nextCallbackId;
+    const returnCallbackId = ref?.__returnCallbackId;
+    const throwCallbackId = ref?.__throwCallbackId;
+    if (typeof nextCallbackId !== "number") {
+      throw new Error(`Iterator ${iteratorId} is missing a next callback`);
+    }
+    const invokeIteratorCallback = async (callbackId, args, label) => {
+      const resultJson = await invokeIsolateCallbackRef.apply(undefined, [callbackId, JSON.stringify(args)], { result: { promise: true, copy: true } });
+      const result = JSON.parse(resultJson);
+      if (result.ok) {
+        return result.value;
+      }
+      const error = new Error(result.error?.message ?? `${label} failed for iterator ${iteratorId}`);
+      error.name = result.error?.name ?? "Error";
+      throw error;
+    };
+    return {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        const result = await invokeIteratorCallback(nextCallbackId, [iteratorId], "Iterator next()");
+        return {
+          done: Boolean(result.done),
+          value: import_protocol3.unmarshalValue(result.value, isolateUnmarshalContext)
+        };
+      },
+      async return(value) {
+        if (typeof returnCallbackId !== "number") {
+          return { done: true, value };
+        }
+        const result = await invokeIteratorCallback(returnCallbackId, [iteratorId, value], "Iterator return()");
+        return {
+          done: result.done ?? true,
+          value: import_protocol3.unmarshalValue(result.value, isolateUnmarshalContext)
+        };
+      },
+      async throw(errorValue) {
+        if (typeof throwCallbackId !== "number") {
+          throw errorValue;
+        }
+        const serializedError = errorValue && typeof errorValue === "object" ? {
+          message: errorValue.message,
+          name: errorValue.name,
+          stack: errorValue.stack
+        } : {
+          message: String(errorValue ?? "Iterator throw()"),
+          name: "Error"
+        };
+        const result = await invokeIteratorCallback(throwCallbackId, [iteratorId, serializedError], "Iterator throw()");
+        return {
+          done: Boolean(result.done),
+          value: import_protocol3.unmarshalValue(result.value, isolateUnmarshalContext)
+        };
+      }
+    };
+  };
   for (const name of Object.keys(customFunctions)) {
     const def = customFunctions[name];
     if (def.type === "async") {
       context.evalSync(`
-        globalThis.${name} = async function(...args) {
-          const marshalledArgs = __marshalForHost(args);
-          const resultJson = await __customFn_invoke.apply(
-            undefined,
-            ["${name}", JSON.stringify(marshalledArgs)],
-            { result: { promise: true, copy: true } }
-          );
-          const result = JSON.parse(resultJson);
-          if (result.ok) {
-            return __unmarshalFromHost(result.value);
-          }
-          const error = new Error(result.error.message);
-          error.name = result.error.name;
-          throw error;
+        globalThis.${name} = function(...args) {
+          const resultPromise = (async () => {
+            const marshalledArgs = __marshalForHost(args);
+            const resultJson = await __customFn_invoke.apply(
+              undefined,
+              ["${name}", JSON.stringify(marshalledArgs)],
+              { result: { promise: true, copy: true } }
+            );
+            const result = JSON.parse(resultJson);
+            if (result.ok) {
+              await __customFn_waitForTurn();
+              return __unmarshalFromHost(result.value);
+            }
+            const error = new Error(result.error.message);
+            error.name = result.error.name;
+            throw error;
+          })();
+          return __customFn_attachAsyncIterator(resultPromise, "${name}");
         };
       `);
     } else if (def.type === "sync") {
@@ -654,18 +981,38 @@ async function setupCustomFunctions(context, customFunctions, marshalOptions) {
               name: result.error.name,
             });
           })();
+          let iteratorRef;
+          const getIterator = async () => {
+            if (!iteratorRef) {
+              let iterator = await iteratorPromise;
+              for (let depth = 0; depth < 4; depth += 1) {
+                if (iterator && typeof iterator.next === 'function') {
+                  break;
+                }
+                if (!iterator || typeof iterator[Symbol.asyncIterator] !== 'function') {
+                  break;
+                }
+                iterator = iterator[Symbol.asyncIterator]();
+              }
+              iteratorRef = iterator;
+            }
+            return iteratorRef;
+          };
           return {
             [Symbol.asyncIterator]() { return this; },
             async next() {
-              const iterator = await iteratorPromise;
+              const iterator = await getIterator();
+              if (!iterator || typeof iterator.next !== 'function') {
+                throw new TypeError('Custom async iterator resolved to a non-iterator');
+              }
               return iterator.next();
             },
             async return(v) {
-              const iterator = await iteratorPromise;
+              const iterator = await getIterator();
               return iterator.return ? iterator.return(v) : { done: true, value: v };
             },
             async throw(e) {
-              const iterator = await iteratorPromise;
+              const iterator = await getIterator();
               if (!iterator.throw) {
                 throw e;
               }
@@ -991,6 +1338,7 @@ async function createRuntime(options) {
     }
     const playwrightSetupOptions = {
       handler: opts.playwright.handler,
+      hasDefaultPage: opts.playwright.hasDefaultPage,
       timeout: opts.playwright.timeout,
       console: opts.playwright.console && !opts.console?.onEntry,
       onEvent: eventCallback
@@ -1182,6 +1530,13 @@ async function createRuntime(options) {
         requestFailures: state.handles.playwright.getRequestFailures()
       };
     },
+    getTrackedResources() {
+      ensureRuntimeUsable();
+      if (!state.handles.playwright) {
+        throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
+      }
+      return state.handles.playwright.getTrackedResources();
+    },
     clearCollectedData() {
       ensureRuntimeUsable();
       state.handles.playwright?.clearCollected();
@@ -1304,4 +1659,4 @@ ${trimmed.map((p) => `  ${p}`).join(`
   };
 }
 
-//# debugId=F082D1F8095EB10F64756E2164756E21
+//# debugId=02620CFDF0CE45BE64756E2164756E21