@ricsam/isolate-runtime 0.1.10 → 0.1.12

package/README.md

@@ -126,7 +126,7 @@ interface PlaywrightOptions {
   /** Print browser console logs to stdout */
   console?: boolean;
   /** Browser console log callback (from the page, not sandbox) */
-  onBrowserConsoleLog?: (entry: { level: string; args: unknown[]; timestamp: number }) => void;
+  onBrowserConsoleLog?: (entry: { level: string; stdout: string; timestamp: number }) => void;
   onNetworkRequest?: (info: { url: string; method: string; headers: Record<string, string>; timestamp: number }) => void;
   onNetworkResponse?: (info: { url: string; status: number; headers: Record<string, string>; timestamp: number }) => void;
 }
@@ -134,15 +134,20 @@ interface PlaywrightOptions {
 
 ## Module Loader
 
-Provide custom ES modules:
+Provide custom ES modules. The loader receives the module specifier and importer info, and returns an object with the source code and `resolveDir` (used to resolve nested relative imports):
 
 ```typescript
 const runtime = await createRuntime({
-  moduleLoader: async (moduleName) => {
+  moduleLoader: async (moduleName, importer) => {
+    // importer.path = resolved path of importing module
+    // importer.resolveDir = directory for relative resolution
     if (moduleName === "@/utils") {
-      return `
-        export function add(a, b) { return a + b; }
-      `;
+      return {
+        code: `
+          export function add(a, b) { return a + b; }
+        `,
+        resolveDir: "/modules",
+      };
     }
     throw new Error(`Unknown module: ${moduleName}`);
   },
@@ -355,7 +360,7 @@ const runtime = await createRuntime({
   playwright: {
     page,
     baseUrl: "https://example.com",
-    onBrowserConsoleLog: (entry) => console.log("[browser]", ...entry.args),
+    onBrowserConsoleLog: (entry) => console.log("[browser]", entry.stdout),
   },
 });
 

package/dist/cjs/index.cjs

@@ -71,6 +71,7 @@ __export(exports_src, {
   setupCore: () => import_isolate_core2.setupCore,
   setupConsole: () => import_isolate_console2.setupConsole,
   runTests: () => import_isolate_test_environment2.runTests,
+  normalizeEntryFilename: () => import_isolate_protocol2.normalizeEntryFilename,
   hasTests: () => import_isolate_test_environment2.hasTests,
   getTestCount: () => import_isolate_test_environment2.getTestCount,
   createRuntime: () => createRuntime,
@@ -79,7 +80,10 @@ __export(exports_src, {
 });
 module.exports = __toCommonJS(exports_src);
 var import_isolated_vm = __toESM(require("isolated-vm"));
+var import_node_path = __toESM(require("node:path"));
 var import_isolate_core = require("@ricsam/isolate-core");
+var import_isolate_protocol = require("@ricsam/isolate-protocol");
+var import_isolate_protocol2 = require("@ricsam/isolate-protocol");
 var import_isolate_console = require("@ricsam/isolate-console");
 var import_isolate_encoding = require("@ricsam/isolate-encoding");
 var import_isolate_timers = require("@ricsam/isolate-timers");
@@ -89,6 +93,7 @@ var import_isolate_fetch = require("@ricsam/isolate-fetch");
 var import_isolate_fs = require("@ricsam/isolate-fs");
 var import_isolate_test_environment = require("@ricsam/isolate-test-environment");
 var import_isolate_playwright = require("@ricsam/isolate-playwright");
+var import_isolate_protocol3 = require("@ricsam/isolate-protocol");
 var import_isolate_core2 = require("@ricsam/isolate-core");
 var import_isolate_console2 = require("@ricsam/isolate-console");
 var import_utils = require("@ricsam/isolate-console/utils");
@@ -103,6 +108,152 @@ 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 = `
+(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;
+        }
+        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) {
   const global = context.global;
   const invokeCallbackRef = new import_isolated_vm.default.Reference(async (name, argsJson) => {
@@ -116,10 +267,12 @@ async function setupCustomFunctions(context, customFunctions) {
         }
       });
     }
