@ricsam/isolate-runtime 0.1.14 → 0.1.16

package/dist/cjs/index.cjs

@@ -4,23 +4,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __reExport = (target, mod, secondTarget) => {
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(target, key) && key !== "default")
-      __defProp(target, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  if (secondTarget) {
-    for (let key of __getOwnPropNames(mod))
-      if (!__hasOwnProp.call(secondTarget, key) && key !== "default")
-        __defProp(secondTarget, key, {
-          get: () => mod[key],
-          enumerable: true
-        });
-    return secondTarget;
-  }
-};
 var __toESM = (mod, isNodeMode, target) => {
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
@@ -74,6 +57,8 @@ __export(exports_src, {
   normalizeEntryFilename: () => import_isolate_protocol2.normalizeEntryFilename,
   hasTests: () => import_isolate_test_environment2.hasTests,
   getTestCount: () => import_isolate_test_environment2.getTestCount,
+  getDefaultPlaywrightHandlerMetadata: () => import_isolate_playwright2.getDefaultPlaywrightHandlerMetadata,
+  defaultPlaywrightHandler: () => import_isolate_playwright2.defaultPlaywrightHandler,
   createRuntime: () => createRuntime,
   createPlaywrightHandler: () => import_isolate_playwright2.createPlaywrightHandler,
   createNodeFileSystemHandler: () => import_isolate_fs2.createNodeFileSystemHandler
@@ -106,7 +91,6 @@ var import_isolate_path2 = require("@ricsam/isolate-path");
 var import_isolate_timers2 = require("@ricsam/isolate-timers");
 var import_isolate_test_environment2 = require("@ricsam/isolate-test-environment");
 var import_isolate_playwright2 = require("@ricsam/isolate-playwright");
-__reExport(exports_src, require("./internal.cjs"), module.exports);
 var iteratorSessions = new Map;
 var nextIteratorId = 1;
 var ISOLATE_MARSHAL_CODE = `
@@ -232,6 +216,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;
@@ -255,9 +301,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 import_isolated_vm.default.Reference(async (name, argsJson) => {
+  const invokeCallbackRef = new import_isolated_vm.default.Reference(async (nameOrId, argsJson) => {
+    if (typeof nameOrId === "number" && marshalOptions) {
+      const rawArgs2 = JSON.parse(argsJson);
+      const args2 = import_isolate_protocol3.unmarshalValue(rawArgs2);
+      try {
+        const result = await marshalOptions.invokeCallback(nameOrId, args2);
+        const ctx = marshalOptions.createMarshalContext();
+        const marshalledResult = await import_isolate_protocol3.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({
@@ -271,7 +335,13 @@ async function setupCustomFunctions(context, customFunctions) {
     const rawArgs = JSON.parse(argsJson);
     const args = import_isolate_protocol3.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 import_isolate_protocol3.marshalValue(result, ctx);
+        const processedResult = marshalOptions.addCallbackIdsToRefs(marshalledResult2);
+        return JSON.stringify({ ok: true, value: processedResult });
+      }
       const marshalledResult = await import_isolate_protocol3.marshalValue(result);
       return JSON.stringify({ ok: true, value: marshalledResult });
     } catch (error) {
@@ -327,7 +397,14 @@ async function setupCustomFunctions(context, customFunctions) {
       if (result.done) {
         iteratorSessions.delete(iteratorId);
       }
-      const marshalledValue = await import_isolate_protocol3.marshalValue(result.value);
+      let marshalledValue;
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        marshalledValue = await import_isolate_protocol3.marshalValue(result.value, ctx);
+        marshalledValue = marshalOptions.addCallbackIdsToRefs(marshalledValue);
+      } else {
+        marshalledValue = await import_isolate_protocol3.marshalValue(result.value);
+      }
       return JSON.stringify({
         ok: true,
         done: result.done,
@@ -353,7 +430,14 @@ async function setupCustomFunctions(context, customFunctions) {
       const value = import_isolate_protocol3.unmarshalValue(rawValue);
       const result = await session.iterator.return?.(value);
       iteratorSessions.delete(iteratorId);
-      const marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
+      let marshalledValue;
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        marshalledValue = await import_isolate_protocol3.marshalValue(result?.value, ctx);
+        marshalledValue = marshalOptions.addCallbackIdsToRefs(marshalledValue);
+      } else {
+        marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
+      }
       return JSON.stringify({ ok: true, done: true, value: marshalledValue });
     } catch (error) {
       const err = error;
@@ -383,7 +467,14 @@ async function setupCustomFunctions(context, customFunctions) {
       });
       const result = await session.iterator.throw?.(error);
       iteratorSessions.delete(iteratorId);
-      const marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
+      let marshalledValue;
+      if (marshalOptions) {
+        const ctx = marshalOptions.createMarshalContext();
+        marshalledValue = await import_isolate_protocol3.marshalValue(result?.value, ctx);
+        marshalledValue = marshalOptions.addCallbackIdsToRefs(marshalledValue);
+      } else {
+        marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
+      }
       return JSON.stringify({
         ok: true,
         done: result?.done ?? true,
@@ -474,8 +565,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 import_isolate_protocol3.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 import_isolate_protocol3.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 import_isolate_protocol3.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;
@@ -484,29 +681,74 @@ function createModuleResolver(state) {
     }
     const importerPath = state.moduleToFilename.get(referrer) ?? "<unknown>";
     const importerResolveDir = import_node_path.default.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 = import_isolate_transform.contentHash(code);
     const cacheKey = `${specifier}:${hash}`;
+    const inFlightKey = `${result.static ? "static" : "dynamic"}:${cacheKey}`;
+    const staticCachedAfterLoad = state.staticModuleCache.get(specifier);
+    if (staticCachedAfterLoad)
+      return staticCachedAfterLoad;
+    const cachedAfterLoad = state.moduleCache.get(specifier);
+    if (cachedAfterLoad)
+      return cachedAfterLoad;
     const hashCached = state.moduleCache.get(cacheKey);
     if (hashCached)
       return hashCached;
-    const transformed = await import_isolate_transform.transformModuleCode(code, specifier);
-    if (transformed.sourceMap) {
-      state.sourceMaps.set(specifier, transformed.sourceMap);
+    const inFlight = state.moduleLoadsInFlight.get(inFlightKey);
+    if (inFlight)
+      return inFlight;
+    const loadPromise = (async () => {
+      let mod;
+      try {
+        let transformed = state.transformCache.get(hash);
+        if (!transformed) {
+          transformed = await import_isolate_transform.transformModuleCode(code, specifier);
+          state.transformCache.set(hash, transformed);
+        }
+        if (transformed.sourceMap) {
+          state.sourceMaps.set(specifier, transformed.sourceMap);
+        }
+        mod = await state.isolate.compileModule(transformed.code, {
+          filename: specifier
+        });
+        const resolvedPath = import_node_path.default.posix.join(resolveDir, import_node_path.default.posix.basename(specifier));
+        state.moduleToFilename.set(mod, resolvedPath);
+        if (result.static) {
+          state.staticModuleCache.set(specifier, mod);
+        } else {
+          state.moduleCache.set(specifier, mod);
+          state.moduleCache.set(cacheKey, mod);
+        }
+        return mod;
+      } catch (err) {
+        if (mod) {
+          state.moduleToFilename.delete(mod);
+          if (result.static) {
+            if (state.staticModuleCache.get(specifier) === mod) {
+              state.staticModuleCache.delete(specifier);
+            }
+          } else {
+            if (state.moduleCache.get(specifier) === mod) {
+              state.moduleCache.delete(specifier);
+            }
+            if (state.moduleCache.get(cacheKey) === mod) {
+              state.moduleCache.delete(cacheKey);
+            }
+          }
+        }
+        throw err;
+      }
+    })();
+    state.moduleLoadsInFlight.set(inFlightKey, loadPromise);
+    try {
+      return await loadPromise;
+    } finally {
+      state.moduleLoadsInFlight.delete(inFlightKey);
     }
-    const mod = await state.isolate.compileModule(transformed.code, {
-      filename: specifier
-    });
-    const resolvedPath = import_node_path.default.posix.join(resolveDir, import_node_path.default.posix.basename(specifier));
-    state.moduleToFilename.set(mod, resolvedPath);
-    state.moduleCache.set(specifier, mod);
-    state.moduleCache.set(cacheKey, mod);
-    const resolver = createModuleResolver(state);
-    await mod.instantiate(state.context, resolver);
-    return mod;
   };
 }
 function convertFetchCallback(callback) {
@@ -514,8 +756,8 @@ function convertFetchCallback(callback) {
     return {};
   }
   return {
-    onFetch: async (request) => {
-      return Promise.resolve(callback(request));
+    onFetch: async (url, init) => {
+      return Promise.resolve(callback(url, init));
     }
   };
 }
@@ -531,8 +773,13 @@ async function createRuntime(options) {
     context,
     handles: {},
     moduleCache: new Map,
+    staticModuleCache: new Map,
+    moduleLoadsInFlight: new Map,
+    transformCache: new Map,
     moduleToFilename: new Map,
     sourceMaps: new Map,
+    pendingCallbacks: [],
+    evalChain: Promise.resolve(),
     moduleLoader: opts.moduleLoader,
     customFunctions: opts.customFunctions
   };
@@ -547,13 +794,17 @@ async function createRuntime(options) {
     state.handles.fs = await import_isolate_fs.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 import_isolate_test_environment.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;
@@ -572,12 +823,13 @@ async function createRuntime(options) {
         }
       };
     }
-    state.handles.playwright = await import_isolate_playwright.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 import_isolate_playwright.setupPlaywright(context, playwrightSetupOptions);
   }
   const fetchHandle = {
     async dispatchRequest(request, options2) {
@@ -633,6 +885,48 @@ 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);
+    },
+    onEvent(callback) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.onEvent(callback);
+    },
+    dispatchEvent(event, payload) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchEvent(event, payload);
     }
   };
   const timersHandle = {
@@ -655,11 +949,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 import_isolate_test_environment.runTests(state.context);
+      if (timeout === undefined) {
+        return import_isolate_test_environment.runTests(state.context);
+      }
+      let timeoutId;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error("Test timeout")), timeout);
+      });
+      try {
+        return await Promise.race([
+          import_isolate_test_environment.runTests(state.context),
+          timeoutPromise
+        ]);
+      } finally {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      }
     },
     hasTests() {
       if (!state.handles.testEnvironment) {
@@ -680,7 +990,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(),
@@ -694,43 +1004,62 @@ async function createRuntime(options) {
   };
   return {
     id,
+    pendingCallbacks: state.pendingCallbacks,
     fetch: fetchHandle,
     timers: timersHandle,
     console: consoleHandle,
     testEnvironment: testEnvironmentHandle,
     playwright: playwrightHandle,
     async eval(code, filenameOrOptions) {
-      const options2 = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions } : filenameOrOptions;
-      const filename = import_isolate_protocol.normalizeEntryFilename(options2?.filename);
-      try {
-        const transformed = await import_isolate_transform.transformEntryCode(code, filename);
-        if (transformed.sourceMap) {
-          state.sourceMaps.set(filename, transformed.sourceMap);
-        }
-        const mod = await state.isolate.compileModule(transformed.code, {
-          filename
-        });
-        state.moduleToFilename.set(mod, filename);
-        const resolver = createModuleResolver(state);
-        await mod.instantiate(state.context, resolver);
-        await mod.evaluate();
-        const ns = mod.namespace;
-        const runRef = await ns.get("default", { reference: true });
+      const runEval = async () => {
+        const options2 = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions } : filenameOrOptions;
+        const filename = import_isolate_protocol.normalizeEntryFilename(options2?.filename);
         try {
-          await runRef.apply(undefined, [], {
-            result: { promise: true },
-            ...options2?.maxExecutionMs ? { timeout: options2.maxExecutionMs } : {}
+          const transformed = await import_isolate_transform.transformEntryCode(code, filename);
+          if (transformed.sourceMap) {
+            state.sourceMaps.set(filename, transformed.sourceMap);
+          }
+          const mod = await state.isolate.compileModule(transformed.code, {
+            filename
           });
-        } finally {
-          runRef.release();
-        }
-      } catch (err) {
-        const error = err;
-        if (error.stack && state.sourceMaps.size > 0) {
-          error.stack = import_isolate_transform.mapErrorStack(error.stack, state.sourceMaps);
+          state.moduleToFilename.set(mod, filename);
+          const resolver = createModuleResolver(state);
+          await mod.instantiate(state.context, resolver);
+          await mod.evaluate();
+          const ns = mod.namespace;
+          const runRef = await ns.get("default", { reference: true });
+          try {
+            await runRef.apply(undefined, [], {
+              result: { promise: true }
+            });
+          } 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) {
+            error.stack = import_isolate_transform.mapErrorStack(error.stack, state.sourceMaps);
+          }
+          throw error;
         }
-        throw error;
-      }
+      };
+      const queuedEval = state.evalChain.then(runEval, runEval);
+      state.evalChain = queuedEval.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      return queuedEval;
+    },
+    clearModuleCache() {
+      state.moduleCache.clear();
+      state.moduleLoadsInFlight.clear();
+      state.moduleToFilename.clear();
+      state.sourceMaps.clear();
     },
     async dispose() {
       if (state.customFnInvokeRef) {
@@ -747,10 +1076,11 @@ async function createRuntime(options) {
       state.handles.console?.dispose();
       state.handles.core?.dispose();
       state.moduleCache.clear();
+      state.moduleLoadsInFlight.clear();
       state.context.release();
       state.isolate.dispose();
     }
   };
 }
 
-//# debugId=230C5D24BE3157C264756E2164756E21
+//# debugId=9159E7F9BC462BBB64756E2164756E21