@ricsam/isolate 0.1.4 → 0.1.6

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,47 @@ 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`
+- `node:async_hooks` `createHook()`
+- `node:async_hooks` `executionAsyncId()`
+- `node:async_hooks` `triggerAsyncId()`
+- `node:async_hooks` `executionAsyncResource()`
+- `node:async_hooks` `asyncWrapProviders`
+
+Hook callbacks observe sandbox-managed resources such as promises, timers, host callback bridges, and user-created `AsyncResource`s. This is still not a claim of full Node internals parity outside the sandbox runtime.
+
+```ts
+import {
+  createHook,
+  executionAsyncResource,
+} from "node:async_hooks";
+
+const hook = createHook({
+  init(asyncId, type, triggerAsyncId, resource) {
+    resource.requestTag = type + ":" + asyncId;
+  },
+  before() {
+    console.log(executionAsyncResource().requestTag ?? null);
+  },
+}).enable();
+
+setTimeout(() => {
+  console.log(executionAsyncResource().requestTag);
+  hook.disable();
+}, 0);
+```
+
 ## Quick Start
 
 ```ts

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

@@ -0,0 +1,401 @@
+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"
+    || typeof native.setPromiseHooks !== "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 topLevelResource = {};
+  const topLevelExecutionState = {
+    asyncId: 1,
+    triggerAsyncId: 0,
+    type: "ROOT",
+    resource: topLevelResource,
+    destroyed: false,
+  };
+  const currentExecutionState = new AsyncContext.Variable({
+    name: "isolate.executionState",
+    defaultValue: topLevelExecutionState,
+  });
+
+  const promiseStateByPromise = new WeakMap();
+  const activeHooks = new Map();
+  const promiseFrameStack = [];
+  const kWrappedState = Symbol("isolate.asyncResourceState");
+  const kWrappedDestroy = Symbol("isolate.destroyAsyncResource");
+  let nextAsyncId = 2;
+  let hookDispatchDepth = 0;
+  let promiseHooksEnabled = false;
+
+  function getCurrentExecutionState() {
+    return currentExecutionState.get();
+  }
+
+  function normalizeType(type, fallback) {
+    if (typeof type === "string" && type.length > 0) {
+      return type;
+    }
+    return fallback;
+  }
+
+  function normalizeTriggerAsyncId(triggerAsyncId) {
+    return Number.isSafeInteger(triggerAsyncId) && triggerAsyncId >= 0
+      ? triggerAsyncId
+      : undefined;
+  }
+
+  function dispatchHook(name, args) {
+    if (hookDispatchDepth > 0 || activeHooks.size === 0) {
+      return;
+    }
+
+    hookDispatchDepth++;
+    try {
+      for (const [hook, callbacks] of Array.from(activeHooks.entries())) {
+        const callback = callbacks[name];
+        if (typeof callback === "function") {
+          Reflect.apply(callback, hook, args);
+        }
+      }
+    } finally {
+      hookDispatchDepth--;
+    }
+  }
+
+  function createResource(type, resource, options = {}) {
+    const normalizedOptions =
+      options && typeof options === "object" ? options : {};
+    const state = {
+      asyncId: nextAsyncId++,
+      triggerAsyncId:
+        normalizeTriggerAsyncId(normalizedOptions.triggerAsyncId)
+        ?? getCurrentExecutionState().asyncId,
+      type: normalizeType(type, "isolate.resource"),
+      resource:
+        resource !== undefined && resource !== null ? resource : {},
+      destroyed: false,
+    };
+
+    if (normalizedOptions.emitInit !== false) {
+      dispatchHook("init", [
+        state.asyncId,
+        state.type,
+        state.triggerAsyncId,
+        state.resource,
+      ]);
+    }
+
+    return state;
+  }
+
+  function enterResource(resourceState) {
+    return AsyncContextFrame.exchange(
+      new AsyncContextFrame(currentExecutionState, resourceState),
+    );
+  }
+
+  function destroyResource(resourceState) {
+    if (!resourceState || resourceState.destroyed) {
+      return false;
+    }
+    resourceState.destroyed = true;
+    dispatchHook("destroy", [resourceState.asyncId]);
+    return true;
+  }
+
+  function runWithResource(resourceState, fn, thisArg, args) {
+    const priorFrame = enterResource(resourceState);
+    let didRunBeforeHook = false;
+    try {
+      dispatchHook("before", [resourceState.asyncId]);
+      didRunBeforeHook = true;
+      return Reflect.apply(fn, thisArg, args);
+    } finally {
+      try {
+        if (didRunBeforeHook) {
+          dispatchHook("after", [resourceState.asyncId]);
+        }
+      } finally {
+        AsyncContextFrame.set(priorFrame);
+      }
+    }
+  }
+
+  function wrapCallback(callback, options = {}) {
+    if (typeof callback !== "function") {
+      return callback;
+    }
+
+    const normalizedOptions =
+      options && typeof options === "object" ? options : {};
+    const snapshot = new AsyncContext.Snapshot();
+    const resourceState = createResource(
+      normalizedOptions.type,
+      normalizedOptions.resource,
+      normalizedOptions,
+    );
+
+    function wrapped(...args) {
+      const thisArg = normalizedOptions.thisArg === undefined
+        ? this
+        : normalizedOptions.thisArg;
+      return snapshot.run(
+        () => runWithResource(resourceState, callback, thisArg, args),
+      );
+    }
+
+    try {
+      Object.defineProperty(wrapped, "name", {
+        configurable: true,
+        value: callback.name ? "wrapped " + callback.name : "wrapped",
+      });
+    } catch {}
+
+    Object.defineProperty(wrapped, kWrappedState, {
+      configurable: false,
+      enumerable: false,
+      value: resourceState,
+      writable: false,
+    });
+    Object.defineProperty(wrapped, kWrappedDestroy, {
+      configurable: false,
+      enumerable: false,
+      value: () => destroyResource(resourceState),
+      writable: false,
+    });
+
+    return wrapped;
+  }
+
+  function releaseCallback(callback) {
+    if (typeof callback !== "function") {
+      return false;
+    }
+    const destroy = callback[kWrappedDestroy];
+    if (typeof destroy === "function") {
+      return destroy();
+    }
+    return false;
+  }
+
+  function onPromiseInit(promise, parentPromise) {
+    const parentState = (
+      parentPromise && typeof parentPromise === "object"
+        ? promiseStateByPromise.get(parentPromise)
+        : undefined
+    );
+    const promiseState = createResource("PROMISE", promise, {
+      triggerAsyncId: parentState?.asyncId ?? getCurrentExecutionState().asyncId,
+    });
+    promiseStateByPromise.set(promise, promiseState);
+  }
+
+  function onPromiseBefore(promise) {
+    const promiseState = promiseStateByPromise.get(promise);
+    if (!promiseState) {
+      return;
+    }
+    const priorFrame = enterResource(promiseState);
+    promiseFrameStack.push(priorFrame);
+    try {
+      dispatchHook("before", [promiseState.asyncId]);
+    } catch (error) {
+      promiseFrameStack.pop();
+      AsyncContextFrame.set(priorFrame);
+      throw error;
+    }
+  }
+
+  function onPromiseAfter(promise) {
+    const promiseState = promiseStateByPromise.get(promise);
+    if (!promiseState) {
+      return;
+    }
+    const priorFrame = promiseFrameStack.pop();
+    try {
+      dispatchHook("after", [promiseState.asyncId]);
+    } finally {
+      AsyncContextFrame.set(priorFrame);
+    }
+  }
+
+  function onPromiseResolve(promise) {
+    const promiseState = promiseStateByPromise.get(promise);
+    if (!promiseState) {
+      return;
+    }
+    dispatchHook("promiseResolve", [promiseState.asyncId]);
+  }
+
+  function refreshPromiseHooks() {
+    if (activeHooks.size > 0) {
+      if (!promiseHooksEnabled) {
+        native.setPromiseHooks(
+          onPromiseInit,
+          onPromiseBefore,
+          onPromiseAfter,
+          onPromiseResolve,
+        );
+        promiseHooksEnabled = true;
+      }
+      return;
+    }
+
+    if (promiseHooksEnabled) {
+      native.setPromiseHooks(undefined, undefined, undefined, undefined);
+      promiseFrameStack.length = 0;
+      promiseHooksEnabled = false;
+    }
+  }
+
+  function enableHook(hook, callbacks) {
+    activeHooks.set(hook, callbacks);
+    refreshPromiseHooks();
+  }
+
+  function disableHook(hook) {
+    activeHooks.delete(hook);
+    refreshPromiseHooks();
+  }
+
+  Object.defineProperty(globalThis, "__isolateAsyncContextInternals", {
+    configurable: true,
+    enumerable: false,
+    writable: false,
+    value: {
+      AsyncContextFrame,
+      topLevelExecutionState,
+      currentExecutionState,
+      getCurrentExecutionState,
+      executionAsyncId() {
+        return getCurrentExecutionState().asyncId;
+      },
+      triggerAsyncId() {
+        return getCurrentExecutionState().triggerAsyncId;
+      },
+      executionAsyncResource() {
+        return getCurrentExecutionState().resource;
+      },
+      createResource,
+      runWithResource,
+      destroyResource,
+      wrapCallback,
+      releaseCallback,
+      enableHook,
+      disableHook,
+    },
+  });
+})();
+`;
+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"
+      && typeof globalThis.__ivmAsyncContextInternal?.setPromiseHooks === "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=890EACA6895F598664756E2164756E21

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    || typeof native.setPromiseHooks !== \"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\n  const topLevelResource = {};\n  const topLevelExecutionState = {\n    asyncId: 1,\n    triggerAsyncId: 0,\n    type: \"ROOT\",\n    resource: topLevelResource,\n    destroyed: false,\n  };\n  const currentExecutionState = new AsyncContext.Variable({\n    name: \"isolate.executionState\",\n    defaultValue: topLevelExecutionState,\n  });\n\n  const promiseStateByPromise = new WeakMap();\n  const activeHooks = new Map();\n  const promiseFrameStack = [];\n  const kWrappedState = Symbol(\"isolate.asyncResourceState\");\n  const kWrappedDestroy = Symbol(\"isolate.destroyAsyncResource\");\n  let nextAsyncId = 2;\n  let hookDispatchDepth = 0;\n  let promiseHooksEnabled = false;\n\n  function getCurrentExecutionState() {\n    return currentExecutionState.get();\n  }\n\n  function normalizeType(type, fallback) {\n    if (typeof type === \"string\" && type.length > 0) {\n      return type;\n    }\n    return fallback;\n  }\n\n  function normalizeTriggerAsyncId(triggerAsyncId) {\n    return Number.isSafeInteger(triggerAsyncId) && triggerAsyncId >= 0\n      ? triggerAsyncId\n      : undefined;\n  }\n\n  function dispatchHook(name, args) {\n    if (hookDispatchDepth > 0 || activeHooks.size === 0) {\n      return;\n    }\n\n    hookDispatchDepth++;\n    try {\n      for (const [hook, callbacks] of Array.from(activeHooks.entries())) {\n        const callback = callbacks[name];\n        if (typeof callback === \"function\") {\n          Reflect.apply(callback, hook, args);\n        }\n      }\n    } finally {\n      hookDispatchDepth--;\n    }\n  }\n\n  function createResource(type, resource, options = {}) {\n    const normalizedOptions =\n      options && typeof options === \"object\" ? options : {};\n    const state = {\n      asyncId: nextAsyncId++,\n      triggerAsyncId:\n        normalizeTriggerAsyncId(normalizedOptions.triggerAsyncId)\n        ?? getCurrentExecutionState().asyncId,\n      type: normalizeType(type, \"isolate.resource\"),\n      resource:\n        resource !== undefined && resource !== null ? resource : {},\n      destroyed: false,\n    };\n\n    if (normalizedOptions.emitInit !== false) {\n      dispatchHook(\"init\", [\n        state.asyncId,\n        state.type,\n        state.triggerAsyncId,\n        state.resource,\n      ]);\n    }\n\n    return state;\n  }\n\n  function enterResource(resourceState) {\n    return AsyncContextFrame.exchange(\n      new AsyncContextFrame(currentExecutionState, resourceState),\n    );\n  }\n\n  function destroyResource(resourceState) {\n    if (!resourceState || resourceState.destroyed) {\n      return false;\n    }\n    resourceState.destroyed = true;\n    dispatchHook(\"destroy\", [resourceState.asyncId]);\n    return true;\n  }\n\n  function runWithResource(resourceState, fn, thisArg, args) {\n    const priorFrame = enterResource(resourceState);\n    let didRunBeforeHook = false;\n    try {\n      dispatchHook(\"before\", [resourceState.asyncId]);\n      didRunBeforeHook = true;\n      return Reflect.apply(fn, thisArg, args);\n    } finally {\n      try {\n        if (didRunBeforeHook) {\n          dispatchHook(\"after\", [resourceState.asyncId]);\n        }\n      } finally {\n        AsyncContextFrame.set(priorFrame);\n      }\n    }\n  }\n\n  function wrapCallback(callback, options = {}) {\n    if (typeof callback !== \"function\") {\n      return callback;\n    }\n\n    const normalizedOptions =\n      options && typeof options === \"object\" ? options : {};\n    const snapshot = new AsyncContext.Snapshot();\n    const resourceState = createResource(\n      normalizedOptions.type,\n      normalizedOptions.resource,\n      normalizedOptions,\n    );\n\n    function wrapped(...args) {\n      const thisArg = normalizedOptions.thisArg === undefined\n        ? this\n        : normalizedOptions.thisArg;\n      return snapshot.run(\n        () => runWithResource(resourceState, callback, thisArg, args),\n      );\n    }\n\n    try {\n      Object.defineProperty(wrapped, \"name\", {\n        configurable: true,\n        value: callback.name ? \"wrapped \" + callback.name : \"wrapped\",\n      });\n    } catch {}\n\n    Object.defineProperty(wrapped, kWrappedState, {\n      configurable: false,\n      enumerable: false,\n      value: resourceState,\n      writable: false,\n    });\n    Object.defineProperty(wrapped, kWrappedDestroy, {\n      configurable: false,\n      enumerable: false,\n      value: () => destroyResource(resourceState),\n      writable: false,\n    });\n\n    return wrapped;\n  }\n\n  function releaseCallback(callback) {\n    if (typeof callback !== \"function\") {\n      return false;\n    }\n    const destroy = callback[kWrappedDestroy];\n    if (typeof destroy === \"function\") {\n      return destroy();\n    }\n    return false;\n  }\n\n  function onPromiseInit(promise, parentPromise) {\n    const parentState = (\n      parentPromise && typeof parentPromise === \"object\"\n        ? promiseStateByPromise.get(parentPromise)\n        : undefined\n    );\n    const promiseState = createResource(\"PROMISE\", promise, {\n      triggerAsyncId: parentState?.asyncId ?? getCurrentExecutionState().asyncId,\n    });\n    promiseStateByPromise.set(promise, promiseState);\n  }\n\n  function onPromiseBefore(promise) {\n    const promiseState = promiseStateByPromise.get(promise);\n    if (!promiseState) {\n      return;\n    }\n    const priorFrame = enterResource(promiseState);\n    promiseFrameStack.push(priorFrame);\n    try {\n      dispatchHook(\"before\", [promiseState.asyncId]);\n    } catch (error) {\n      promiseFrameStack.pop();\n      AsyncContextFrame.set(priorFrame);\n      throw error;\n    }\n  }\n\n  function onPromiseAfter(promise) {\n    const promiseState = promiseStateByPromise.get(promise);\n    if (!promiseState) {\n      return;\n    }\n    const priorFrame = promiseFrameStack.pop();\n    try {\n      dispatchHook(\"after\", [promiseState.asyncId]);\n    } finally {\n      AsyncContextFrame.set(priorFrame);\n    }\n  }\n\n  function onPromiseResolve(promise) {\n    const promiseState = promiseStateByPromise.get(promise);\n    if (!promiseState) {\n      return;\n    }\n    dispatchHook(\"promiseResolve\", [promiseState.asyncId]);\n  }\n\n  function refreshPromiseHooks() {\n    if (activeHooks.size > 0) {\n      if (!promiseHooksEnabled) {\n        native.setPromiseHooks(\n          onPromiseInit,\n          onPromiseBefore,\n          onPromiseAfter,\n          onPromiseResolve,\n        );\n        promiseHooksEnabled = true;\n      }\n      return;\n    }\n\n    if (promiseHooksEnabled) {\n      native.setPromiseHooks(undefined, undefined, undefined, undefined);\n      promiseFrameStack.length = 0;\n      promiseHooksEnabled = false;\n    }\n  }\n\n  function enableHook(hook, callbacks) {\n    activeHooks.set(hook, callbacks);\n    refreshPromiseHooks();\n  }\n\n  function disableHook(hook) {\n    activeHooks.delete(hook);\n    refreshPromiseHooks();\n  }\n\n  Object.defineProperty(globalThis, \"__isolateAsyncContextInternals\", {\n    configurable: true,\n    enumerable: false,\n    writable: false,\n    value: {\n      AsyncContextFrame,\n      topLevelExecutionState,\n      currentExecutionState,\n      getCurrentExecutionState,\n      executionAsyncId() {\n        return getCurrentExecutionState().asyncId;\n      },\n      triggerAsyncId() {\n        return getCurrentExecutionState().triggerAsyncId;\n      },\n      executionAsyncResource() {\n        return getCurrentExecutionState().resource;\n      },\n      createResource,\n      runWithResource,\n      destroyResource,\n      wrapCallback,\n      releaseCallback,\n      enableHook,\n      disableHook,\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      && typeof globalThis.__ivmAsyncContextInternal?.setPromiseHooks === \"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;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;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;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;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;AAwVhC,eAAsB,iBAAiB,CAAC,SAAmD;AAAA,EACzF,MAAM,YAAY,QAAQ,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAQlC;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": "890EACA6895F598664756E2164756E21",
+  "names": []
+}