@ricsam/isolate 0.1.4 → 0.1.5

package/README.md

@@ -1,13 +1,15 @@
 # @ricsam/isolate
 
-`@ricsam/isolate` is a runtime-centric JavaScript sandbox built on [`isolated-vm`](https://github.com/nicknisi/isolated-vm). It gives you a single host API for running isolated code with web-style capabilities such as `fetch`, files, streams, server handlers, module loading, and Playwright-backed browser tests.
+`@ricsam/isolate` is a runtime-centric JavaScript sandbox built on an async-context-enabled [`@ricsam/isolated-vm`](https://github.com/ricsam/isolated-vm) engine build. It gives you a single host API for running isolated code with web-style capabilities such as `fetch`, files, streams, server handlers, module loading, and Playwright-backed browser tests.
 
 ## Installation
 
 ```bash
-npm add @ricsam/isolate isolated-vm
+npm add @ricsam/isolate @ricsam/isolated-vm
 ```
 
+The `@ricsam/isolated-vm` peer includes the `createContext({ asyncContext: true })` support required by this repo. Upstream `isolated-vm` will fail fast during runtime boot with a clear AsyncContext error.
+
 Install Playwright when you want browser runtimes:
 
 ```bash
@@ -41,6 +43,27 @@ Each runtime is configured through `bindings`, which describe how sandboxed code
 
 Every host callback receives a `HostCallContext` with an `AbortSignal`, runtime identity, resource identity, and request metadata.
 
+## Async Context
+
+Runtimes created by `@ricsam/isolate` enable the TC39 proposal-style `AsyncContext` global inside the sandbox. This is an experimental surface for now, and the proposal API is used to implement the `node:async_hooks` shim exported to sandboxed code.
+
+This shim is intended for async context propagation inside the sandbox. It is not a full reimplementation of Node's `async_hooks` lifecycle, resource graph, or profiling APIs.
+
+What is currently supported:
+
+- `AsyncContext.Variable`
+- `AsyncContext.Snapshot`
+- `node:async_hooks` `AsyncLocalStorage`
+- `node:async_hooks` `AsyncResource`
+
+What is intentionally not implemented in `node:async_hooks` yet:
+
+- `createHook()`
+- `executionAsyncId()`
+- `triggerAsyncId()`
+- `executionAsyncResource()`
+- `asyncWrapProviders`
+
 ## Quick Start
 
 ```ts

package/dist/cjs/internal/async-context/index.cjs

@@ -0,0 +1,140 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/internal/async-context/index.ts
+var exports_async_context = {};
+__export(exports_async_context, {
+  setupAsyncContext: () => setupAsyncContext
+});
+module.exports = __toCommonJS(exports_async_context);
+var ASYNC_CONTEXT_BOOTSTRAP = `
+(function() {
+  if (globalThis.__isolateAsyncContextInternals) {
+    return;
+  }
+
+  const AsyncContext = globalThis.AsyncContext;
+  const native = globalThis.__ivmAsyncContextInternal;
+  if (
+    !AsyncContext
+    || typeof AsyncContext.Variable !== "function"
+    || typeof AsyncContext.Snapshot !== "function"
+    || !native
+    || typeof native.getContinuationPreservedEmbedderData !== "function"
+    || typeof native.setContinuationPreservedEmbedderData !== "function"
+  ) {
+    throw new Error(
+      "The installed isolated-vm runtime does not expose async context support. " +
+      "Install the async-context-enabled isolate engine build."
+    );
+  }
+
+  class AsyncContextFrame extends Map {
+    constructor(store, value) {
+      super(AsyncContextFrame.current() ?? undefined);
+      if (arguments.length > 0) {
+        this.set(store, value);
+      }
+    }
+
+    static current() {
+      return native.getContinuationPreservedEmbedderData();
+    }
+
+    static set(frame) {
+      native.setContinuationPreservedEmbedderData(frame);
+    }
+
+    static exchange(frame) {
+      const prior = this.current();
+      this.set(frame);
+      return prior;
+    }
+
+    static disable(store) {
+      const frame = this.current();
+      frame?.delete(store);
+    }
+  }
+
+  Object.defineProperty(AsyncContextFrame, "enabled", {
+    configurable: true,
+    enumerable: false,
+    value: true,
+  });
+  const currentAsyncResource = new AsyncContext.Variable({
+    name: "isolate.asyncResource",
+    defaultValue: undefined,
+  });
+
+  const wrapCallback = (callback) => {
+    if (typeof callback !== "function") {
+      return callback;
+    }
+    return AsyncContext.Snapshot.wrap(callback);
+  };
+
+  Object.defineProperty(globalThis, "__isolateAsyncContextInternals", {
+    configurable: true,
+    enumerable: false,
+    writable: false,
+    value: {
+      AsyncContextFrame,
+      currentAsyncResource,
+      wrapCallback,
+    },
+  });
+})();
+`;
+async function setupAsyncContext(context) {
+  const supported = context.evalSync(`
+    typeof globalThis.AsyncContext === "object"
+      && typeof globalThis.AsyncContext?.Variable === "function"
+      && typeof globalThis.AsyncContext?.Snapshot === "function"
+      && typeof globalThis.__ivmAsyncContextInternal === "object"
+      && typeof globalThis.__ivmAsyncContextInternal?.getContinuationPreservedEmbedderData === "function"
+      && typeof globalThis.__ivmAsyncContextInternal?.setContinuationPreservedEmbedderData === "function"
+  `);
+  if (!supported) {
+    throw new Error("The installed isolated-vm runtime does not support AsyncContext. " + "Use the async-context-enabled isolate engine build.");
+  }
+  context.evalSync(ASYNC_CONTEXT_BOOTSTRAP);
+  return { supported };
+}
+
+//# debugId=68BD605C0C0582DB64756E2164756E21

package/dist/cjs/internal/async-context/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/async-context/index.ts"],
+  "sourcesContent": [
+    "import type ivm from \"@ricsam/isolated-vm\";\n\nconst ASYNC_CONTEXT_BOOTSTRAP = `\n(function() {\n  if (globalThis.__isolateAsyncContextInternals) {\n    return;\n  }\n\n  const AsyncContext = globalThis.AsyncContext;\n  const native = globalThis.__ivmAsyncContextInternal;\n  if (\n    !AsyncContext\n    || typeof AsyncContext.Variable !== \"function\"\n    || typeof AsyncContext.Snapshot !== \"function\"\n    || !native\n    || typeof native.getContinuationPreservedEmbedderData !== \"function\"\n    || typeof native.setContinuationPreservedEmbedderData !== \"function\"\n  ) {\n    throw new Error(\n      \"The installed isolated-vm runtime does not expose async context support. \" +\n      \"Install the async-context-enabled isolate engine build.\"\n    );\n  }\n\n  class AsyncContextFrame extends Map {\n    constructor(store, value) {\n      super(AsyncContextFrame.current() ?? undefined);\n      if (arguments.length > 0) {\n        this.set(store, value);\n      }\n    }\n\n    static current() {\n      return native.getContinuationPreservedEmbedderData();\n    }\n\n    static set(frame) {\n      native.setContinuationPreservedEmbedderData(frame);\n    }\n\n    static exchange(frame) {\n      const prior = this.current();\n      this.set(frame);\n      return prior;\n    }\n\n    static disable(store) {\n      const frame = this.current();\n      frame?.delete(store);\n    }\n  }\n\n  Object.defineProperty(AsyncContextFrame, \"enabled\", {\n    configurable: true,\n    enumerable: false,\n    value: true,\n  });\n  const currentAsyncResource = new AsyncContext.Variable({\n    name: \"isolate.asyncResource\",\n    defaultValue: undefined,\n  });\n\n  const wrapCallback = (callback) => {\n    if (typeof callback !== \"function\") {\n      return callback;\n    }\n    return AsyncContext.Snapshot.wrap(callback);\n  };\n\n  Object.defineProperty(globalThis, \"__isolateAsyncContextInternals\", {\n    configurable: true,\n    enumerable: false,\n    writable: false,\n    value: {\n      AsyncContextFrame,\n      currentAsyncResource,\n      wrapCallback,\n    },\n  });\n})();\n`;\n\nexport interface AsyncContextHandle {\n  supported: boolean;\n}\n\nexport async function setupAsyncContext(context: ivm.Context): Promise<AsyncContextHandle> {\n  const supported = context.evalSync(`\n    typeof globalThis.AsyncContext === \"object\"\n      && typeof globalThis.AsyncContext?.Variable === \"function\"\n      && typeof globalThis.AsyncContext?.Snapshot === \"function\"\n      && typeof globalThis.__ivmAsyncContextInternal === \"object\"\n      && typeof globalThis.__ivmAsyncContextInternal?.getContinuationPreservedEmbedderData === \"function\"\n      && typeof globalThis.__ivmAsyncContextInternal?.setContinuationPreservedEmbedderData === \"function\"\n  `) as boolean;\n\n  if (!supported) {\n    throw new Error(\n      \"The installed isolated-vm runtime does not support AsyncContext. \" +\n      \"Use the async-context-enabled isolate engine build.\"\n    );\n  }\n\n  context.evalSync(ASYNC_CONTEXT_BOOTSTRAP);\n  return { supported };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,0BAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoFhC,eAAsB,iBAAiB,CAAC,SAAmD;AAAA,EACzF,MAAM,YAAY,QAAQ,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAOlC;AAAA,EAED,IAAI,CAAC,WAAW;AAAA,IACd,MAAM,IAAI,MACR,sEACA,qDACF;AAAA,EACF;AAAA,EAEA,QAAQ,SAAS,uBAAuB;AAAA,EACxC,OAAO,EAAE,UAAU;AAAA;",
+  "debugId": "68BD605C0C0582DB64756E2164756E21",
+  "names": []
+}

package/dist/cjs/internal/client/connection.cjs

@@ -81,6 +81,7 @@ async function connect(options = {}) {
   const state = {
     socket,
     pendingRequests: new Map,
+    pendingCallbackCalls: new Map,
     callbacks: new Map,
     callbacksNeedingRequestId: new Set,
     nextRequestId: 1,
@@ -113,6 +114,10 @@ async function connect(options = {}) {
         pending.reject(new Error("Connection closed"));
       }
       state.pendingRequests.clear();
+      for (const [, pending] of state.pendingCallbackCalls) {
+        pending.reject(new Error("Connection closed"));
+      }
+      state.pendingCallbackCalls.clear();
       for (const [, receiver] of state.streamResponses) {
         receiver.state = "errored";
         receiver.error = new Error("Connection closed");
@@ -310,6 +315,24 @@ function handleMessage(message, state) {
       handleCallbackInvoke(invoke, state);
       break;
     }
+    case import_protocol.MessageType.CALLBACK_RESPONSE: {
+      const response = message;
+      const pending = state.pendingCallbackCalls.get(response.requestId);
+      if (pending) {
+        state.pendingCallbackCalls.delete(response.requestId);
+        if (response.error) {
+          const error = new Error(response.error.message);
+          error.name = response.error.name;
+          if (response.error.stack) {
+            error.stack = response.error.stack;
+          }
+          pending.reject(error);
+        } else {
+          pending.resolve(response.result);
+        }
+      }
+      break;
+    }
     case import_protocol.MessageType.PONG:
       break;
     case import_protocol.MessageType.CALLBACK_STREAM_CANCEL: {
@@ -550,6 +573,27 @@ async function handleCallbackInvoke(invoke, state) {
     }
   }
 }
+function invokeDaemonCallback(state, callbackId, args) {
+  if (!state.connected) {
+    return Promise.reject(new Error("Not connected"));
+  }
+  const requestId = state.nextRequestId++;
+  const requestContext = import_request_context.getRequestContext();
+  const invoke = {
+    type: import_protocol.MessageType.CALLBACK_INVOKE,
+    requestId,
+    callbackId,
+    args,
+    context: requestContext ? {
+      requestId: requestContext.requestId,
+      metadata: requestContext.metadata
+    } : undefined
+  };
+  return new Promise((resolve, reject) => {
+    state.pendingCallbackCalls.set(requestId, { resolve, reject });
+    sendMessage(state.socket, invoke);
+  });
+}
 function sendMessage(socket, message) {
   const frame = import_protocol.buildFrame(message);
   socket.write(frame);
@@ -1416,13 +1460,141 @@ var returnedPromiseRegistry = new Map;
 var returnedIteratorRegistry = new Map;
 function registerCustomFunctions(state, customFunctions) {
   const registrations = {};
+  const addCallbackIdsToRefs = (value) => {
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (import_protocol.isPromiseRef(value)) {
+      const resolveCallbackId = state.nextCallbackId++;
+      state.callbacks.set(resolveCallbackId, async (...args) => {
+        const promiseId = args[0];
+        const promise = returnedPromiseRegistry.get(promiseId);
+        if (!promise) {
+          throw new Error(`Promise ${promiseId} not found`);
+        }
+        const promiseResult = await promise;
+        returnedPromiseRegistry.delete(promiseId);
+        const marshalledResult = await import_protocol.marshalValue(promiseResult, marshalCtx);
+        return addCallbackIdsToRefs(marshalledResult);
+      });
+      return {
+        ...value,
+        __resolveCallbackId: resolveCallbackId
+      };
+    }
+    if (import_protocol.isAsyncIteratorRef(value)) {
+      const nextCallbackId = state.nextCallbackId++;
+      state.callbacks.set(nextCallbackId, async (...args) => {
+        const iteratorId = args[0];
+        const iterator = returnedIteratorRegistry.get(iteratorId);
+        if (!iterator) {
+          throw new Error(`Iterator ${iteratorId} not found`);
+        }
+        const iterResult = await iterator.next();
+        if (iterResult.done) {
+          returnedIteratorRegistry.delete(iteratorId);
+        }
+        const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
+        return {
+          done: iterResult.done,
+          value: addCallbackIdsToRefs(marshalledValue)
+        };
+      });
+      const returnCallbackId = state.nextCallbackId++;
+      state.callbacks.set(returnCallbackId, async (...args) => {
+        const iteratorId = args[0];
+        const returnValue = args[1];
+        const iterator = returnedIteratorRegistry.get(iteratorId);
+        returnedIteratorRegistry.delete(iteratorId);
+        if (!iterator || !iterator.return) {
+          return { done: true, value: undefined };
+        }
+        const iterResult = await iterator.return(returnValue);
+        const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
+        return {
+          done: true,
+          value: addCallbackIdsToRefs(marshalledValue)
+        };
+      });
+      const throwCallbackId = state.nextCallbackId++;
+      state.callbacks.set(throwCallbackId, async (...args) => {
+        const iteratorId = args[0];
+        const errorValue = args[1];
+        const iterator = returnedIteratorRegistry.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 iterResult = await iterator.throw(thrownError);
+          if (iterResult.done) {
+            returnedIteratorRegistry.delete(iteratorId);
+          }
+          const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
+          return {
+            done: iterResult.done,
+            value: addCallbackIdsToRefs(marshalledValue)
+          };
+        } catch (error) {
+          returnedIteratorRegistry.delete(iteratorId);
+          throw error;
+        }
+      });
+      return {
+        ...value,
+        __nextCallbackId: nextCallbackId,
+        __returnCallbackId: returnCallbackId,
+        __throwCallbackId: throwCallbackId
+      };
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => addCallbackIdsToRefs(item));
+    }
+    const objResult = {};
+    for (const key of Object.keys(value)) {
+      objResult[key] = addCallbackIdsToRefs(value[key]);
+    }
+    return objResult;
+  };
+  const marshalCtx = {
+    registerCallback: (fn) => {
+      const returnedCallbackId = state.nextCallbackId++;
+      state.callbacks.set(returnedCallbackId, async (...args) => {
+        const fnResult = await fn(...args);
+        const marshalledResult = await import_protocol.marshalValue(fnResult, marshalCtx);
+        return addCallbackIdsToRefs(marshalledResult);
+      });
+      return returnedCallbackId;
+    },
+    registerPromise: (promise) => {
+      const promiseId = state.nextCallbackId++;
+      returnedPromiseRegistry.set(promiseId, promise);
+      return promiseId;
+    },
+    registerIterator: (iterator) => {
+      const iteratorId = state.nextCallbackId++;
+      returnedIteratorRegistry.set(iteratorId, iterator);
+      return iteratorId;
+    }
+  };
+  const unmarshalCtx = {};
+  unmarshalCtx.getCallback = (callbackId) => {
+    return async (...args) => {
+      const marshalledArgs = await import_protocol.marshalValue(args, marshalCtx);
+      const result = await invokeDaemonCallback(state, callbackId, addCallbackIdsToRefs(marshalledArgs));
+      return import_protocol.unmarshalValue(result, unmarshalCtx);
+    };
+  };
   for (const [name, def] of Object.entries(customFunctions)) {
     if (def.type === "asyncIterator") {
       const startCallbackId = state.nextCallbackId++;
       state.callbacks.set(startCallbackId, async (...args) => {
         try {
           const fn = def.fn;
-          const iterator = fn(...args);
+          const iterator = fn(...import_protocol.unmarshalValue(args, unmarshalCtx));
           const iteratorId = nextClientIteratorId++;
           clientIteratorSessions.set(iteratorId, { iterator });
           return { iteratorId };
@@ -1491,127 +1663,7 @@ function registerCustomFunctions(state, customFunctions) {
     } else {
       const callbackId = state.nextCallbackId++;
       state.callbacks.set(callbackId, async (...args) => {
-        const result = await def.fn(...args);
-        const addCallbackIdsToRefs = (value) => {
-          if (value === null || typeof value !== "object") {
-            return value;
-          }
-          if (import_protocol.isPromiseRef(value)) {
-            const resolveCallbackId = state.nextCallbackId++;
-            state.callbacks.set(resolveCallbackId, async (...args2) => {
-              const promiseId = args2[0];
-              const promise = returnedPromiseRegistry.get(promiseId);
-              if (!promise) {
-                throw new Error(`Promise ${promiseId} not found`);
-              }
-              const promiseResult = await promise;
-              returnedPromiseRegistry.delete(promiseId);
-              const marshalledResult = await import_protocol.marshalValue(promiseResult, marshalCtx);
-              return addCallbackIdsToRefs(marshalledResult);
-            });
-            return {
-              ...value,
-              __resolveCallbackId: resolveCallbackId
-            };
-          }
-          if (import_protocol.isAsyncIteratorRef(value)) {
-            const nextCallbackId = state.nextCallbackId++;
-            state.callbacks.set(nextCallbackId, async (...args2) => {
-              const iteratorId = args2[0];
-              const iterator = returnedIteratorRegistry.get(iteratorId);
-              if (!iterator) {
-                throw new Error(`Iterator ${iteratorId} not found`);
-              }
-              const iterResult = await iterator.next();
-              if (iterResult.done) {
-                returnedIteratorRegistry.delete(iteratorId);
-              }
-              const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
-              return {
-                done: iterResult.done,
-                value: addCallbackIdsToRefs(marshalledValue)
-              };
-            });
-            const returnCallbackId = state.nextCallbackId++;
-            state.callbacks.set(returnCallbackId, async (...args2) => {
-              const iteratorId = args2[0];
-              const returnValue = args2[1];
-              const iterator = returnedIteratorRegistry.get(iteratorId);
-              returnedIteratorRegistry.delete(iteratorId);
-              if (!iterator || !iterator.return) {
-                return { done: true, value: undefined };
-              }
-              const iterResult = await iterator.return(returnValue);
-              const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
-              return {
-                done: true,
-                value: addCallbackIdsToRefs(marshalledValue)
-              };
-            });
-            const throwCallbackId = state.nextCallbackId++;
-            state.callbacks.set(throwCallbackId, async (...args2) => {
-              const iteratorId = args2[0];
-              const errorValue = args2[1];
-              const iterator = returnedIteratorRegistry.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 iterResult = await iterator.throw(thrownError);
-                if (iterResult.done) {
-                  returnedIteratorRegistry.delete(iteratorId);
-                }
-                const marshalledValue = await import_protocol.marshalValue(iterResult.value, marshalCtx);
-                return {
-                  done: iterResult.done,
-                  value: addCallbackIdsToRefs(marshalledValue)
-                };
-              } catch (error) {
-                returnedIteratorRegistry.delete(iteratorId);
-                throw error;
-              }
-            });
-            return {
-              ...value,
-              __nextCallbackId: nextCallbackId,
-              __returnCallbackId: returnCallbackId,
-              __throwCallbackId: throwCallbackId
-            };
-          }
-          if (Array.isArray(value)) {
-            return value.map((item) => addCallbackIdsToRefs(item));
-          }
-          const objResult = {};
-          for (const key of Object.keys(value)) {
-            objResult[key] = addCallbackIdsToRefs(value[key]);
-          }
-          return objResult;
-        };
-        const marshalCtx = {
-          registerCallback: (fn) => {
-            const returnedCallbackId = state.nextCallbackId++;
-            state.callbacks.set(returnedCallbackId, async (...args2) => {
-              const fnResult = await fn(...args2);
-              const marshalledResult = await import_protocol.marshalValue(fnResult, marshalCtx);
-              return addCallbackIdsToRefs(marshalledResult);
-            });
-            return returnedCallbackId;
-          },
-          registerPromise: (promise) => {
-            const promiseId = state.nextCallbackId++;
-            returnedPromiseRegistry.set(promiseId, promise);
-            return promiseId;
-          },
-          registerIterator: (iterator) => {
-            const iteratorId = state.nextCallbackId++;
-            returnedIteratorRegistry.set(iteratorId, iterator);
-            return iteratorId;
-          }
-        };
+        const result = await def.fn(...import_protocol.unmarshalValue(args, unmarshalCtx));
         const marshalled = await import_protocol.marshalValue(result, marshalCtx);
         const withCallbackIds = addCallbackIdsToRefs(marshalled);
         return withCallbackIds;
@@ -1916,4 +1968,4 @@ function handleClientWsClose(isolateId, payload, state) {
   }
 }
 
-//# debugId=7D1BE4A52F267ED264756E2164756E21
+//# debugId=6EEF0F611807A4E264756E2164756E21