@ricsam/isolate 0.0.1 → 0.1.0

package/dist/mjs/internal/runtime/index.mjs

@@ -0,0 +1,1198 @@
+// packages/isolate/src/internal/runtime/index.ts
+import ivm from "isolated-vm";
+import path from "node:path";
+import { setupCore } from "../core/index.mjs";
+import { normalizeEntryFilename } from "../protocol/index.mjs";
+import {
+  transformEntryCode,
+  transformModuleCode,
+  contentHash,
+  mapErrorStack
+} from "../transform/index.mjs";
+import { normalizeEntryFilename as normalizeEntryFilename2 } from "../protocol/index.mjs";
+import { setupConsole } from "../console/index.mjs";
+import { setupEncoding } from "../encoding/index.mjs";
+import { setupTimers } from "../timers/index.mjs";
+import { setupPath } from "../path/index.mjs";
+import { setupCrypto } from "../crypto/index.mjs";
+import { setupFetch } from "../fetch/index.mjs";
+import { setupFs } from "../fs/index.mjs";
+import {
+  setupTestEnvironment,
+  runTests as runTestsInContext,
+  hasTests as hasTestsInContext,
+  getTestCount as getTestCountInContext
+} from "../test-environment/index.mjs";
+import {
+  setupPlaywright
+} from "../playwright/index.mjs";
+import {
+  marshalValue,
+  unmarshalValue
+} from "../protocol/index.mjs";
+import { setupCore as setupCore2 } from "../core/index.mjs";
+import { setupConsole as setupConsole2 } from "../console/index.mjs";
+import {
+  simpleConsoleHandler
+} from "../console/utils.mjs";
+import { setupCrypto as setupCrypto2 } from "../crypto/index.mjs";
+import { setupEncoding as setupEncoding2 } from "../encoding/index.mjs";
+import { setupFetch as setupFetch2 } from "../fetch/index.mjs";
+import { setupFs as setupFs2, createNodeFileSystemHandler } from "../fs/index.mjs";
+import { setupPath as setupPath2 } from "../path/index.mjs";
+import { setupTimers as setupTimers2 } from "../timers/index.mjs";
+import {
+  setupTestEnvironment as setupTestEnvironment2,
+  runTests,
+  hasTests,
+  getTestCount
+} from "../test-environment/index.mjs";
+import {
+  setupPlaywright as setupPlaywright2,
+  createPlaywrightHandler,
+  defaultPlaywrightHandler,
+  getDefaultPlaywrightHandlerMetadata
+} from "../playwright/index.mjs";
+function getConfiguredExecutionTimeout(timeoutMs) {
+  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return;
+  }
+  return timeoutMs;
+}
+function createTimeoutError(label, timeoutMs) {
+  const error = new Error(`${label} timed out after ${timeoutMs}ms`);
+  error.name = "TimeoutError";
+  return error;
+}
+function createDisposedRuntimeError() {
+  return new Error("Runtime has been disposed");
+}
+function createTimedOutRuntimeError(timeoutMs) {
+  const error = new Error(`Runtime execution timed out after ${timeoutMs}ms; create a new runtime.`);
+  error.name = "TimeoutError";
+  return error;
+}
+function assertRuntimeUsable(state) {
+  if (state.timedOutExecutionMs !== undefined) {
+    throw createTimedOutRuntimeError(state.timedOutExecutionMs);
+  }
+  if (state.isDisposed) {
+    throw createDisposedRuntimeError();
+  }
+}
+function logRuntimeDisposal(state, options) {
+  const message = `[isolate-runtime] Disposing runtime ${state.id}: ${options.reason}`;
+  if (options.error) {
+    console.error(message, options.error);
+    return;
+  }
+  console.warn(message);
+}
+async function disposeRuntimeState(state, options = { reason: "RuntimeHandle.dispose() called", log: false }) {
+  if (state.disposePromise) {
+    return state.disposePromise;
+  }
+  state.disposeReason = options.reason;
+  state.isDisposed = true;
+  if (options.log !== false) {
+    logRuntimeDisposal(state, options);
+  }
+  state.disposePromise = (async () => {
+    if (state.customFnInvokeRef) {
+      try {
+        state.customFnInvokeRef.release();
+      } catch {} finally {
+        state.customFnInvokeRef = undefined;
+      }
+    }
+    const disposeHandle = (dispose) => {
+      if (!dispose)
+        return;
+      try {
+        dispose();
+      } catch {}
+    };
+    disposeHandle(state.handles.playwright?.dispose.bind(state.handles.playwright));
+    disposeHandle(state.handles.testEnvironment?.dispose.bind(state.handles.testEnvironment));
+    disposeHandle(state.handles.fs?.dispose.bind(state.handles.fs));
+    disposeHandle(state.handles.fetch?.dispose.bind(state.handles.fetch));
+    disposeHandle(state.handles.crypto?.dispose.bind(state.handles.crypto));
+    disposeHandle(state.handles.path?.dispose.bind(state.handles.path));
+    disposeHandle(state.handles.timers?.dispose.bind(state.handles.timers));
+    disposeHandle(state.handles.encoding?.dispose.bind(state.handles.encoding));
+    disposeHandle(state.handles.console?.dispose.bind(state.handles.console));
+    disposeHandle(state.handles.core?.dispose.bind(state.handles.core));
+    state.pendingCallbacks.length = 0;
+    state.moduleCache.clear();
+    state.moduleLoadsInFlight.clear();
+    state.moduleToFilename.clear();
+    state.moduleImportChain.clear();
+    state.specifierToImporter.clear();
+    state.sourceMaps.clear();
+    try {
+      state.context.release();
+    } catch {}
+    try {
+      state.isolate.dispose();
+    } catch {}
+  })();
+  return state.disposePromise;
+}
+async function runWithExecutionTimeout(state, timeoutMs, label, operation) {
+  const effectiveTimeoutMs = getConfiguredExecutionTimeout(timeoutMs);
+  if (effectiveTimeoutMs === undefined) {
+    return operation();
+  }
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      const timeoutError = createTimeoutError(label, effectiveTimeoutMs);
+      state.timedOutExecutionMs ??= effectiveTimeoutMs;
+      disposeRuntimeState(state, {
+        reason: timeoutError.message,
+        error: timeoutError
+      });
+      reject(timeoutError);
+    }, effectiveTimeoutMs);
+  });
+  try {
+    return await Promise.race([operation(), timeoutPromise]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+var iteratorSessions = new Map;
+var ISOLATE_MARSHAL_CODE = `
+(function() {
+  // Marshal a value (JavaScript → Ref)
+  function marshalForHost(value, depth = 0) {
+    if (depth > 100) throw new Error('Maximum marshalling depth exceeded');
+
+    if (value === null) return null;
+    if (value === undefined) return { __type: 'UndefinedRef' };
+
+    const type = typeof value;
+    if (type === 'string' || type === 'number' || type === 'boolean') return value;
+    if (type === 'bigint') return { __type: 'BigIntRef', value: value.toString() };
+    if (type === 'function') throw new Error('Cannot marshal functions from isolate');
+    if (type === 'symbol') throw new Error('Cannot marshal Symbol values');
+
+    if (type === 'object') {
+      if (value instanceof Date) {
+        return { __type: 'DateRef', timestamp: value.getTime() };
+      }
+      if (value instanceof RegExp) {
+        return { __type: 'RegExpRef', source: value.source, flags: value.flags };
+      }
+      if (value instanceof URL) {
+        return { __type: 'URLRef', href: value.href };
+      }
+      if (typeof Headers !== 'undefined' && value instanceof Headers) {
+        const pairs = [];
+        value.forEach((v, k) => pairs.push([k, v]));
+        return { __type: 'HeadersRef', pairs };
+      }
+      if (value instanceof Uint8Array) {
+        return { __type: 'Uint8ArrayRef', data: Array.from(value) };
+      }
+      if (value instanceof ArrayBuffer) {
+        return { __type: 'Uint8ArrayRef', data: Array.from(new Uint8Array(value)) };
+      }
+      if (typeof Request !== 'undefined' && value instanceof Request) {
+        throw new Error('Cannot marshal Request from isolate. Use fetch callback instead.');
+      }
+      if (typeof Response !== 'undefined' && value instanceof Response) {
+        throw new Error('Cannot marshal Response from isolate. Return plain objects instead.');
+      }
+      if (typeof File !== 'undefined' && value instanceof File) {
+        throw new Error('Cannot marshal File from isolate.');
+      }
+      if (typeof Blob !== 'undefined' && value instanceof Blob) {
+        throw new Error('Cannot marshal Blob from isolate.');
+      }
+      if (typeof FormData !== 'undefined' && value instanceof FormData) {
+        throw new Error('Cannot marshal FormData from isolate.');
+      }
+      if (Array.isArray(value)) {
+        return value.map(v => marshalForHost(v, depth + 1));
+      }
+      // Plain object
+      const result = {};
+      for (const key of Object.keys(value)) {
+        result[key] = marshalForHost(value[key], depth + 1);
+      }
+      return result;
+    }
+    return value;
+  }
+
+  // Unmarshal a value (Ref → JavaScript)
+  function unmarshalFromHost(value, depth = 0) {
+    if (depth > 100) throw new Error('Maximum unmarshalling depth exceeded');
+
+    if (value === null) return null;
+    if (typeof value !== 'object') return value;
+
+    if (value.__type) {
+      switch (value.__type) {
+        case 'UndefinedRef': return undefined;
+        case 'DateRef': return new Date(value.timestamp);
+        case 'RegExpRef': return new RegExp(value.source, value.flags);
+        case 'BigIntRef': return BigInt(value.value);
+        case 'URLRef': return new URL(value.href);
+        case 'HeadersRef': return new Headers(value.pairs);
+        case 'Uint8ArrayRef': return new Uint8Array(value.data);
+        case 'RequestRef': {
+          const init = {
+            method: value.method,
+            headers: value.headers,
+            body: value.body ? new Uint8Array(value.body) : null,
+          };
+          if (value.mode) init.mode = value.mode;
+          if (value.credentials) init.credentials = value.credentials;
+          if (value.cache) init.cache = value.cache;
+          if (value.redirect) init.redirect = value.redirect;
+          if (value.referrer) init.referrer = value.referrer;
+          if (value.referrerPolicy) init.referrerPolicy = value.referrerPolicy;
+          if (value.integrity) init.integrity = value.integrity;
+          return new Request(value.url, init);
+        }
+        case 'ResponseRef': {
+          return new Response(value.body ? new Uint8Array(value.body) : null, {
+            status: value.status,
+            statusText: value.statusText,
+            headers: value.headers,
+          });
+        }
+        case 'FileRef': {
+          if (!value.name) {
+            return new Blob([new Uint8Array(value.data)], { type: value.type });
+          }
+          return new File([new Uint8Array(value.data)], value.name, {
+            type: value.type,
+            lastModified: value.lastModified,
+          });
+        }
+        case 'FormDataRef': {
+          const fd = new FormData();
+          for (const [key, entry] of value.entries) {
+            if (typeof entry === 'string') {
+              fd.append(key, entry);
+            } else {
+              const file = unmarshalFromHost(entry, depth + 1);
+              fd.append(key, file);
+            }
+          }
+          return fd;
+        }
+        case 'CallbackRef': {
+          const callbackId = value.callbackId;
+          return async function(...args) {
+            const argsJson = JSON.stringify(marshalForHost(args));
+            const resultJson = await __customFn_invoke.apply(
+              undefined,
+              [callbackId, argsJson],
+              { 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;
+          };
+        }
+        case 'PromiseRef': {
+          const promiseId = value.promiseId;
+          return (async () => {
+            const argsJson = JSON.stringify([promiseId]);
+            const resultJson = await __customFn_invoke.apply(
+              undefined,
+              [value.__resolveCallbackId, argsJson],
+              { 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;
+          })();
+        }
+        case 'AsyncIteratorRef': {
+          const iteratorId = value.iteratorId;
+          const nextCallbackId = value.__nextCallbackId;
+          const returnCallbackId = value.__returnCallbackId;
+          const throwCallbackId = value.__throwCallbackId;
+          return {
+            [Symbol.asyncIterator]() { return this; },
+            async next() {
+              const argsJson = JSON.stringify([iteratorId]);
+              const resultJson = await __customFn_invoke.apply(
+                undefined,
+                [nextCallbackId, argsJson],
+                { result: { promise: true, copy: true } }
+              );
+              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 = await __customFn_invoke.apply(
+                undefined,
+                [returnCallbackId, argsJson],
+                { result: { promise: true, copy: true } }
+              );
+              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 ?? true,
+                value: unmarshalFromHost(result.value.value ?? result.value),
+              };
+            },
+            async throw(e) {
+              if (throwCallbackId == null) {
+                throw e;
+              }
+              const errorValue = e && typeof e === 'object'
+                ? { message: e.message, name: e.name, stack: e.stack }
+                : { message: String(e), name: 'Error' };
+              const argsJson = JSON.stringify([iteratorId, errorValue]);
+              const resultJson = await __customFn_invoke.apply(
+                undefined,
+                [throwCallbackId, argsJson],
+                { result: { promise: true, copy: true } }
+              );
+              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),
+              };
+            }
+          };
+        }
+        default:
+          // Unknown ref type, return as-is
+          break;
+      }
+    }
+
+    if (Array.isArray(value)) {
+      return value.map(v => unmarshalFromHost(v, depth + 1));
+    }
+
+    // Plain object - recursively unmarshal
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = unmarshalFromHost(value[key], depth + 1);
+    }
+    return result;
+  }
+
+  // Expose as globals
+  globalThis.__marshalForHost = marshalForHost;
+  globalThis.__unmarshalFromHost = unmarshalFromHost;
+})();
+`;
+async function setupCustomFunctions(context, customFunctions, marshalOptions) {
+  const global = context.global;
+  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({
+        ok: false,
+        error: {
+          message: `Custom function '${name}' not found`,
+          name: "Error"
+        }
+      });
+    }
+    const rawArgs = JSON.parse(argsJson);
+    const args = unmarshalValue(rawArgs);
+    try {
+      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) {
+      const err = error;
+      return JSON.stringify({
+        ok: false,
+        error: { message: err.message, name: err.name }
+      });
+    }
+  });
+  global.setSync("__customFn_invoke", invokeCallbackRef);
+  context.evalSync(ISOLATE_MARSHAL_CODE);
+  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;
+        };
+      `);
+    } else if (def.type === "sync") {
+      context.evalSync(`
+        globalThis.${name} = function(...args) {
+          const marshalledArgs = __marshalForHost(args);
+          const resultJson = __customFn_invoke.applySync(
+            undefined,
+            ["${name}", JSON.stringify(marshalledArgs)],
+            { result: { 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;
+        };
+      `);
+    } else if (def.type === "asyncIterator") {
+      context.evalSync(`
+        globalThis.${name} = function(...args) {
+          const marshalledArgs = __marshalForHost(args);
+          const iteratorPromise = (async () => {
+            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);
+            }
+            throw Object.assign(new Error(result.error.message), {
+              name: result.error.name,
+            });
+          })();
+          return {
+            [Symbol.asyncIterator]() { return this; },
+            async next() {
+              const iterator = await iteratorPromise;
+              return iterator.next();
+            },
+            async return(v) {
+              const iterator = await iteratorPromise;
+              return iterator.return ? iterator.return(v) : { done: true, value: v };
+            },
+            async throw(e) {
+              const iterator = await iteratorPromise;
+              if (!iterator.throw) {
+                throw e;
+              }
+              return iterator.throw(e);
+            }
+          };
+        };
+      `);
+    }
+  }
+  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)
+        };
+      });
+      const throwCallbackId = nextLocalCallbackId++;
+      returnedCallbacks.set(throwCallbackId, async (iteratorId, errorValue) => {
+        const iterator = returnedIterators.get(iteratorId);
+        if (!iterator) {
+          throw new Error(`Iterator ${iteratorId} not found`);
+        }
+        try {
+          if (!iterator.throw) {
+            throw Object.assign(new Error(errorValue?.message ?? "Iterator does not support throw()"), { name: errorValue?.name ?? "Error", stack: errorValue?.stack });
+          }
+          const thrownError = Object.assign(new Error(errorValue?.message ?? "Iterator throw()"), { name: errorValue?.name ?? "Error", stack: errorValue?.stack });
+          const result2 = await iterator.throw(thrownError);
+          if (result2.done) {
+            returnedIterators.delete(iteratorId);
+          }
+          const ctx = createMarshalContext();
+          const marshalledValue = await marshalValue(result2.value, ctx);
+          return {
+            done: result2.done,
+            value: addCallbackIdsToRefs(marshalledValue)
+          };
+        } catch (error) {
+          returnedIterators.delete(iteratorId);
+          throw error;
+        }
+      });
+      return {
+        ...value,
+        __nextCallbackId: nextCallbackId,
+        __returnCallbackId: returnCallbackId,
+        __throwCallbackId: throwCallbackId
+      };
+    }
+    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 importerPath = state.moduleToFilename.get(referrer) ?? "<unknown>";
+    const importerResolveDir = path.posix.dirname(importerPath);
+    const importerStack = state.moduleImportChain.get(importerPath) ?? [];
+    const resolvedSpecifier = specifier.startsWith(".") ? path.posix.normalize(path.posix.join(importerResolveDir, specifier)) : specifier;
+    state.specifierToImporter.set(resolvedSpecifier, importerPath);
+    const staticCached = state.staticModuleCache.get(resolvedSpecifier);
+    if (staticCached)
+      return staticCached;
+    const cached = state.moduleCache.get(resolvedSpecifier);
+    if (cached)
+      return cached;
+    if (!state.moduleLoader) {
+      throw new Error(`No module loader registered. Cannot import: ${specifier}`);
+    }
+    const result = await state.moduleLoader(specifier, {
+      path: importerPath,
+      resolveDir: importerResolveDir
+    });
+    const { code, resolveDir } = result;
+    if (result.filename.includes("/")) {
+      throw new Error(`moduleLoader returned a filename with slashes: "${result.filename}". ` + `filename must be a basename (e.g. "utils.js"), not a path.`);
+    }
+    const resolvedFilename = path.posix.join(resolveDir, result.filename);
+    const hash = contentHash(code);
+    const cacheKey = `${resolvedSpecifier}:${hash}`;
+    const inFlightKey = `${result.static ? "static" : "dynamic"}:${cacheKey}`;
+    const staticCachedAfterLoad = state.staticModuleCache.get(resolvedSpecifier);
+    if (staticCachedAfterLoad)
+      return staticCachedAfterLoad;
+    const cachedAfterLoad = state.moduleCache.get(resolvedSpecifier);
+    if (cachedAfterLoad)
+      return cachedAfterLoad;
+    const hashCached = state.moduleCache.get(cacheKey);
+    if (hashCached)
+      return hashCached;
+    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 transformModuleCode(code, resolvedSpecifier);
+          state.transformCache.set(hash, transformed);
+        }
+        if (transformed.sourceMap) {
+          state.sourceMaps.set(resolvedSpecifier, transformed.sourceMap);
+        }
+        mod = await state.isolate.compileModule(transformed.code, {
+          filename: resolvedSpecifier
+        });
+        state.moduleToFilename.set(mod, resolvedFilename);
+        state.moduleImportChain.set(resolvedFilename, [...importerStack, importerPath]);
+        if (result.static) {
+          state.staticModuleCache.set(resolvedSpecifier, mod);
+        } else {
+          state.moduleCache.set(resolvedSpecifier, mod);
+          state.moduleCache.set(cacheKey, mod);
+        }
+        return mod;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        error.message = `Failed to compile module "${resolvedSpecifier}" (imported by "${importerPath}"):
+${error.message}`;
+        if (importerStack.length > 0) {
+          error.message += `
+
+Import chain:
+  ${[...importerStack, importerPath].join(`
+    -> `)}`;
+        }
+        if (mod) {
+          state.moduleToFilename.delete(mod);
+          if (result.static) {
+            if (state.staticModuleCache.get(resolvedSpecifier) === mod) {
+              state.staticModuleCache.delete(resolvedSpecifier);
+            }
+          } else {
+            if (state.moduleCache.get(resolvedSpecifier) === mod) {
+              state.moduleCache.delete(resolvedSpecifier);
+            }
+            if (state.moduleCache.get(cacheKey) === mod) {
+              state.moduleCache.delete(cacheKey);
+            }
+          }
+        }
+        throw error;
+      }
+    })();
+    state.moduleLoadsInFlight.set(inFlightKey, loadPromise);
+    try {
+      return await loadPromise;
+    } finally {
+      state.moduleLoadsInFlight.delete(inFlightKey);
+    }
+  };
+}
+function convertFetchCallback(callback) {
+  if (!callback) {
+    return {};
+  }
+  return {
+    onFetch: async (url, init) => {
+      return Promise.resolve(callback(url, init));
+    }
+  };
+}
+async function createRuntime(options) {
+  const opts = options ?? {};
+  const id = crypto.randomUUID();
+  const isolate = new ivm.Isolate({
+    memoryLimit: opts.memoryLimitMB
+  });
+  const context = await isolate.createContext();
+  const state = {
+    id,
+    isolate,
+    context,
+    handles: {},
+    moduleCache: new Map,
+    staticModuleCache: new Map,
+    moduleLoadsInFlight: new Map,
+    transformCache: new Map,
+    moduleToFilename: new Map,
+    sourceMaps: new Map,
+    moduleImportChain: new Map,
+    specifierToImporter: new Map,
+    pendingCallbacks: [],
+    evalChain: Promise.resolve(),
+    executionTimeout: getConfiguredExecutionTimeout(opts.executionTimeout),
+    isDisposed: false,
+    moduleLoader: opts.moduleLoader,
+    customFunctions: opts.customFunctions
+  };
+  state.handles.core = await setupCore(context);
+  state.handles.console = await setupConsole(context, opts.console);
+  state.handles.encoding = await setupEncoding(context);
+  state.handles.timers = await setupTimers(context);
+  state.handles.path = await setupPath(context, { cwd: opts.cwd });
+  state.handles.crypto = await setupCrypto(context);
+  state.handles.fetch = await setupFetch(context, convertFetchCallback(opts.fetch));
+  if (opts.fs) {
+    state.handles.fs = await setupFs(context, opts.fs);
+  }
+  if (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;
+      const consoleHandler = opts.console.onEntry;
+      eventCallback = (event) => {
+        if (originalCallback) {
+          originalCallback(event);
+        }
+        if (event.type === "browserConsoleLog") {
+          consoleHandler({
+            type: "browserOutput",
+            level: event.level,
+            stdout: event.stdout,
+            location: event.location,
+            timestamp: event.timestamp
+          });
+        }
+      };
+    }
+    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 ensureRuntimeUsable = () => {
+    assertRuntimeUsable(state);
+  };
+  const fetchHandle = {
+    async dispatchRequest(request, options2) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.dispatchRequest(request, options2);
+    },
+    getUpgradeRequest() {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.getUpgradeRequest();
+    },
+    dispatchWebSocketOpen(connectionId) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchWebSocketOpen(connectionId);
+    },
+    dispatchWebSocketMessage(connectionId, message) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchWebSocketMessage(connectionId, message);
+    },
+    dispatchWebSocketClose(connectionId, code, reason) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchWebSocketClose(connectionId, code, reason);
+    },
+    dispatchWebSocketError(connectionId, error) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchWebSocketError(connectionId, error);
+    },
+    onWebSocketCommand(callback) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.onWebSocketCommand(callback);
+    },
+    hasServeHandler() {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.hasServeHandler();
+    },
+    hasActiveConnections() {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.hasActiveConnections();
+    },
+    dispatchClientWebSocketOpen(socketId, protocol, extensions) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketOpen(socketId, protocol, extensions);
+    },
+    dispatchClientWebSocketMessage(socketId, data) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketMessage(socketId, data);
+    },
+    dispatchClientWebSocketClose(socketId, code, reason, wasClean) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketClose(socketId, code, reason, wasClean);
+    },
+    dispatchClientWebSocketError(socketId) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchClientWebSocketError(socketId);
+    },
+    onClientWebSocketCommand(callback) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.onClientWebSocketCommand(callback);
+    },
+    onEvent(callback) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.onEvent(callback);
+    },
+    dispatchEvent(event, payload) {
+      ensureRuntimeUsable();
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchEvent(event, payload);
+    }
+  };
+  const timersHandle = {
+    clearAll() {
+      ensureRuntimeUsable();
+      state.handles.timers?.clearAll();
+    }
+  };
+  const consoleHandle = {
+    reset() {
+      ensureRuntimeUsable();
+      state.handles.console?.reset();
+    },
+    getTimers() {
+      ensureRuntimeUsable();
+      return state.handles.console?.getTimers() ?? new Map;
+    },
+    getCounters() {
+      ensureRuntimeUsable();
+      return state.handles.console?.getCounters() ?? new Map;
+    },
+    getGroupDepth() {
+      ensureRuntimeUsable();
+      return state.handles.console?.getGroupDepth() ?? 0;
+    }
+  };
+  const testEnvironmentHandle = {
+    async runTests(timeout) {
+      ensureRuntimeUsable();
+      if (!state.handles.testEnvironment) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      const executionTimeout = timeout ?? state.executionTimeout;
+      return runWithExecutionTimeout(state, executionTimeout, "Test", async () => {
+        return runTestsInContext(state.context);
+      });
+    },
+    hasTests() {
+      ensureRuntimeUsable();
+      if (!state.handles.testEnvironment) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      return hasTestsInContext(state.context);
+    },
+    getTestCount() {
+      ensureRuntimeUsable();
+      if (!state.handles.testEnvironment) {
+        throw new Error("Test environment not enabled. Set testEnvironment: true in createRuntime options.");
+      }
+      return getTestCountInContext(state.context);
+    },
+    reset() {
+      ensureRuntimeUsable();
+      state.handles.testEnvironment?.dispose();
+    }
+  };
+  const playwrightHandle = {
+    getCollectedData() {
+      ensureRuntimeUsable();
+      if (!state.handles.playwright) {
+        throw new Error("Playwright not configured. Provide playwright.handler in createRuntime options.");
+      }
+      return {
+        browserConsoleLogs: state.handles.playwright.getBrowserConsoleLogs(),
+        pageErrors: state.handles.playwright.getPageErrors(),
+        networkRequests: state.handles.playwright.getNetworkRequests(),
+        networkResponses: state.handles.playwright.getNetworkResponses(),
+        requestFailures: state.handles.playwright.getRequestFailures()
+      };
+    },
+    clearCollectedData() {
+      ensureRuntimeUsable();
+      state.handles.playwright?.clearCollected();
+    }
+  };
+  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 executionTimeout = options2?.executionTimeout ?? state.executionTimeout;
+      const runEval = async () => {
+        assertRuntimeUsable(state);
+        const filename = normalizeEntryFilename(options2?.filename);
+        try {
+          await runWithExecutionTimeout(state, executionTimeout, "Execution", async () => {
+            const transformed = await 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);
+            state.moduleImportChain.set(filename, []);
+            const resolver = createModuleResolver(state);
+            try {
+              await mod.instantiate(state.context, resolver);
+            } catch (err) {
+              const error = err instanceof Error ? err : new Error(String(err));
+              const specifierMatch = error.message.match(/The requested module '([^']+)'/);
+              const exportMatch = error.message.match(/export named '([^']+)'/);
+              const failingSpecifier = specifierMatch?.[1];
+              const failingExport = exportMatch?.[1];
+              const importerFile = failingSpecifier ? state.specifierToImporter.get(failingSpecifier) : undefined;
+              const details = [];
+              if (importerFile) {
+                const chain = state.moduleImportChain.get(importerFile) ?? [];
+                const fullChain = [...chain, importerFile];
+                if (failingSpecifier)
+                  fullChain.push(failingSpecifier);
+                const trimmed = fullChain.length > 12 ? fullChain.slice(-12) : fullChain;
+                const prefix = fullChain.length > 12 ? `  ...
+` : "";
+                details.push(`Import chain:
+${prefix}${trimmed.map((p) => `  ${p}`).join(`
+    -> `)}`);
+              } else if (failingSpecifier) {
+                for (const [modPath, chain] of state.moduleImportChain) {
+                  if (modPath.includes(failingSpecifier) || modPath.endsWith(failingSpecifier)) {
+                    const fullChain = [...chain, modPath];
+                    const trimmed = fullChain.length > 12 ? fullChain.slice(-12) : fullChain;
+                    details.push(`Import chain:
+${trimmed.map((p) => `  ${p}`).join(`
+    -> `)}`);
+                    break;
+                  }
+                }
+              }
+              if (failingExport && failingSpecifier) {
+                details.push(`Hint: If '${failingExport}' is a TypeScript type/interface, use \`import type\` to prevent it from being resolved at runtime:
+` + `  import type { ${failingExport} } from '${failingSpecifier}';`);
+              }
+              const suffix = details.length > 0 ? `
+
+` + details.join(`
+
+`) : "";
+              error.message = `Module instantiation failed: ${error.message}${suffix}`;
+              throw error;
+            }
+            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 = mapErrorStack(error.stack, state.sourceMaps);
+          }
+          throw error;
+        }
+      };
+      const queuedEval = state.evalChain.then(runEval, runEval);
+      state.evalChain = queuedEval.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      return queuedEval;
+    },
+    clearModuleCache() {
+      ensureRuntimeUsable();
+      state.moduleCache.clear();
+      state.moduleLoadsInFlight.clear();
+      state.moduleToFilename.clear();
+      state.moduleImportChain.clear();
+      state.specifierToImporter.clear();
+      state.sourceMaps.clear();
+    },
+    async dispose() {
+      await disposeRuntimeState(state);
+    }
+  };
+}
+export {
+  simpleConsoleHandler,
+  setupTimers2 as setupTimers,
+  setupTestEnvironment2 as setupTestEnvironment,
+  setupPlaywright2 as setupPlaywright,
+  setupPath2 as setupPath,
+  setupFs2 as setupFs,
+  setupFetch2 as setupFetch,
+  setupEncoding2 as setupEncoding,
+  setupCrypto2 as setupCrypto,
+  setupCore2 as setupCore,
+  setupConsole2 as setupConsole,
+  runTests,
+  normalizeEntryFilename2 as normalizeEntryFilename,
+  hasTests,
+  getTestCount,
+  getDefaultPlaywrightHandlerMetadata,
+  defaultPlaywrightHandler,
+  createRuntime,
+  createPlaywrightHandler,
+  createNodeFileSystemHandler
+};
+
+//# debugId=246B42CD1F0441B264756E2164756E21