-    const args = JSON.parse(argsJson);
+    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);
-      return JSON.stringify({ ok: true, value: result });
+      const marshalledResult = await import_isolate_protocol3.marshalValue(result);
+      return JSON.stringify({ ok: true, value: marshalledResult });
     } catch (error) {
       const err = error;
       return JSON.stringify({
@@ -141,7 +294,8 @@ async function setupCustomFunctions(context, customFunctions) {
       });
     }
     try {
-      const args = JSON.parse(argsJson);
+      const rawArgs = JSON.parse(argsJson);
+      const args = import_isolate_protocol3.unmarshalValue(rawArgs);
       const fn = def.fn;
       const iterator = fn(...args);
       const iteratorId = nextIteratorId++;
@@ -172,10 +326,11 @@ async function setupCustomFunctions(context, customFunctions) {
       if (result.done) {
         iteratorSessions.delete(iteratorId);
       }
+      const marshalledValue = await import_isolate_protocol3.marshalValue(result.value);
       return JSON.stringify({
         ok: true,
         done: result.done,
-        value: result.value
+        value: marshalledValue
       });
     } catch (error) {
       const err = error;
@@ -193,10 +348,12 @@ async function setupCustomFunctions(context, customFunctions) {
       return JSON.stringify({ ok: true, done: true, value: undefined });
     }
     try {
-      const value = valueJson ? JSON.parse(valueJson) : undefined;
+      const rawValue = valueJson ? JSON.parse(valueJson) : undefined;
+      const value = import_isolate_protocol3.unmarshalValue(rawValue);
       const result = await session.iterator.return?.(value);
       iteratorSessions.delete(iteratorId);
-      return JSON.stringify({ ok: true, done: true, value: result?.value });
+      const marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
+      return JSON.stringify({ ok: true, done: true, value: marshalledValue });
     } catch (error) {
       const err = error;
       iteratorSessions.delete(iteratorId);
@@ -225,10 +382,11 @@ async function setupCustomFunctions(context, customFunctions) {
       });
       const result = await session.iterator.throw?.(error);
       iteratorSessions.delete(iteratorId);
+      const marshalledValue = await import_isolate_protocol3.marshalValue(result?.value);
       return JSON.stringify({
         ok: true,
         done: result?.done ?? true,
-        value: result?.value
+        value: marshalledValue
       });
     } catch (error) {
       const err = error;
@@ -240,18 +398,20 @@ async function setupCustomFunctions(context, customFunctions) {
     }
   });
   global.setSync("__iter_throw", iterThrowRef);
+  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 = __customFn_invoke.applySyncPromise(
             undefined,
-            ["${name}", JSON.stringify(args)]
+            ["${name}", JSON.stringify(marshalledArgs)]
           );
           const result = JSON.parse(resultJson);
           if (result.ok) {
-            return result.value;
+            return __unmarshalFromHost(result.value);
           } else {
             const error = new Error(result.error.message);
             error.name = result.error.name;
@@ -262,13 +422,14 @@ async function setupCustomFunctions(context, customFunctions) {
     } else if (def.type === "sync") {
       context.evalSync(`
         globalThis.${name} = function(...args) {
+          const marshalledArgs = __marshalForHost(args);
           const resultJson = __customFn_invoke.applySyncPromise(
             undefined,
-            ["${name}", JSON.stringify(args)]
+            ["${name}", JSON.stringify(marshalledArgs)]
           );
           const result = JSON.parse(resultJson);
           if (result.ok) {
-            return result.value;
+            return __unmarshalFromHost(result.value);
           } else {
             const error = new Error(result.error.message);
             error.name = result.error.name;
@@ -279,7 +440,8 @@ async function setupCustomFunctions(context, customFunctions) {
     } else if (def.type === "asyncIterator") {
       context.evalSync(`
         globalThis.${name} = function(...args) {
-          const startResult = JSON.parse(__iter_start.applySyncPromise(undefined, ["${name}", JSON.stringify(args)]));
+          const marshalledArgs = __marshalForHost(args);
+          const startResult = JSON.parse(__iter_start.applySyncPromise(undefined, ["${name}", JSON.stringify(marshalledArgs)]));
           if (!startResult.ok) {
             throw Object.assign(new Error(startResult.error.message), { name: startResult.error.name });
           }
@@ -291,18 +453,18 @@ async function setupCustomFunctions(context, customFunctions) {
               if (!result.ok) {
                 throw Object.assign(new Error(result.error.message), { name: result.error.name });
               }
-              return { done: result.done, value: result.value };
+              return { done: result.done, value: __unmarshalFromHost(result.value) };
             },
             async return(v) {
-              const result = JSON.parse(__iter_return.applySyncPromise(undefined, [iteratorId, JSON.stringify(v)]));
-              return { done: true, value: result.value };
+              const result = JSON.parse(__iter_return.applySyncPromise(undefined, [iteratorId, JSON.stringify(__marshalForHost(v))]));
+              return { done: true, value: __unmarshalFromHost(result.value) };
             },
             async throw(e) {
               const result = JSON.parse(__iter_throw.applySyncPromise(undefined, [iteratorId, JSON.stringify({ message: e.message, name: e.name })]));
               if (!result.ok) {
                 throw Object.assign(new Error(result.error.message), { name: result.error.name });
               }
-              return { done: result.done, value: result.value };
+              return { done: result.done, value: __unmarshalFromHost(result.value) };
             }
           };
         };
@@ -312,17 +474,24 @@ async function setupCustomFunctions(context, customFunctions) {
   return invokeCallbackRef;
 }
 function createModuleResolver(state) {
-  return async (specifier, _referrer) => {
+  return async (specifier, referrer) => {
     const cached = state.moduleCache.get(specifier);
     if (cached)
       return cached;
     if (!state.moduleLoader) {
       throw new Error(`No module loader registered. Cannot import: ${specifier}`);
     }
-    const code = await state.moduleLoader(specifier);
+    const importerPath = state.moduleToFilename.get(referrer) ?? "<unknown>";
+    const importerResolveDir = import_node_path.default.posix.dirname(importerPath);
+    const { code, resolveDir } = await state.moduleLoader(specifier, {
+      path: importerPath,
+      resolveDir: importerResolveDir
+    });
     const mod = await state.isolate.compileModule(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);
     const resolver = createModuleResolver(state);
     await mod.instantiate(state.context, resolver);
@@ -351,6 +520,7 @@ async function createRuntime(options) {
     context,
     handles: {},
     moduleCache: new Map,
+    moduleToFilename: new Map,
     moduleLoader: opts.moduleLoader,
     customFunctions: opts.customFunctions
   };
@@ -384,7 +554,7 @@ async function createRuntime(options) {
           consoleHandler({
             type: "browserOutput",
             level: event.level,
-            args: event.args,
+            stdout: event.stdout,
             timestamp: event.timestamp
           });
         }
@@ -520,9 +690,11 @@ async function createRuntime(options) {
     playwright: playwrightHandle,
     async eval(code, filenameOrOptions) {
       const options2 = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions } : filenameOrOptions;
+      const filename = import_isolate_protocol.normalizeEntryFilename(options2?.filename);
       const mod = await state.isolate.compileModule(code, {
-        filename: options2?.filename ?? "<eval>"
+        filename
       });
+      state.moduleToFilename.set(mod, filename);
       const resolver = createModuleResolver(state);
       await mod.instantiate(state.context, resolver);
       await mod.evaluate(options2?.maxExecutionMs ? { timeout: options2.maxExecutionMs } : undefined);
@@ -548,4 +720,4 @@ async function createRuntime(options) {
   };
 }
 
-//# debugId=6D096DCA13F6758764756E2164756E21
+//# debugId=B6BA58D3B2A5225064756E2164756E21