poe-code 4.0.72 → 5.0.0

package/dist/index.js

@@ -136874,7 +136874,7 @@ function getEnumerableDataEntries(value) {
 function getEnumerableDataValues(value) {
   return getEnumerableDataEntries(value).map(([, entry]) => entry);
 }
-var DUMP_FORMAT_VERSION, SKIP_VALUE;
+var DUMP_FORMAT_VERSION, EXECUTION_SEMANTICS, SKIP_VALUE;
 var init_dump_format = __esm({
   "packages/safejs/src/snapshot/dump-format.ts"() {
     "use strict";
@@ -136882,6 +136882,7 @@ var init_dump_format = __esm({
     init_arguments();
     init_arguments2();
     DUMP_FORMAT_VERSION = 1;
+    EXECUTION_SEMANTICS = "jobs-v1";
     SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
   }
 });
@@ -137683,11 +137684,17 @@ function createSandboxPromise(promise, metadata = {}) {
     enumerable: false,
     value: true
   });
+  Object.defineProperty(sandboxPromise, Symbol.toStringTag, { value: "Promise" });
   if (metadata.span !== void 0) {
     Object.defineProperty(sandboxPromise, "span", {
       value: metadata.span
     });
   }
+  if (metadata.synchronousPrefix !== void 0) {
+    Object.defineProperty(sandboxPromise, "synchronousPrefix", {
+      value: metadata.synchronousPrefix
+    });
+  }
   if (metadata.hostCall !== void 0) {
     Object.defineProperty(sandboxPromise, "hostCall", { value: metadata.hostCall });
   }
@@ -138430,6 +138437,13 @@ var init_running_state = __esm({
 function restore2(snapshot2, options) {
   assertSnapshotInactive(snapshot2);
   validateDumpEnvelope(snapshot2);
+  if (snapshot2.executionSemantics !== EXECUTION_SEMANTICS && (snapshot2.executionSemantics !== void 0 || snapshot2.promiseReplay !== void 0 || snapshot2.replay !== void 0 || snapshot2.initialInputs !== void 0)) {
+    throw new SnapshotValidationError(
+      "unsupportedVersion",
+      "$.executionSemantics",
+      "incompatible execution semantics; resume with the SafeJS version that created this snapshot. Migration requires explicit reconciliation, not changing its version marker."
+    );
+  }
   const currentSourceHash = hashSource(options.source);
   if (snapshot2.sourceHash !== currentSourceHash) {
     throw new SnapshotMismatchError(snapshot2.sourceHash, currentSourceHash);
@@ -138443,6 +138457,7 @@ var init_restore = __esm({
     init_hash();
     init_shape();
     init_validation();
+    init_dump_format();
     init_running_state();
     SnapshotMismatchError = class extends Error {
       actualHash;
@@ -138460,149 +138475,6 @@ var init_restore = __esm({
   }
 });
 
-// packages/safejs/src/interp/cancel.ts
-function wrapCancelableBindings(bindings, signal) {
-  if (signal === void 0) {
-    return bindings;
-  }
-  return wrapCancelableValue(bindings, signal, /* @__PURE__ */ new WeakMap());
-}
-function wrapCancelableValue(value, signal, seen) {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  const existing = seen.get(value);
-  if (existing !== void 0) {
-    return existing;
-  }
-  if (isSandboxClosure(value)) {
-    const wrapped2 = createSandboxClosure({
-      ...value.async === true ? { async: true } : {},
-      call: (args, context) => {
-        if (signal.aborted) {
-          if (value.async === true) {
-            return createRejectedSandboxPromise(readAbortReason(signal));
-          }
-          throw readAbortReason(signal);
-        }
-        return wrapCancelableResult(value.call(args, context), signal, seen);
-      },
-      name: value.name
-    });
-    seen.set(value, wrapped2);
-    return wrapped2;
-  }
-  if (isSandboxPromise(value)) {
-    observeSandboxPromise(value);
-    const wrapped2 = createSandboxPromise(wrapCancelablePromise(value.promise, signal, seen), {
-      trackReplay: false,
-      ...value.hostCall === void 0 ? {} : { hostCall: value.hostCall },
-      ...value.hostCallJournal === void 0 ? {} : { hostCallJournal: value.hostCallJournal },
-      ...value.span === void 0 ? {} : { span: value.span }
-    });
-    seen.set(value, wrapped2);
-    return wrapped2;
-  }
-  if (Array.isArray(value)) {
-    const wrapped2 = new Array(value.length);
-    seen.set(value, wrapped2);
-    for (let index = 0; index < value.length; index += 1) {
-      wrapped2[index] = wrapCancelableValue(value[index], signal, seen);
-    }
-    return wrapped2;
-  }
-  const wrapped = Object.create(Object.getPrototypeOf(value));
-  seen.set(value, wrapped);
-  for (const [key3, entry] of Object.entries(value)) {
-    wrapped[key3] = wrapCancelableValue(entry, signal, seen);
-  }
-  return wrapped;
-}
-function wrapCancelableResult(result, signal, seen) {
-  if (!isPromiseLike3(result)) {
-    return wrapCancelableValue(result, signal, seen);
-  }
-  return wrapCancelablePromise(result, signal, seen);
-}
-function wrapCancelablePromise(promise, signal, seen) {
-  if (signal.aborted) {
-    return Promise.reject(readAbortReason(signal));
-  }
-  return new Promise((resolve17, reject) => {
-    let listenerActive = true;
-    let settled = false;
-    const onAbort = () => {
-      cleanup();
-      queueMicrotask(() => {
-        settle(() => reject(readAbortReason(signal)));
-      });
-    };
-    const cleanup = () => {
-      if (!listenerActive) {
-        return;
-      }
-      listenerActive = false;
-      signal.removeEventListener("abort", onAbort);
-    };
-    const settle = (complete) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanup();
-      complete();
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    Promise.resolve(promise).then(
-      (value) => {
-        settle(() => resolve17(wrapCancelableValue(value, signal, seen)));
-      },
-      (reason) => {
-        settle(() => reject(wrapCancelableUnknown(reason, signal, seen)));
-      }
-    );
-  });
-}
-function wrapCancelableUnknown(value, signal, seen) {
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (isSandboxClosure(value) || isSandboxPromise(value) || Array.isArray(value) || typeof value === "object" && value !== null) {
-    return wrapCancelableValue(value, signal, seen);
-  }
-  return value;
-}
-function readAbortReason(signal) {
-  return signal.reason ?? createAbortError11();
-}
-function createAbortError11() {
-  if (typeof DOMException === "function") {
-    const error4 = new DOMException("This operation was aborted", "AbortError");
-    replaceErrorStack(error4);
-    return error4;
-  }
-  const error3 = new Error("This operation was aborted");
-  error3.name = "AbortError";
-  replaceErrorStack(error3);
-  return error3;
-}
-function createRejectedSandboxPromise(reason) {
-  const promise = Promise.reject(reason);
-  promise.catch(() => void 0);
-  return createSandboxPromise(promise);
-}
-function isPromiseLike3(value) {
-  return typeof value === "object" && value !== null && "then" in value;
-}
-var init_cancel2 = __esm({
-  "packages/safejs/src/interp/cancel.ts"() {
-    "use strict";
-    init_values();
-    init_promise_tracker();
-    init_shape();
-  }
-});
-
 // packages/safejs/src/snapshot/replay-data.ts
 function encodeReplayData(value, options = {}) {
   const nodes = [];
@@ -139431,1548 +139303,1806 @@ var init_host_call = __esm({
   }
 });
 
-// packages/safejs/src/interp/generator.ts
-function createGeneratorChannel(body) {
-  let state = "unstarted";
-  let signal = deferred();
-  let resume;
-  const start = deferred();
-  const sent = [];
-  let yieldNodeId;
-  const bodyPromise = start.promise.then(() => body(yieldValue));
-  void bodyPromise.then(
-    (value) => {
-      if (state === "done") {
-        return;
-      }
-      state = "done";
-      signal.resolve({ type: "complete", value });
-    },
-    (error3) => {
-      if (state === "done") {
-        return;
-      }
-      state = "done";
-      signal.resolve({ type: "error", error: error3 });
-    }
-  );
-  void bodyPromise.catch(() => void 0);
-  async function yieldValue(value, nodeId) {
-    resume = deferred();
-    yieldNodeId = nodeId;
-    state = "suspended";
-    signal.resolve({ type: "yield", value });
-    return resume.promise;
-  }
-  async function deliver(completion) {
-    const leaveRunning = enterRunningState(channelIdentity);
-    try {
-      if (state === "done") {
-        if (completion.type === "return") {
-          return { value: completion.value, done: true };
-        }
-        if (completion.type === "throw") {
-          throw completion.value;
-        }
-        return { value: void 0, done: true };
-      }
-      if (state === "unstarted") {
-        if (completion.type === "return") {
-          state = "done";
-          return { value: completion.value, done: true };
-        }
-        if (completion.type === "throw") {
-          state = "done";
-          throw completion.value;
-        }
-        state = "running";
-        sent.push(completion);
-        start.resolve();
-      } else {
-        state = "running";
-        sent.push(completion);
-        signal = deferred();
-        const pendingResume = resume;
-        resume = void 0;
-        pendingResume?.resolve(completion);
-      }
-      const settled = await signal.promise;
-      if (settled.type === "yield") {
-        return { value: settled.value, done: false };
-      }
-      if (settled.type === "error") {
-        throw settled.error;
-      }
-      return { value: settled.value, done: true };
-    } finally {
-      leaveRunning();
-    }
+// packages/safejs/src/interp/exceptions.ts
+async function evaluateThrowStatement(node, context, evaluateNode3) {
+  const argument = await evaluateNode3(node.argument, context);
+  if (argument.kind !== "normal") {
+    return argument;
   }
-  const channelIdentity = {};
   return {
-    next: (value) => deliver({ type: "normal", value }),
-    return: (value) => deliver({ type: "return", value }),
-    throw: (error3) => deliver({ type: "throw", value: error3 }),
-    snapshot: () => ({
-      ...yieldNodeId === void 0 ? {} : { yieldNodeId },
-      sent: sent.map((completion) => ({ ...completion }))
-    })
+    kind: "throw",
+    hasValue: true,
+    span: node.span,
+    stackFrames: context.callStack,
+    value: argument.value
   };
 }
-function deferred() {
-  let resolve17;
-  let reject;
-  const promise = new Promise((innerResolve, innerReject) => {
-    resolve17 = innerResolve;
-    reject = innerReject;
-  });
-  return { promise, reject, resolve: resolve17 };
-}
-var init_generator = __esm({
-  "packages/safejs/src/interp/generator.ts"() {
-    "use strict";
-    init_running_state();
-  }
-});
-
-// packages/safejs/src/interp/patterns.ts
-async function bindPattern(pattern, value, target, scope, context) {
-  switch (pattern.type) {
-    case "Identifier":
-      bindIdentifier(pattern, value, target, scope);
-      return { ok: true };
-    case "MemberExpression":
-      if ("kind" in target) {
-        throw new TypeError("Destructuring declarations cannot bind to member expressions.");
-      }
-      return bindMemberExpression(pattern, value, scope, context);
-    case "AssignmentPattern":
-      return bindAssignmentPattern(pattern, value, target, scope, context);
-    case "ArrayPattern":
-      return bindArrayPattern(pattern, value, target, scope, context);
-    case "ObjectPattern":
-      return bindObjectPattern(pattern, value, target, scope, context);
-    case "RestElement":
-      return bindPattern(pattern.argument, value, target, scope, context);
-  }
-}
-function bindIdentifier(pattern, value, target, scope) {
-  if ("assign" in target || target.kind === "var") {
-    if ("assign" in target) {
-      const binding = scope.lookup(pattern.name);
-      if (!binding.found) {
-        throw new ReferenceError(`Cannot assign to undeclared binding '${pattern.name}'.`);
-      }
-      if (binding.kind === "const") {
-        throw new TypeError(`Cannot assign to const '${pattern.name}'`);
-      }
+async function evaluateTryStatement(node, context, evaluateNode3) {
+  let fatalBudgetError;
+  let tryResult;
+  try {
+    tryResult = await evaluateBlockCompletion(node.block, context, evaluateNode3);
+  } catch (error3) {
+    if (!isBudgetExceeded(error3) || node.finalizer === void 0) {
+      throw error3;
     }
-    scope.assign(pattern.name, value);
-    return;
-  }
-  scope.declare(pattern.name, target.kind, value);
-}
-async function bindAssignmentPattern(pattern, value, target, scope, context) {
-  if (value !== void 0) {
-    return bindPattern(pattern.left, value, target, scope, context);
-  }
-  const defaultValue = await context.evaluate(pattern.right);
-  if (defaultValue.kind !== "normal") {
-    return { ok: false, result: defaultValue };
+    fatalBudgetError = error3;
+    tryResult = {
+      kind: "throw",
+      hasValue: true,
+      value: void 0
+    };
   }
-  return bindPattern(pattern.left, defaultValue.value, target, scope, context);
-}
-async function bindArrayPattern(pattern, value, target, scope, context) {
-  const values = getArrayPatternValues(value);
-  for (let index = 0; index < pattern.elements.length; index += 1) {
-    const element = pattern.elements[index];
-    if (element === null) {
-      continue;
-    }
-    const elementValue = element.type === "RestElement" ? values.slice(index) : values[index];
-    const binding = await bindPattern(element, elementValue, target, scope, context);
-    if (!binding.ok) {
-      return binding;
-    }
+  const tryOrCatchResult = fatalBudgetError === void 0 && tryResult.kind === "throw" && node.handler !== void 0 ? await evaluateCatchClause(node.handler, tryResult.value, context, evaluateNode3) : tryResult;
+  if (node.finalizer === void 0 || tryOrCatchResult.kind === "error") {
+    return tryOrCatchResult;
   }
-  return { ok: true };
-}
-async function bindObjectPattern(pattern, value, target, scope, context) {
-  if (typeof value !== "object" || value === null) {
-    throw new TypeError("Object destructuring declarations require a non-null object value.");
+  const finalizerResult = fatalBudgetError?.budget === "deadline" ? await evaluateWithoutDeadlineChecks(
+    context,
+    () => evaluateBlockCompletion(node.finalizer, context, evaluateNode3)
+  ) : await evaluateBlockCompletion(node.finalizer, context, evaluateNode3);
+  if (fatalBudgetError !== void 0) {
+    throw fatalBudgetError;
   }
-  const excludedKeys = /* @__PURE__ */ new Set();
-  for (const property of pattern.properties) {
-    if (property.type === "RestElement") {
-      const binding2 = await bindPattern(
-        property,
-        copyObjectRestValue(value, excludedKeys),
-        target,
-        scope,
-        context
-      );
-      if (!binding2.ok) {
-        return binding2;
-      }
-      continue;
-    }
-    const key3 = await evaluatePatternKey(property, context);
-    if (!key3.ok) {
-      return key3;
-    }
-    excludedKeys.add(String(key3.value));
-    const binding = await bindPattern(
-      property.value,
-      value[key3.value],
-      target,
-      scope,
-      context
-    );
-    if (!binding.ok) {
-      return binding;
-    }
+  if (finalizerResult.kind === "normal") {
+    return tryOrCatchResult;
   }
-  return { ok: true };
+  return finalizerResult;
 }
-async function bindMemberExpression(pattern, value, scope, context) {
-  const object = await context.evaluate(pattern.object);
-  if (object.kind !== "normal") {
-    return { ok: false, result: object };
-  }
-  if (object.value === null || object.value === void 0) {
-    throw new TypeError("Cannot assign properties of null or undefined.");
-  }
-  if (!isIndexableValue(object.value)) {
-    throw new TypeError("Assignment expressions require a sandbox object property.");
-  }
-  const property = pattern.computed ? await evaluateProperty(pattern.property, context) : { ok: true, value: getStaticPropertyName(pattern.property) };
-  if (!property.ok) {
-    return property;
-  }
-  setProperty(object.value, property.value, value);
-  return { ok: true };
+function createCapturedException(reason, stackFrames) {
+  return {
+    reason,
+    stackFrames,
+    [capturedExceptionBrand]: true
+  };
 }
-async function evaluatePatternKey(property, context) {
-  return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName(property.key) };
+function isCapturedException(value) {
+  return typeof value === "object" && value !== null && capturedExceptionBrand in value;
 }
-async function evaluateProperty(property, context) {
-  const result = await context.evaluate(property);
-  if (result.kind !== "normal") {
-    return { ok: false, result };
-  }
-  if (typeof result.value !== "string" && typeof result.value !== "number") {
-    throw new TypeError("Computed property access requires a string or number key.");
+function coerceThrownValue(reason, budget, stackFrames, span) {
+  if (isSubsetErrorValue(reason)) {
+    attachErrorSpan(reason, readErrorSpan(reason) ?? span);
+    return reason;
   }
-  return { ok: true, value: result.value };
-}
-function getStaticPropertyName(property) {
-  if (property.type === "Identifier") {
-    return property.name;
+  if (reason instanceof Error) {
+    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
+      chargeBudget: false,
+      cause: readErrorCause(reason),
+      span
+    });
   }
-  if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
-    return property.value;
+  if (isErrorLikeValue(reason)) {
+    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
+      chargeBudget: false,
+      cause: readErrorCause(reason),
+      span
+    });
   }
-  throw new TypeError(`Unsupported static property node '${property.type}'.`);
+  return deepCopyToSandbox(reason);
 }
-function getArrayPatternValues(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return Array.from(value);
+function surfaceThrownValue(reason, budget, stackFrames = [], span) {
+  if (reason instanceof HostCallResumabilityError) {
+    throw reason;
   }
-  if (isSandboxMap(value)) {
-    return Array.from(value.entries, ([key3, entry]) => [key3, entry]);
+  if (isSubsetErrorValue(reason)) {
+    normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
+    return reason;
   }
-  if (isSandboxSet(value)) {
-    return [...value.values];
+  if (reason instanceof Error) {
+    const error3 = createSubsetErrorValue(
+      reason.name || "Error",
+      reason.message,
+      stackFrames,
+      budget,
+      {
+        cause: reason,
+        chargeBudget: false,
+        span
+      }
+    );
+    normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
+    return error3;
   }
-  if (isIterableValue(value)) {
-    throw new TypeError(
-      `Array destructuring declarations support only arrays and strings; received ${describeRuntimeValue(value)}.`
+  if (isErrorLikeValue(reason)) {
+    const error3 = createSubsetErrorValue(
+      reason.name || "Error",
+      reason.message,
+      stackFrames,
+      budget,
+      {
+        cause: readErrorCause(reason),
+        chargeBudget: false,
+        span
+      }
     );
+    normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
+    return error3;
   }
-  throw new TypeError("Array destructuring declarations require an array or string iterable.");
-}
-function isIterableValue(value) {
-  return typeof value === "object" && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
-}
-function describeRuntimeValue(value) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  if (typeof value === "object") return value.constructor?.name ?? "Object";
-  return typeof value;
+  return createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
+    chargeBudget: false,
+    span
+  });
 }
-function copyObjectRestValue(value, excludedKeys) {
-  const rest = /* @__PURE__ */ Object.create(null);
-  for (const [key3, entryValue] of Object.entries(value)) {
-    if (!excludedKeys.has(key3)) {
-      defineProperty(rest, key3, entryValue);
-    }
+function createSubsetErrorValue(name, message2, stackFrames, budget, options = {}) {
+  const resumeChecks = options.chargeBudget === false ? budget.suspendChecks() : void 0;
+  try {
+    const errorName = budget.allocateString(name === "" ? "Error" : name);
+    const errorMessage9 = budget.allocateString(coerceErrorMessage(message2));
+    const header = errorMessage9 === "" ? errorName : `${errorName}: ${errorMessage9}`;
+    const stack = budget.allocateString([header, ...[...stackFrames].reverse()].join("\n"));
+    const error3 = {
+      name: errorName,
+      message: errorMessage9,
+      stack
+    };
+    defineSandboxErrorMetadata(error3, errorName);
+    attachErrorSpan(error3, options.span);
+    attachWrappedErrorCause(error3, options.cause);
+    return error3;
+  } finally {
+    resumeChecks?.();
   }
-  return rest;
 }
-function isIndexableValue(value) {
-  return typeof value === "object" && value !== null;
+function isSandboxErrorConstructorInstance(value, name) {
+  return isSandboxErrorObject(value) && value[sandboxErrorBrand].chain.includes(name);
 }
-function setProperty(target, property, value) {
-  if (Array.isArray(target)) {
-    const key3 = String(property);
-    if (key3 === "length" || isArrayIndexKey2(key3)) {
-      target[key3] = value;
-      return;
+function defineSandboxErrorMetadata(error3, name) {
+  const metadataName = toSandboxErrorName(name);
+  Object.defineProperty(error3, sandboxErrorBrand, {
+    enumerable: false,
+    value: {
+      chain: metadataName === "Error" ? ["Error"] : [metadataName, "Error"],
+      name: metadataName
     }
-    defineProperty(target, key3, value);
-    return;
-  }
-  defineProperty(target, String(property), value);
+  });
 }
-function isArrayIndexKey2(value) {
-  if (value === "") {
-    return false;
-  }
-  const index = Number(value);
-  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === value;
+function toSandboxErrorName(name) {
+  return isSandboxErrorName(name) ? name : "Error";
 }
-function defineProperty(target, key3, value) {
-  Object.defineProperty(target, key3, {
-    configurable: true,
-    enumerable: true,
-    value,
-    writable: true
-  });
+function isSandboxErrorName(name) {
+  return sandboxErrorNames.includes(name);
 }
-var init_patterns = __esm({
-  "packages/safejs/src/interp/patterns.ts"() {
-    "use strict";
-    init_values();
-  }
-});
-
-// packages/safejs/src/interp/promise.ts
-function createPromiseGlobals(options) {
-  return {
-    Promise: {
-      all: createSandboxClosure({
-        async: true,
-        call: ([values]) => createSandboxPromise(
-          settleIterable(values, (entries) => Promise.all(entries), options.budget)
-        ),
-        name: "all"
-      }),
-      race: createSandboxClosure({
-        async: true,
-        call: ([values]) => createSandboxPromise(
-          settleIterable(values, (entries) => Promise.race(entries), options.budget)
-        ),
-        name: "race"
-      }),
-      allSettled: createSandboxClosure({
-        async: true,
-        call: ([values]) => createSandboxPromise(
-          settleIterable(
-            values,
-            (entries) => Promise.allSettled(entries).then(
-              (results) => budgetSandboxValue(
-                results.map(
-                  (result) => result.status === "fulfilled" ? {
-                    status: "fulfilled",
-                    value: result.value
-                  } : {
-                    reason: result.reason,
-                    status: "rejected"
-                  }
-                ),
-                options.budget
-              )
-            ),
-            options.budget
-          )
-        ),
-        name: "allSettled"
-      }),
-      any: createSandboxClosure({
-        async: true,
-        call: ([values]) => createSandboxPromise(
-          settleIterable(
-            values,
-            (entries) => Promise.any(entries).catch(
-              (error3) => Promise.reject(
-                budgetSandboxValue(
-                  {
-                    errors: Array.isArray(error3.errors) ? error3.errors : [],
-                    message: "All promises were rejected",
-                    name: "AggregateError"
-                  },
-                  options.budget
-                )
-              )
-            ),
-            options.budget
-          )
-        ),
-        name: "any"
-      }),
-      resolve: createSandboxClosure({
-        async: true,
-        call: ([value]) => isSandboxPromise(value) ? value : createSandboxPromise(resolveSandboxValue(value, { budget: options.budget })),
-        name: "resolve"
-      }),
-      reject: createSandboxClosure({
-        async: true,
-        call: ([reason], context) => createRejectedSandboxPromise2(reason, options.budget, context?.span),
-        name: "reject"
-      })
-    }
-  };
+function isSandboxErrorObject(value) {
+  return typeof value === "object" && value !== null && sandboxErrorBrand in value;
 }
-function getPromiseMember(target, property, budget, enqueue = (task) => Promise.resolve().then(task)) {
-  if (property === "then") {
-    return createSandboxClosure({
-      async: true,
-      call: ([onFulfilled, onRejected]) => {
-        observeSandboxPromise(target);
-        const chained = createSandboxPromise(
-          enqueue(
-            () => target.promise.then(
-              (value) => runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained),
-              (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained)
-            )
-          )
-        );
-        return chained;
-      },
-      name: "then"
-    });
-  }
-  if (property === "catch") {
-    return createSandboxClosure({
-      async: true,
-      call: ([onRejected]) => {
-        observeSandboxPromise(target);
-        const chained = createSandboxPromise(
-          enqueue(
-            () => target.promise.then(
-              (value) => runPromiseReaction(void 0, value, "fulfilled", budget, chained),
-              (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained)
-            )
-          )
-        );
-        return chained;
-      },
-      name: "catch"
-    });
+function isSubsetErrorValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
   }
-  if (property === "finally") {
-    return createSandboxClosure({
-      async: true,
-      call: ([onFinally]) => {
-        observeSandboxPromise(target);
-        const chained = createSandboxPromise(
-          enqueue(
-            () => target.promise.then(
-              (value) => runPromiseFinally(onFinally, value, "fulfilled", budget, chained),
-              (reason) => runPromiseFinally(onFinally, reason, "rejected", budget, chained)
-            )
-          )
-        );
-        return chained;
-      },
-      name: "finally"
-    });
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === Object.prototype || prototype === null) && typeof value.name === "string" && typeof value.message === "string" && typeof value.stack === "string";
+}
+function normalizeSurfacedSubsetError(error3, budget, stackFrames, span) {
+  const resumeChecks = budget.suspendChecks();
+  try {
+    const name = budget.allocateString(toSandboxErrorName(readErrorName(error3)));
+    const message2 = budget.allocateString(readSurfacedErrorMessage(error3, name));
+    const frames = readSandboxStackFrames(error3.stack);
+    error3.name = name;
+    error3.message = message2;
+    error3.stack = budget.allocateString(
+      formatErrorStack(name, message2, frames.length > 0 ? frames : [...stackFrames].reverse())
+    );
+    attachErrorSpan(error3, readErrorSpan(error3) ?? span);
+  } finally {
+    resumeChecks();
   }
-  return void 0;
 }
-function settleIterable(iterable, settle, budget) {
-  return Promise.resolve().then(
-    () => settle(toHostPromiseArray(iterable, budget)).then((value) => budgetSandboxValue(value, budget))
-  );
+function readErrorName(error3) {
+  return typeof error3.name === "string" && error3.name.length > 0 ? error3.name : "Error";
 }
-function toHostPromiseArray(iterable, budget) {
-  const iterator = getPromiseIterator(iterable);
-  if (iterator === void 0) {
-    throw new TypeError("Promise helpers require an iterable.");
+function readSurfacedErrorMessage(error3, name) {
+  const message2 = typeof error3.message === "string" ? error3.message : "";
+  if (message2 === "") {
+    return `${name} thrown`;
   }
-  const entries = [];
-  while (true) {
-    const next = readIteratorNext(iterator);
-    if (next.done === true) {
-      return entries;
-    }
-    entries.push(resolveSandboxValue(next.value, { budget }));
+  if (message2 === "[object Object]") {
+    return `${name} thrown with non-string message`;
   }
+  return message2;
 }
-function getPromiseIterator(iterable) {
-  if (typeof iterable === "string") {
-    return iterable[Symbol.iterator]();
+function readSandboxStackFrames(stack) {
+  if (typeof stack !== "string") {
+    return [];
   }
-  if (typeof iterable !== "object" && typeof iterable !== "function" || iterable === null) {
-    return void 0;
+  const [, ...frames] = stack.split("\n");
+  return frames;
+}
+function isErrorLikeValue(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.message === "string";
+}
+function coerceErrorMessage(message2) {
+  if (message2 === void 0) {
+    return "";
   }
-  const iteratorMethod = iterable[Symbol.iterator];
-  if (typeof iteratorMethod !== "function") {
-    return void 0;
+  if (Array.isArray(message2)) {
+    return message2.map((value) => value === null || value === void 0 ? "" : String(value)).join(",");
   }
-  const iterator = Reflect.apply(iteratorMethod, iterable, []);
-  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null) {
-    throw new TypeError("Promise helper iterable returned a non-object iterator.");
+  if (typeof message2 === "object" && message2 !== null) {
+    return "[object Object]";
   }
-  return iterator;
+  return String(message2);
 }
-function readIteratorNext(iterator) {
-  const nextMethod = iterator.next;
-  if (typeof nextMethod !== "function") {
-    throw new TypeError("Promise helper iterator requires a next method.");
-  }
-  const next = Reflect.apply(nextMethod, iterator, []);
-  if (typeof next !== "object" || next === null) {
-    throw new TypeError("Iterator result must be an object.");
+async function evaluateWithoutDeadlineChecks(context, evaluate) {
+  const resumeDeadlineChecks = context.budget.suspendDeadlineChecks();
+  try {
+    return await evaluate();
+  } finally {
+    resumeDeadlineChecks();
   }
-  return next;
-}
-function schedulePromise(promise, budget) {
-  return Promise.resolve().then(
-    () => promise.then(
-      (value) => resolveSandboxValue(value, { budget }),
-      (reason) => Promise.reject(budgetSandboxValue(reason, budget))
-    )
-  );
-}
-function createRejectedSandboxPromise2(reason, budget, span) {
-  const promise = schedulePromise(Promise.reject(reason), budget);
-  promise.catch(() => void 0);
-  return createSandboxPromise(promise, { span });
 }
-function budgetSandboxValue(value, budget) {
-  allocateSandboxValue2(value, budget, /* @__PURE__ */ new WeakSet());
-  return value;
+function isBudgetExceeded(error3) {
+  return error3 instanceof SandboxError && error3.code === "budgetExceeded";
 }
-function resolveSandboxValue(value, options = {}) {
-  return Promise.resolve().then(() => resolveSandboxValueNow(value, options, /* @__PURE__ */ new WeakSet()));
-}
-function consumeSettledHostCall(value) {
-  if (value.hostCall?.lifecycle !== "settled") {
-    return;
+async function evaluateCatchClause(node, thrownValue, context, evaluateNode3) {
+  const scope = context.scope.child();
+  const catchContext = {
+    ...context,
+    scope
+  };
+  if (node.param !== void 0) {
+    const binding = await bindPattern(node.param, thrownValue, catchContext, evaluateNode3);
+    if (!binding.ok) {
+      return binding.result;
+    }
   }
-  value.hostCallJournal?.consume(value.hostCall);
+  return evaluateBlockCompletion(node.body, catchContext, evaluateNode3);
 }
-function resolveSandboxValueNow(value, options, seenThenables) {
-  if (isPromiseLike4(value)) {
-    return Promise.resolve(value).then(
-      (resolved) => resolveSandboxValueNow(resolved, options, seenThenables),
-      (reason) => Promise.reject(budgetIfNeeded(reason, options.budget))
-    );
-  }
-  if (isSandboxPromise(value)) {
-    observeSandboxPromise(value);
-    return value.promise.then(
-      (resolved) => {
-        consumeSettledHostCall(value);
-        return resolveSandboxValueNow(resolved, options, seenThenables);
-      },
-      (reason) => {
-        consumeSettledHostCall(value);
-        return Promise.reject(budgetIfNeeded(reason, options.budget));
-      }
-    );
-  }
-  const then = getThenable(value);
-  if (then !== void 0) {
-    return resolveThenable(value, then, options, seenThenables);
+async function evaluateBlockCompletion(node, context, evaluateNode3) {
+  const blockContext = {
+    ...context,
+    scope: context.scope.child()
+  };
+  predeclareBlockBindings(node, blockContext.scope);
+  let result = {
+    kind: "normal",
+    hasValue: false,
+    value: void 0
+  };
+  for (const statement of node.body) {
+    result = await evaluateNode3(statement, blockContext);
+    if (result.kind !== "normal") {
+      return result;
+    }
   }
-  return Promise.resolve(budgetIfNeeded(value, options.budget));
+  return result;
 }
-function resolveThenable(value, then, options, seenThenables) {
-  if (typeof value !== "object" || value === null) {
-    return Promise.resolve(budgetIfNeeded(value, options.budget));
-  }
-  if (seenThenables.has(value)) {
-    return Promise.reject({
-      message: "Promise cannot resolve to itself.",
-      name: "TypeError"
-    });
-  }
-  seenThenables.add(value);
-  return new Promise((resolve17, reject) => {
-    let settlement;
-    let completed = false;
-    const complete = () => {
-      if (completed || settlement === void 0) return;
-      completed = true;
-      if (settlement.state === "fulfilled") {
-        resolve17(resolveSandboxValueNow(settlement.value, options, seenThenables));
-      } else {
-        reject(budgetIfNeeded(settlement.value, options.budget));
-      }
-    };
-    const recordSettlement = (state, settledValue) => {
-      if (settlement !== void 0) {
-        throw new SandboxError("reentry");
-      }
-      settlement = { state, value: settledValue };
-      queueMicrotask(complete);
-    };
-    const resolveOnce = (resolved) => {
-      recordSettlement("fulfilled", resolved);
-    };
-    const rejectOnce = (reason) => {
-      recordSettlement("rejected", reason);
-    };
-    try {
-      const result = then.call([
-        createSandboxClosure({
-          call: ([resolved]) => {
-            resolveOnce(resolved);
-            return void 0;
-          },
-          name: "resolve"
-        }),
-        createSandboxClosure({
-          call: ([reason]) => {
-            rejectOnce(reason);
-            return void 0;
-          },
-          name: "reject"
-        })
-      ]);
-      if (isPromiseLike4(result)) {
-        Promise.resolve(result).catch((reason) => {
-          rejectOnce(reason);
-        });
-      }
-    } catch (error3) {
-      if (settlement !== void 0) {
-        settlement = { state: "rejected", value: error3 };
-        queueMicrotask(complete);
-      } else {
-        rejectOnce(error3);
+function predeclareBlockBindings(node, scope) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of node.body) {
+    if (statement.type !== "VariableDeclaration" || statement.kind === "var") {
+      continue;
+    }
+    for (const name of getDeclarationBindingNames(statement)) {
+      if (names.has(name) || scope.hasOwnBinding(name)) {
+        throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
       }
+      names.add(name);
+      scope.predeclare(name, statement.kind);
     }
-  }).then((resolved) => budgetIfNeeded(resolved, options.budget));
-}
-function runPromiseReaction(handler, value, state, budget, self) {
-  if (!isSandboxClosure(handler)) {
-    return state === "fulfilled" ? Promise.resolve(value) : Promise.reject(budgetSandboxValue(value, budget));
-  }
-  try {
-    const result = handler.call([value]);
-    return resolveReactionResult(result, budget, self);
-  } catch (error3) {
-    return Promise.reject(error3);
   }
 }
-function runPromiseFinally(handler, value, state, budget, self) {
-  if (!isSandboxClosure(handler)) {
-    return runPromiseReaction(void 0, value, state, budget);
+function getDeclarationBindingNames(node) {
+  return node.declarations.flatMap((declarator) => getPatternBindingNames(declarator.id));
+}
+function getPatternBindingNames(pattern) {
+  switch (pattern.type) {
+    case "Identifier":
+      return [pattern.name];
+    case "MemberExpression":
+      return [];
+    case "AssignmentPattern":
+      return getPatternBindingNames(pattern.left);
+    case "ArrayPattern":
+      return pattern.elements.flatMap(
+        (element) => element === null ? [] : getPatternBindingNames(element)
+      );
+    case "ObjectPattern":
+      return pattern.properties.flatMap(
+        (property) => property.type === "RestElement" ? getPatternBindingNames(property) : getPatternBindingNames(property.value)
+      );
+    case "RestElement":
+      return getPatternBindingNames(pattern.argument);
   }
-  try {
-    const result = handler.call([]);
-    return resolveReactionResult(result, budget, self).then(
-      () => runPromiseReaction(void 0, value, state, budget)
-    );
-  } catch (error3) {
-    return Promise.reject(error3);
+}
+async function bindPattern(pattern, value, context, evaluateNode3) {
+  switch (pattern.type) {
+    case "Identifier":
+      context.scope.declare(pattern.name, "let", value);
+      return { ok: true };
+    case "MemberExpression":
+      throw new TypeError("Catch bindings do not support member expressions.");
+    case "AssignmentPattern":
+      return bindAssignmentPattern(pattern, value, context, evaluateNode3);
+    case "ArrayPattern":
+      return bindArrayPattern(pattern, value, context, evaluateNode3);
+    case "ObjectPattern":
+      return bindObjectPattern(pattern, value, context, evaluateNode3);
+    case "RestElement":
+      return bindPattern(pattern.argument, value, context, evaluateNode3);
   }
 }
-function resolveReactionResult(result, budget, self) {
-  return Promise.resolve(result).then((resolved) => {
-    if (isSelfResolution(resolved, self)) {
-      return Promise.reject({
-        message: "Promise cannot resolve to itself.",
-        name: "TypeError"
-      });
+async function bindAssignmentPattern(pattern, value, context, evaluateNode3) {
+  let nextValue = value;
+  if (nextValue === void 0) {
+    const defaultValue = await evaluateNode3(pattern.right, context);
+    if (defaultValue.kind !== "normal") {
+      return {
+        ok: false,
+        result: defaultValue
+      };
     }
-    return resolveSandboxValue(resolved, { budget });
-  });
-}
-function isSelfResolution(result, self) {
-  return self !== void 0 && (result === self || isSandboxPromise(result) && result.promise === self.promise);
-}
-function getThenable(value) {
-  if (typeof value !== "object" || value === null || isSandboxClosure(value) || isSandboxPromise(value)) {
-    return void 0;
+    nextValue = defaultValue.value;
   }
-  const then = value.then;
-  return isSandboxClosure(then) ? then : void 0;
-}
-function budgetIfNeeded(value, budget) {
-  return budget === void 0 ? value : budgetSandboxValue(value, budget);
+  return bindPattern(pattern.left, nextValue, context, evaluateNode3);
 }
-function allocateSandboxValue2(value, budget, seen) {
-  if (typeof value === "string") {
-    budget.allocateString(value);
-    return;
+async function bindArrayPattern(pattern, value, context, evaluateNode3) {
+  if (!Array.isArray(value)) {
+    throw new TypeError("Array catch bindings require an array value.");
   }
-  if (Array.isArray(value)) {
-    budget.allocateArrayLength(value.length);
-    if (seen.has(value)) {
-      return;
+  for (let index = 0; index < pattern.elements.length; index += 1) {
+    const element = pattern.elements[index];
+    if (element === null) {
+      continue;
     }
-    seen.add(value);
-    for (const entry of value) {
-      allocateSandboxValue2(entry, budget, seen);
+    const elementValue = element.type === "RestElement" ? value.slice(index) : value[index];
+    const binding = await bindPattern(element, elementValue, context, evaluateNode3);
+    if (!binding.ok) {
+      return binding;
     }
-    return;
-  }
-  if (typeof value !== "object" || value === null || isSandboxClosure(value) || isSandboxPromise(value)) {
-    return;
   }
-  if (seen.has(value)) {
-    return;
+  return { ok: true };
+}
+async function bindObjectPattern(pattern, value, context, evaluateNode3) {
+  if (typeof value !== "object" && !Array.isArray(value) || value === null) {
+    throw new TypeError("Object catch bindings require a non-null object value.");
   }
-  seen.add(value);
-  for (const entry of Object.values(value)) {
-    allocateSandboxValue2(entry, budget, seen);
+  const excludedKeys = /* @__PURE__ */ new Set();
+  for (const property of pattern.properties) {
+    if (property.type === "RestElement") {
+      const restValue = copyObjectRest(value, excludedKeys);
+      const binding2 = await bindPattern(property, restValue, context, evaluateNode3);
+      if (!binding2.ok) {
+        return binding2;
+      }
+      continue;
+    }
+    const key3 = await resolvePatternPropertyKey(property, context, evaluateNode3);
+    if (!key3.ok) {
+      return key3;
+    }
+    excludedKeys.add(String(key3.value));
+    const binding = await bindPattern(
+      property.value,
+      getObjectPatternValue(value, key3.value),
+      context,
+      evaluateNode3
+    );
+    if (!binding.ok) {
+      return binding;
+    }
   }
+  return { ok: true };
 }
-function isPromiseLike4(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" && !isSandboxClosure(value) && !isSandboxPromise(value);
-}
-var init_promise = __esm({
-  "packages/safejs/src/interp/promise.ts"() {
-    "use strict";
-    init_budget2();
-    init_promise_tracker();
-    init_values();
+async function resolvePatternPropertyKey(property, context, evaluateNode3) {
+  if (!property.computed) {
+    return {
+      ok: true,
+      value: getStaticPropertyKey2(property.key)
+    };
   }
-});
-
-// packages/safejs/src/interp/var-hoist.ts
-function hoistVarDeclarations(node, scope) {
-  if (node.type === "BlockStatement") {
-    for (const statement of node.body) {
-      hoistVarStatement(statement, scope);
-    }
-    return;
-  }
-  switch (node.type) {
-    case "VariableDeclaration":
-    case "IfStatement":
-    case "ForStatement":
-    case "ForInStatement":
-    case "ForOfStatement":
-    case "WhileStatement":
-    case "DoWhileStatement":
-    case "TryStatement":
-    case "SwitchStatement":
-    case "ExportNamedDeclaration":
-      hoistVarStatement(node, scope);
-      return;
-    default:
-      return;
-  }
-}
-function hoistVarStatement(statement, scope) {
-  switch (statement.type) {
-    case "VariableDeclaration":
-      declareVarBindings(statement, scope);
-      return;
-    case "BlockStatement":
-      hoistVarDeclarations(statement, scope);
-      return;
-    case "IfStatement":
-      hoistVarStatement(statement.consequent, scope);
-      if (statement.alternate !== void 0) {
-        hoistVarStatement(statement.alternate, scope);
-      }
-      return;
-    case "ForStatement":
-      if (statement.init?.type === "VariableDeclaration") {
-        declareVarBindings(statement.init, scope);
-      }
-      hoistVarStatement(statement.body, scope);
-      return;
-    case "ForInStatement":
-    case "ForOfStatement":
-      if (statement.left.type === "VariableDeclaration") {
-        declareVarBindings(statement.left, scope);
-      }
-      hoistVarStatement(statement.body, scope);
-      return;
-    case "WhileStatement":
-    case "DoWhileStatement":
-      hoistVarStatement(statement.body, scope);
-      return;
-    case "TryStatement":
-      hoistVarDeclarations(statement.block, scope);
-      if (statement.handler !== void 0) {
-        hoistVarDeclarations(statement.handler.body, scope);
-      }
-      if (statement.finalizer !== void 0) {
-        hoistVarDeclarations(statement.finalizer, scope);
-      }
-      return;
-    case "SwitchStatement":
-      for (const switchCase of statement.cases) {
-        for (const consequent of switchCase.consequent) {
-          hoistVarStatement(consequent, scope);
-        }
-      }
-      return;
-    case "ExportNamedDeclaration":
-      hoistVarStatement(statement.declaration, scope);
-      return;
-    case "FunctionDeclaration":
-    case "ExportDefaultDeclaration":
-    case "ImportDeclaration":
-    case "BreakStatement":
-    case "ContinueStatement":
-    case "EmptyStatement":
-    case "ExpressionStatement":
-    case "ReturnStatement":
-    case "ThrowStatement":
-      return;
-  }
-}
-function declareVarBindings(declaration, scope) {
-  if (declaration.kind !== "var") {
-    return;
+  const computedKey = await evaluateNode3(property.key, context);
+  if (computedKey.kind !== "normal") {
+    return {
+      ok: false,
+      result: computedKey
+    };
   }
-  for (const declarator of declaration.declarations) {
-    for (const name of getPatternBindingNames(declarator.id)) {
-      scope.declareVar(name);
-    }
+  if (typeof computedKey.value !== "string" && typeof computedKey.value !== "number") {
+    throw new TypeError("Computed catch binding keys must evaluate to a string or number.");
   }
+  return {
+    ok: true,
+    value: computedKey.value
+  };
 }
-function getPatternBindingNames(pattern) {
-  switch (pattern.type) {
+function getStaticPropertyKey2(property) {
+  switch (property.type) {
     case "Identifier":
-      return [pattern.name];
-    case "ArrayPattern":
-      return pattern.elements.flatMap(
-        (element) => element === null || element.type === "MemberExpression" ? [] : getNestedPatternBindingNames(element)
-      );
-    case "ObjectPattern":
-      return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? property.argument.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.argument) : property.value.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.value)
-      );
+      return property.name;
+    case "StringLiteral":
+    case "NumericLiteral":
+      return property.value;
+    default:
+      throw new TypeError(`Unsupported catch binding property key '${property.type}'.`);
   }
 }
-function getNestedPatternBindingNames(pattern) {
-  switch (pattern.type) {
-    case "Identifier":
-      return [pattern.name];
-    case "AssignmentPattern":
-      return pattern.left.type === "MemberExpression" ? [] : getNestedPatternBindingNames(pattern.left);
-    case "RestElement":
-      return pattern.argument.type === "MemberExpression" ? [] : getNestedPatternBindingNames(pattern.argument);
-    case "ArrayPattern":
-      return pattern.elements.flatMap(
-        (element) => element === null || element.type === "MemberExpression" ? [] : getNestedPatternBindingNames(element)
-      );
-    case "ObjectPattern":
-      return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? property.argument.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.argument) : property.value.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.value)
-      );
+function getObjectPatternValue(value, key3) {
+  return value[key3];
+}
+function copyObjectRest(value, excludedKeys) {
+  const rest = /* @__PURE__ */ Object.create(null);
+  for (const [key3, entryValue] of Object.entries(value)) {
+    if (excludedKeys.has(key3)) {
+      continue;
+    }
+    rest[key3] = entryValue;
   }
+  return rest;
 }
-var init_var_hoist = __esm({
-  "packages/safejs/src/interp/var-hoist.ts"() {
+var capturedExceptionBrand, sandboxErrorBrand, sandboxErrorNames;
+var init_exceptions = __esm({
+  "packages/safejs/src/interp/exceptions.ts"() {
     "use strict";
+    init_shape();
+    init_budget2();
+    init_host_call();
+    init_values();
+    capturedExceptionBrand = /* @__PURE__ */ Symbol("CapturedException");
+    sandboxErrorBrand = /* @__PURE__ */ Symbol("SandboxError");
+    sandboxErrorNames = [
+      "Error",
+      "TypeError",
+      "RangeError",
+      "ReferenceError",
+      "SyntaxError",
+      "AbortError",
+      "AggregateError",
+      "HarnessFailure"
+    ];
   }
 });
 
-// packages/safejs/src/interp/async.ts
-function emitResumeBreakpoint(context, breakpoint) {
-  context.onYield?.({
-    ...breakpoint,
-    snapshot: () => context.snapshot?.(context.scope) ?? context.scope.snapshot()
+// packages/safejs/src/interp/jobs.ts
+import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
+function runPromiseJob(task) {
+  const job = activeJob.getStore();
+  return job === void 0 ? Promise.resolve().then(task) : job.queue.run(task);
+}
+function runAsyncPrefix(task) {
+  const parent = activeJob.getStore();
+  if (parent === void 0) return task();
+  let owner = parent;
+  while (owner !== void 0 && !owner.ownsExecution) owner = owner.prefixParent;
+  if (owner === void 0) return parent.queue.run(task);
+  const job = { queue: parent.queue, ownsExecution: false, prefixParent: parent };
+  return activeJob.run(job, async () => {
+    try {
+      return await task();
+    } finally {
+      job.queue.release(job);
+    }
   });
 }
-async function evaluateArrowFunctionExpression(node, context, evaluateNode3) {
-  return {
-    kind: "normal",
-    hasValue: true,
-    value: createInterpretedClosure(node, context, evaluateNode3)
-  };
+async function suspendJob(pending) {
+  const job = activeJob.getStore();
+  if (job === void 0) return pending;
+  job.queue.release(job);
+  try {
+    return await pending;
+  } finally {
+    await job.queue.acquire(job);
+  }
 }
-async function evaluateFunctionExpression(node, context, evaluateNode3) {
-  if (node.id === void 0) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: createInterpretedClosure(node, context, evaluateNode3)
+var activeJob, SandboxJobQueue;
+var init_jobs4 = __esm({
+  "packages/safejs/src/interp/jobs.ts"() {
+    "use strict";
+    activeJob = new AsyncLocalStorage5();
+    SandboxJobQueue = class {
+      running = false;
+      pending = [];
+      idle = [];
+      generation = 0;
+      acquire(job) {
+        return new Promise((resolve17) => {
+          this.pending.push(() => {
+            this.running = true;
+            this.generation += 1;
+            job.ownsExecution = true;
+            resolve17();
+          });
+          this.advance();
+        });
+      }
+      release(job) {
+        job.prefixParent = void 0;
+        if (!job.ownsExecution) return;
+        job.ownsExecution = false;
+        this.running = false;
+        this.advance();
+      }
+      async run(task) {
+        const job = { queue: this, ownsExecution: false };
+        await this.acquire(job);
+        return activeJob.run(job, async () => {
+          try {
+            return await task();
+          } finally {
+            this.release(job);
+          }
+        });
+      }
+      async drain() {
+        let idleTurns = 0;
+        while (idleTurns < 20) {
+          const generation = this.generation;
+          if (this.running) await new Promise((resolve17) => this.idle.push(resolve17));
+          await Promise.resolve();
+          idleTurns = generation === this.generation ? idleTurns + 1 : 0;
+        }
+      }
+      advance() {
+        if (this.running) return;
+        const next = this.pending.shift();
+        if (next !== void 0) {
+          next();
+        } else {
+          for (const resolve17 of this.idle.splice(0)) resolve17();
+        }
+      }
     };
   }
-  const wrapperScope = context.scope.child();
-  const closure = createInterpretedClosure(node, { ...context, scope: wrapperScope }, evaluateNode3);
-  wrapperScope.declare(node.id.name, "const", closure);
+});
+
+// packages/safejs/src/interp/promise.ts
+function createPromiseGlobals(options) {
   return {
-    kind: "normal",
-    hasValue: true,
-    value: closure
-  };
-}
-function createInterpretedClosure(node, context, evaluateNode3) {
-  if (node.type !== "ArrowFunctionExpression" && node.generator) {
-    return createGeneratorClosure(node, context, evaluateNode3);
-  }
-  const construct = node.type !== "ArrowFunctionExpression" && !(node.type === "FunctionExpression" && node.method === true) && !node.async ? async (args, callContext) => {
-    const thisValue = {};
-    const result = await executeClosure(
-      node,
-      args,
-      thisValue,
-      {
-        ...context,
-        callStack: [...callContext?.stack ?? context.callStack]
-      },
-      evaluateNode3
-    );
-    return isConstructResult(result) ? result : thisValue;
-  } : void 0;
-  return createSandboxClosure({
-    ...node.async ? { async: true } : {},
-    ...node.type === "FunctionDeclaration" || node.type === "FunctionExpression" ? node.id === void 0 ? {} : { name: node.id.name } : {},
-    ...construct === void 0 ? {} : { construct },
-    retainedValues: () => context.scope.retainedValues(),
-    call: (args, callContext) => node.async ? createSandboxPromise(
-      resolveSandboxValue(
-        executeClosure(
-          node,
-          args,
-          callContext?.thisValue,
-          {
-            ...context,
-            callStack: [...callContext?.stack ?? context.callStack]
-          },
-          evaluateNode3
+    Promise: {
+      all: createSandboxClosure({
+        async: true,
+        call: ([values]) => createSandboxPromise(
+          settleIterable(values, (entries) => Promise.all(entries), options.budget)
         ),
-        { budget: context.budget }
-      )
-    ) : executeClosure(
-      node,
-      args,
-      callContext?.thisValue,
-      {
-        ...context,
-        callStack: [...callContext?.stack ?? context.callStack]
+        name: "all"
+      }),
+      race: createSandboxClosure({
+        async: true,
+        call: ([values]) => createSandboxPromise(
+          settleIterable(values, (entries) => Promise.race(entries), options.budget)
+        ),
+        name: "race"
+      }),
+      allSettled: createSandboxClosure({
+        async: true,
+        call: ([values]) => createSandboxPromise(
+          settleIterable(
+            values,
+            (entries) => Promise.allSettled(entries).then(
+              (results) => budgetSandboxValue(
+                results.map(
+                  (result) => result.status === "fulfilled" ? {
+                    status: "fulfilled",
+                    value: result.value
+                  } : {
+                    reason: result.reason,
+                    status: "rejected"
+                  }
+                ),
+                options.budget
+              )
+            ),
+            options.budget
+          )
+        ),
+        name: "allSettled"
+      }),
+      any: createSandboxClosure({
+        async: true,
+        call: ([values]) => createSandboxPromise(
+          settleIterable(
+            values,
+            (entries) => Promise.any(entries).catch((error3) => {
+              const aggregate = createSubsetErrorValue(
+                "AggregateError",
+                "All promises were rejected",
+                [],
+                options.budget
+              );
+              aggregate.errors = Array.isArray(error3.errors) ? error3.errors : [];
+              throw budgetSandboxValue(aggregate, options.budget);
+            }),
+            options.budget
+          )
+        ),
+        name: "any"
+      }),
+      resolve: createSandboxClosure({
+        async: true,
+        call: ([value]) => isSandboxPromise(value) ? value : createSandboxPromise(resolveSandboxValue(value, { budget: options.budget })),
+        name: "resolve"
+      }),
+      reject: createSandboxClosure({
+        async: true,
+        call: ([reason], context) => createRejectedSandboxPromise(reason, options.budget, context?.span),
+        name: "reject"
+      })
+    }
+  };
+}
+function getPromiseMember(target, property, budget) {
+  if (property === "then") {
+    return createSandboxClosure({
+      async: true,
+      call: ([onFulfilled, onRejected]) => {
+        observeSandboxPromise(target);
+        const chained = createSandboxPromise(
+          target.promise.then(
+            (value) => runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained),
+            (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained)
+          )
+        );
+        return chained;
       },
-      evaluateNode3
+      name: "then"
+    });
+  }
+  if (property === "catch") {
+    return createSandboxClosure({
+      async: true,
+      call: ([onRejected]) => {
+        observeSandboxPromise(target);
+        const chained = createSandboxPromise(
+          target.promise.then(
+            (value) => runPromiseReaction(void 0, value, "fulfilled", budget, chained),
+            (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained)
+          )
+        );
+        return chained;
+      },
+      name: "catch"
+    });
+  }
+  if (property === "finally") {
+    return createSandboxClosure({
+      async: true,
+      call: ([onFinally]) => {
+        observeSandboxPromise(target);
+        const chained = createSandboxPromise(
+          target.promise.then(
+            (value) => runPromiseFinally(onFinally, value, "fulfilled", budget, chained),
+            (reason) => runPromiseFinally(onFinally, reason, "rejected", budget, chained)
+          )
+        );
+        return chained;
+      },
+      name: "finally"
+    });
+  }
+  return void 0;
+}
+function settleIterable(iterable, settle, budget) {
+  return Promise.resolve().then(
+    () => settle(toHostPromiseArray(iterable, budget)).then((value) => budgetSandboxValue(value, budget))
+  );
+}
+function toHostPromiseArray(iterable, budget) {
+  const iterator = getPromiseIterator(iterable);
+  if (iterator === void 0) {
+    throw new TypeError("Promise helpers require an iterable.");
+  }
+  const entries = [];
+  while (true) {
+    const next = readIteratorNext(iterator);
+    if (next.done === true) {
+      return entries;
+    }
+    entries.push(resolveSandboxValue(next.value, { budget }));
+  }
+}
+function getPromiseIterator(iterable) {
+  if (typeof iterable === "string") {
+    return iterable[Symbol.iterator]();
+  }
+  if (typeof iterable !== "object" && typeof iterable !== "function" || iterable === null) {
+    return void 0;
+  }
+  const iteratorMethod = iterable[Symbol.iterator];
+  if (typeof iteratorMethod !== "function") {
+    return void 0;
+  }
+  const iterator = Reflect.apply(iteratorMethod, iterable, []);
+  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null) {
+    throw new TypeError("Promise helper iterable returned a non-object iterator.");
+  }
+  return iterator;
+}
+function readIteratorNext(iterator) {
+  const nextMethod = iterator.next;
+  if (typeof nextMethod !== "function") {
+    throw new TypeError("Promise helper iterator requires a next method.");
+  }
+  const next = Reflect.apply(nextMethod, iterator, []);
+  if (typeof next !== "object" || next === null) {
+    throw new TypeError("Iterator result must be an object.");
+  }
+  return next;
+}
+function schedulePromise(promise, budget) {
+  return Promise.resolve().then(
+    () => promise.then(
+      (value) => resolveSandboxValue(value, { budget }),
+      (reason) => Promise.reject(budgetSandboxValue(reason, budget))
     )
-  });
+  );
+}
+function createRejectedSandboxPromise(reason, budget, span) {
+  const promise = schedulePromise(Promise.reject(reason), budget);
+  promise.catch(() => void 0);
+  return createSandboxPromise(promise, { span });
+}
+function budgetSandboxValue(value, budget) {
+  allocateSandboxValue2(value, budget, /* @__PURE__ */ new WeakSet());
+  return value;
+}
+function resolveSandboxValue(value, options = {}) {
+  return Promise.resolve().then(() => resolveSandboxValueNow(value, options, /* @__PURE__ */ new WeakSet()));
+}
+function consumeSettledHostCall(value) {
+  if (value.hostCall?.lifecycle !== "settled") {
+    return;
+  }
+  value.hostCallJournal?.consume(value.hostCall);
+}
+function resolveSandboxValueNow(value, options, seenThenables) {
+  if (isPromiseLike3(value)) {
+    return Promise.resolve(value).then(
+      (resolved) => resolveSandboxValueNow(resolved, options, seenThenables),
+      (reason) => Promise.reject(budgetIfNeeded(reason, options.budget))
+    );
+  }
+  if (isSandboxPromise(value)) {
+    observeSandboxPromise(value);
+    return value.promise.then(
+      (resolved) => {
+        consumeSettledHostCall(value);
+        return resolveSandboxValueNow(resolved, options, seenThenables);
+      },
+      (reason) => {
+        consumeSettledHostCall(value);
+        return Promise.reject(budgetIfNeeded(reason, options.budget));
+      }
+    );
+  }
+  const then = getThenable(value);
+  if (then !== void 0) {
+    return resolveThenable(value, then, options, seenThenables);
+  }
+  return Promise.resolve(budgetIfNeeded(value, options.budget));
+}
+function resolveThenable(value, then, options, seenThenables) {
+  if (typeof value !== "object" || value === null) {
+    return Promise.resolve(budgetIfNeeded(value, options.budget));
+  }
+  if (seenThenables.has(value)) {
+    return Promise.reject({
+      message: "Promise cannot resolve to itself.",
+      name: "TypeError"
+    });
+  }
+  seenThenables.add(value);
+  return new Promise((resolve17, reject) => {
+    let settlement;
+    let completed = false;
+    let invocationPending = true;
+    const complete = () => {
+      if (completed || invocationPending || settlement === void 0) return;
+      completed = true;
+      try {
+        if (settlement.state === "fulfilled") {
+          resolve17(resolveSandboxValueNow(settlement.value, options, seenThenables));
+        } else {
+          reject(budgetIfNeeded(settlement.value, options.budget));
+        }
+      } catch (error3) {
+        reject(error3);
+      }
+    };
+    const recordSettlement = (state, settledValue) => {
+      if (settlement !== void 0) {
+        return;
+      }
+      settlement = { state, value: settledValue };
+      queueMicrotask(complete);
+    };
+    callInPromiseJob(
+      then,
+      [
+        createSandboxClosure({
+          call: ([resolved]) => {
+            recordSettlement("fulfilled", resolved);
+            return void 0;
+          },
+          name: "resolve"
+        }),
+        createSandboxClosure({
+          call: ([reason]) => {
+            recordSettlement("rejected", reason);
+            return void 0;
+          },
+          name: "reject"
+        })
+      ],
+      value
+    ).then(
+      () => {
+        invocationPending = false;
+        complete();
+      },
+      (error3) => {
+        invocationPending = false;
+        recordSettlement("rejected", error3);
+        complete();
+      }
+    );
+  }).then((resolved) => budgetIfNeeded(resolved, options.budget));
+}
+function runPromiseReaction(handler, value, state, budget, self) {
+  if (!isSandboxClosure(handler)) {
+    return state === "fulfilled" ? Promise.resolve(value) : Promise.reject(budgetSandboxValue(value, budget));
+  }
+  return callInPromiseJob(handler, [value]).then(
+    ({ value: result }) => resolveReactionResult(result, budget, self)
+  );
+}
+function runPromiseFinally(handler, value, state, budget, self) {
+  if (!isSandboxClosure(handler)) {
+    return runPromiseReaction(void 0, value, state, budget);
+  }
+  return callInPromiseJob(handler, []).then(
+    ({ value: result }) => resolveReactionResult(result, budget, self).then(
+      () => runPromiseReaction(void 0, value, state, budget)
+    )
+  );
+}
+function callInPromiseJob(handler, args, thisValue = void 0) {
+  return runPromiseJob(async () => {
+    let result = handler.call(args, { stack: [], thisValue });
+    if (handler.async !== true) result = await result;
+    if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) {
+      await result.synchronousPrefix;
+    }
+    return { value: result };
+  });
+}
+function resolveReactionResult(result, budget, self) {
+  return Promise.resolve(result).then((resolved) => {
+    if (isSelfResolution(resolved, self)) {
+      return Promise.reject({
+        message: "Promise cannot resolve to itself.",
+        name: "TypeError"
+      });
+    }
+    return resolveSandboxValue(resolved, { budget });
+  });
+}
+function isSelfResolution(result, self) {
+  return self !== void 0 && (result === self || isSandboxPromise(result) && result.promise === self.promise);
+}
+function getThenable(value) {
+  if (typeof value !== "object" || value === null || isSandboxPromise(value)) {
+    return void 0;
+  }
+  const then = isSandboxClosure(value) ? value.properties?.then : value.then;
+  return isSandboxClosure(then) ? then : void 0;
+}
+function budgetIfNeeded(value, budget) {
+  return budget === void 0 ? value : budgetSandboxValue(value, budget);
+}
+function allocateSandboxValue2(value, budget, seen) {
+  if (typeof value === "string") {
+    budget.allocateString(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    budget.allocateArrayLength(value.length);
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    for (const entry of value) {
+      allocateSandboxValue2(entry, budget, seen);
+    }
+    return;
+  }
+  if (typeof value !== "object" || value === null || isSandboxClosure(value) || isSandboxPromise(value)) {
+    return;
+  }
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  for (const entry of Object.values(value)) {
+    allocateSandboxValue2(entry, budget, seen);
+  }
+}
+function isPromiseLike3(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" && !isSandboxClosure(value) && !isSandboxPromise(value);
+}
+var init_promise = __esm({
+  "packages/safejs/src/interp/promise.ts"() {
+    "use strict";
+    init_exceptions();
+    init_jobs4();
+    init_promise_tracker();
+    init_values();
+  }
+});
+
+// packages/safejs/src/interp/cancel.ts
+function wrapCancelableBindings(bindings, signal) {
+  if (signal === void 0) {
+    return bindings;
+  }
+  return wrapCancelableValue(bindings, signal, /* @__PURE__ */ new WeakMap());
+}
+function wrapCancelableValue(value, signal, seen) {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const existing = seen.get(value);
+  if (existing !== void 0) {
+    return existing;
+  }
+  if (isSandboxClosure(value)) {
+    const wrapped2 = createSandboxClosure({
+      ...value.async === true ? { async: true } : {},
+      call: (args, context) => {
+        if (signal.aborted) {
+          if (value.async === true) {
+            return createRejectedSandboxPromise2(readAbortReason(signal));
+          }
+          throw readAbortReason(signal);
+        }
+        return wrapCancelableResult(value.call(args, context), signal, seen);
+      },
+      name: value.name
+    });
+    seen.set(value, wrapped2);
+    return wrapped2;
+  }
+  if (isSandboxPromise(value)) {
+    observeSandboxPromise(value);
+    const wrapped2 = createSandboxPromise(wrapCancelablePromise(value.promise, signal, seen), {
+      trackReplay: false,
+      ...value.synchronousPrefix === void 0 ? {} : { synchronousPrefix: value.synchronousPrefix },
+      ...value.hostCall === void 0 ? {} : { hostCall: value.hostCall },
+      ...value.hostCallJournal === void 0 ? {} : { hostCallJournal: value.hostCallJournal },
+      ...value.span === void 0 ? {} : { span: value.span }
+    });
+    seen.set(value, wrapped2);
+    cancellationSignals.set(wrapped2, signal);
+    return wrapped2;
+  }
+  if (Array.isArray(value)) {
+    const wrapped2 = new Array(value.length);
+    seen.set(value, wrapped2);
+    for (let index = 0; index < value.length; index += 1) {
+      wrapped2[index] = wrapCancelableValue(value[index], signal, seen);
+    }
+    return wrapped2;
+  }
+  const wrapped = Object.create(Object.getPrototypeOf(value));
+  seen.set(value, wrapped);
+  for (const [key3, entry] of Object.entries(value)) {
+    wrapped[key3] = wrapCancelableValue(entry, signal, seen);
+  }
+  return wrapped;
+}
+function wrapCancelableResult(result, signal, seen) {
+  if (!isPromiseLike4(result)) {
+    return wrapCancelableValue(result, signal, seen);
+  }
+  return wrapCancelablePromise(result, signal, seen);
+}
+function wrapCancelablePromise(promise, signal, seen) {
+  return awaitWithSignal(promise, signal).then(
+    (value) => wrapCancelableValue(value, signal, seen),
+    (reason) => {
+      if (signal.aborted && reason === signal.reason) throw reason;
+      throw wrapCancelableUnknown(reason, signal, seen);
+    }
+  );
+}
+function awaitSandboxValue(value, signal) {
+  const resolved = resolveSandboxValue(value);
+  return isSandboxPromise(value) && (value.synchronousPrefix !== void 0 || cancellationSignals.get(value) === signal) ? resolved : awaitWithSignal(resolved, signal);
+}
+function awaitWithSignal(promise, signal) {
+  if (signal === void 0) return Promise.resolve(promise);
+  if (signal.aborted) {
+    void Promise.resolve(promise).catch(() => void 0);
+    return Promise.reject(readAbortReason(signal));
+  }
+  return new Promise((resolve17, reject) => {
+    let listenerActive = true;
+    let settled = false;
+    const onAbort = () => {
+      cleanup();
+      queueMicrotask(() => {
+        settle(() => reject(readAbortReason(signal)));
+      });
+    };
+    const cleanup = () => {
+      if (!listenerActive) {
+        return;
+      }
+      listenerActive = false;
+      signal.removeEventListener("abort", onAbort);
+    };
+    const settle = (complete) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      complete();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve(promise).then(
+      (value) => {
+        settle(() => resolve17(value));
+      },
+      (reason) => {
+        settle(() => reject(reason));
+      }
+    );
+  });
+}
+function wrapCancelableUnknown(value, signal, seen) {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (isSandboxClosure(value) || isSandboxPromise(value) || Array.isArray(value) || typeof value === "object" && value !== null) {
+    return wrapCancelableValue(value, signal, seen);
+  }
+  return value;
+}
+function readAbortReason(signal) {
+  return signal.reason ?? createAbortError11();
+}
+function createAbortError11() {
+  if (typeof DOMException === "function") {
+    const error4 = new DOMException("This operation was aborted", "AbortError");
+    replaceErrorStack(error4);
+    return error4;
+  }
+  const error3 = new Error("This operation was aborted");
+  error3.name = "AbortError";
+  replaceErrorStack(error3);
+  return error3;
+}
+function createRejectedSandboxPromise2(reason) {
+  const promise = Promise.reject(reason);
+  promise.catch(() => void 0);
+  return createSandboxPromise(promise);
+}
+function isPromiseLike4(value) {
+  return typeof value === "object" && value !== null && "then" in value;
+}
+var cancellationSignals;
+var init_cancel2 = __esm({
+  "packages/safejs/src/interp/cancel.ts"() {
+    "use strict";
+    init_values();
+    init_promise_tracker();
+    init_shape();
+    init_promise();
+    cancellationSignals = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safejs/src/interp/generator.ts
+function createGeneratorChannel(body) {
+  let state = "unstarted";
+  let signal = deferred();
+  let resume;
+  const start = deferred();
+  const sent = [];
+  let yieldNodeId;
+  const bodyPromise = start.promise.then(() => body(yieldValue));
+  void bodyPromise.then(
+    (value) => {
+      if (state === "done") {
+        return;
+      }
+      state = "done";
+      signal.resolve({ type: "complete", value });
+    },
+    (error3) => {
+      if (state === "done") {
+        return;
+      }
+      state = "done";
+      signal.resolve({ type: "error", error: error3 });
+    }
+  );
+  void bodyPromise.catch(() => void 0);
+  async function yieldValue(value, nodeId) {
+    resume = deferred();
+    yieldNodeId = nodeId;
+    state = "suspended";
+    signal.resolve({ type: "yield", value });
+    return resume.promise;
+  }
+  async function deliver(completion) {
+    const leaveRunning = enterRunningState(channelIdentity);
+    try {
+      if (state === "done") {
+        if (completion.type === "return") {
+          return { value: completion.value, done: true };
+        }
+        if (completion.type === "throw") {
+          throw completion.value;
+        }
+        return { value: void 0, done: true };
+      }
+      if (state === "unstarted") {
+        if (completion.type === "return") {
+          state = "done";
+          return { value: completion.value, done: true };
+        }
+        if (completion.type === "throw") {
+          state = "done";
+          throw completion.value;
+        }
+        state = "running";
+        sent.push(completion);
+        start.resolve();
+      } else {
+        state = "running";
+        sent.push(completion);
+        signal = deferred();
+        const pendingResume = resume;
+        resume = void 0;
+        pendingResume?.resolve(completion);
+      }
+      const settled = await signal.promise;
+      if (settled.type === "yield") {
+        return { value: settled.value, done: false };
+      }
+      if (settled.type === "error") {
+        throw settled.error;
+      }
+      return { value: settled.value, done: true };
+    } finally {
+      leaveRunning();
+    }
+  }
+  const channelIdentity = {};
+  return {
+    next: (value) => deliver({ type: "normal", value }),
+    return: (value) => deliver({ type: "return", value }),
+    throw: (error3) => deliver({ type: "throw", value: error3 }),
+    snapshot: () => ({
+      ...yieldNodeId === void 0 ? {} : { yieldNodeId },
+      sent: sent.map((completion) => ({ ...completion }))
+    })
+  };
+}
+function deferred() {
+  let resolve17;
+  let reject;
+  const promise = new Promise((innerResolve, innerReject) => {
+    resolve17 = innerResolve;
+    reject = innerReject;
+  });
+  return { promise, reject, resolve: resolve17 };
+}
+var init_generator = __esm({
+  "packages/safejs/src/interp/generator.ts"() {
+    "use strict";
+    init_running_state();
+  }
+});
+
+// packages/safejs/src/interp/patterns.ts
+async function bindPattern2(pattern, value, target, scope, context) {
+  switch (pattern.type) {
+    case "Identifier":
+      bindIdentifier(pattern, value, target, scope);
+      return { ok: true };
+    case "MemberExpression":
+      if ("kind" in target) {
+        throw new TypeError("Destructuring declarations cannot bind to member expressions.");
+      }
+      return bindMemberExpression(pattern, value, scope, context);
+    case "AssignmentPattern":
+      return bindAssignmentPattern2(pattern, value, target, scope, context);
+    case "ArrayPattern":
+      return bindArrayPattern2(pattern, value, target, scope, context);
+    case "ObjectPattern":
+      return bindObjectPattern2(pattern, value, target, scope, context);
+    case "RestElement":
+      return bindPattern2(pattern.argument, value, target, scope, context);
+  }
 }
-function createGeneratorClosure(node, context, evaluateNode3) {
-  return createSandboxClosure({
-    ...node.id === void 0 ? {} : { name: node.id.name },
-    retainedValues: () => context.scope.retainedValues(),
-    call: async (args, callContext) => {
-      const closureContext = {
-        ...context,
-        callStack: [...callContext?.stack ?? context.callStack]
-      };
-      const scope = await createClosureScope(
-        node,
-        args,
-        callContext?.thisValue,
-        closureContext,
-        evaluateNode3
-      );
-      const channel = createGeneratorChannel(async (generatorYield) => {
-        const result = await evaluateNode3(node.body, {
-          ...closureContext,
-          generatorYield: (value, yieldNodeId) => {
-            generator.state = "suspended";
-            return generatorYield(value, yieldNodeId);
-          },
-          scope
-        });
-        if (result.kind === "error") {
-          throw result.error;
-        }
-        if (result.kind === "throw") {
-          throw result.value;
-        }
-        return result.hasValue ? result.value : void 0;
-      });
-      const generator = createSandboxGenerator(channel);
-      return generator;
+function bindIdentifier(pattern, value, target, scope) {
+  if ("assign" in target || target.kind === "var") {
+    if ("assign" in target) {
+      const binding = scope.lookup(pattern.name);
+      if (!binding.found) {
+        throw new ReferenceError(`Cannot assign to undeclared binding '${pattern.name}'.`);
+      }
+      if (binding.kind === "const") {
+        throw new TypeError(`Cannot assign to const '${pattern.name}'`);
+      }
     }
-  });
+    scope.assign(pattern.name, value);
+    return;
+  }
+  scope.declare(pattern.name, target.kind, value);
 }
-function isConstructResult(value) {
-  return typeof value === "object" && value !== null;
+async function bindAssignmentPattern2(pattern, value, target, scope, context) {
+  if (value !== void 0) {
+    return bindPattern2(pattern.left, value, target, scope, context);
+  }
+  const defaultValue = await context.evaluate(pattern.right);
+  if (defaultValue.kind !== "normal") {
+    return { ok: false, result: defaultValue };
+  }
+  return bindPattern2(pattern.left, defaultValue.value, target, scope, context);
 }
-async function evaluateAwaitExpression(node, context, evaluateNode3) {
-  const replayState = context.captureReplayState?.();
-  const argument = await evaluateNode3(node.argument, context);
-  if (argument.kind !== "normal") {
-    return argument;
+async function bindArrayPattern2(pattern, value, target, scope, context) {
+  const values = getArrayPatternValues(value);
+  for (let index = 0; index < pattern.elements.length; index += 1) {
+    const element = pattern.elements[index];
+    if (element === null) {
+      continue;
+    }
+    const elementValue = element.type === "RestElement" ? values.slice(index) : values[index];
+    const binding = await bindPattern2(element, elementValue, target, scope, context);
+    if (!binding.ok) {
+      return binding;
+    }
   }
-  emitResumeBreakpoint(context, {
-    kind: "await",
-    replayState,
-    nodeId: node.nodeId,
-    ...getBoundOtelSpan(argument.value) === void 0 ? {} : { otelSpan: getBoundOtelSpan(argument.value) },
-    span: node.span
-  });
-  const leaveAwait = context.budget.enterAwait();
-  try {
-    while (context.microtasks.length > 0) {
-      context.microtasks.shift()?.();
+  return { ok: true };
+}
+async function bindObjectPattern2(pattern, value, target, scope, context) {
+  if (typeof value !== "object" || value === null) {
+    throw new TypeError("Object destructuring declarations require a non-null object value.");
+  }
+  const excludedKeys = /* @__PURE__ */ new Set();
+  for (const property of pattern.properties) {
+    if (property.type === "RestElement") {
+      const binding2 = await bindPattern2(
+        property,
+        copyObjectRestValue(value, excludedKeys),
+        target,
+        scope,
+        context
+      );
+      if (!binding2.ok) {
+        return binding2;
+      }
+      continue;
+    }
+    const key3 = await evaluatePatternKey(property, context);
+    if (!key3.ok) {
+      return key3;
+    }
+    excludedKeys.add(String(key3.value));
+    const binding = await bindPattern2(
+      property.value,
+      value[key3.value],
+      target,
+      scope,
+      context
+    );
+    if (!binding.ok) {
+      return binding;
     }
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: await resolveSandboxValue(argument.value)
-    };
-  } finally {
-    leaveAwait();
   }
+  return { ok: true };
 }
-async function executeClosure(node, args, thisValue, context, evaluateNode3) {
-  const scope = await createClosureScope(node, args, thisValue, context, evaluateNode3);
-  const result = await evaluateNode3(node.body, {
-    ...context,
-    scope
-  });
-  if (result.kind === "error") {
-    throw result.error;
+async function bindMemberExpression(pattern, value, scope, context) {
+  const object = await context.evaluate(pattern.object);
+  if (object.kind !== "normal") {
+    return { ok: false, result: object };
   }
-  if (result.kind === "throw") {
-    throw result.value;
+  if (object.value === null || object.value === void 0) {
+    throw new TypeError("Cannot assign properties of null or undefined.");
   }
-  if (isBlockBody(node.body)) {
-    return result.hasValue ? result.value : void 0;
+  if (!isIndexableValue(object.value)) {
+    throw new TypeError("Assignment expressions require a sandbox object property.");
   }
-  return result.value;
+  const property = pattern.computed ? await evaluateProperty(pattern.property, context) : { ok: true, value: getStaticPropertyName(pattern.property) };
+  if (!property.ok) {
+    return property;
+  }
+  setProperty(object.value, property.value, value);
+  return { ok: true };
 }
-async function createClosureScope(node, args, thisValue, context, evaluateNode3) {
-  const scope = context.scope.child({}, { functionBoundary: true });
-  if (node.type !== "ArrowFunctionExpression") {
-    scope.declare("this", "const", thisValue);
-    context.budget.allocateArrayLength(args.length);
-    scope.declare("arguments", "let", createSandboxArguments(args));
+async function evaluatePatternKey(property, context) {
+  return property.computed ? evaluateProperty(property.key, context) : { ok: true, value: getStaticPropertyName(property.key) };
+}
+async function evaluateProperty(property, context) {
+  const result = await context.evaluate(property);
+  if (result.kind !== "normal") {
+    return { ok: false, result };
   }
-  await bindParameters(node.params, args, scope, context, evaluateNode3);
-  hoistVarDeclarations(node.body, scope);
-  return scope;
+  if (typeof result.value !== "string" && typeof result.value !== "number") {
+    throw new TypeError("Computed property access requires a string or number key.");
+  }
+  return { ok: true, value: result.value };
 }
-function isBlockBody(body) {
-  return body.type === "BlockStatement";
+function getStaticPropertyName(property) {
+  if (property.type === "Identifier") {
+    return property.name;
+  }
+  if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
+    return property.value;
+  }
+  throw new TypeError(`Unsupported static property node '${property.type}'.`);
 }
-async function bindParameters(params, args, scope, context, evaluateNode3) {
-  for (const param of params) {
-    for (const name of getParameterBindingNames(param)) {
-      scope.predeclare(name, "let");
-    }
+function getArrayPatternValues(value) {
+  if (Array.isArray(value)) {
+    return value;
   }
-  for (let index = 0; index < params.length; index += 1) {
-    const param = params[index];
-    if (param.type === "RestElement") {
-      const rest = args.slice(index);
-      context.budget.allocateArrayLength(rest.length);
-      const binding2 = await bindPattern(param, rest, { kind: "let" }, scope, {
-        evaluate: (defaultNode) => evaluateNode3(defaultNode, { ...context, scope })
-      });
-      if (!binding2.ok) {
-        if (binding2.result.kind === "error") {
-          throw binding2.result.error;
-        }
-        if (binding2.result.kind === "throw") {
-          throw binding2.result.value;
-        }
-      }
-      return;
+  if (typeof value === "string") {
+    return Array.from(value);
+  }
+  if (isSandboxMap(value)) {
+    return Array.from(value.entries, ([key3, entry]) => [key3, entry]);
+  }
+  if (isSandboxSet(value)) {
+    return [...value.values];
+  }
+  if (isIterableValue(value)) {
+    throw new TypeError(
+      `Array destructuring declarations support only arrays and strings; received ${describeRuntimeValue(value)}.`
+    );
+  }
+  throw new TypeError("Array destructuring declarations require an array or string iterable.");
+}
+function isIterableValue(value) {
+  return typeof value === "object" && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
+}
+function describeRuntimeValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "object") return value.constructor?.name ?? "Object";
+  return typeof value;
+}
+function copyObjectRestValue(value, excludedKeys) {
+  const rest = /* @__PURE__ */ Object.create(null);
+  for (const [key3, entryValue] of Object.entries(value)) {
+    if (!excludedKeys.has(key3)) {
+      defineProperty(rest, key3, entryValue);
     }
-    const binding = await bindPattern(param, args[index], { kind: "let" }, scope, {
-      evaluate: (defaultNode) => evaluateNode3(defaultNode, { ...context, scope })
-    });
-    if (!binding.ok) {
-      if (binding.result.kind === "error") {
-        throw binding.result.error;
-      }
-      if (binding.result.kind === "throw") {
-        throw binding.result.value;
-      }
+  }
+  return rest;
+}
+function isIndexableValue(value) {
+  return typeof value === "object" && value !== null;
+}
+function setProperty(target, property, value) {
+  if (Array.isArray(target)) {
+    const key3 = String(property);
+    if (key3 === "length" || isArrayIndexKey2(key3)) {
+      target[key3] = value;
+      return;
     }
+    defineProperty(target, key3, value);
+    return;
   }
+  defineProperty(target, String(property), value);
 }
-function getParameterBindingNames(pattern) {
-  switch (pattern.type) {
-    case "Identifier":
-      return [pattern.name];
-    case "MemberExpression":
-      return [];
-    case "AssignmentPattern":
-      return getParameterBindingNames(pattern.left);
-    case "RestElement":
-      return getParameterBindingNames(pattern.argument);
-    case "ArrayPattern":
-      return pattern.elements.flatMap(
-        (element) => element === null ? [] : getParameterBindingNames(element)
-      );
-    case "ObjectPattern":
-      return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? getParameterBindingNames(property) : getParameterBindingNames(property.value)
-      );
+function isArrayIndexKey2(value) {
+  if (value === "") {
+    return false;
   }
+  const index = Number(value);
+  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === value;
 }
-function normalizeClosureResult(result, budget) {
-  if (isSandboxPromise(result)) {
-    return result;
-  }
-  return createSandboxPromise(resolveSandboxValue(result, { budget }));
+function defineProperty(target, key3, value) {
+  Object.defineProperty(target, key3, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
 }
-var init_async = __esm({
-  "packages/safejs/src/interp/async.ts"() {
+var init_patterns = __esm({
+  "packages/safejs/src/interp/patterns.ts"() {
     "use strict";
-    init_generator();
-    init_otel2();
-    init_patterns();
-    init_promise();
-    init_var_hoist();
     init_values();
   }
 });
 
-// packages/safejs/src/interp/exceptions.ts
-async function evaluateThrowStatement(node, context, evaluateNode3) {
-  const argument = await evaluateNode3(node.argument, context);
-  if (argument.kind !== "normal") {
-    return argument;
-  }
-  return {
-    kind: "throw",
-    hasValue: true,
-    span: node.span,
-    stackFrames: context.callStack,
-    value: argument.value
-  };
-}
-async function evaluateTryStatement(node, context, evaluateNode3) {
-  let fatalBudgetError;
-  let tryResult;
-  try {
-    tryResult = await evaluateBlockCompletion(node.block, context, evaluateNode3);
-  } catch (error3) {
-    if (!isBudgetExceeded(error3) || node.finalizer === void 0) {
-      throw error3;
+// packages/safejs/src/interp/var-hoist.ts
+function hoistVarDeclarations(node, scope) {
+  if (node.type === "BlockStatement") {
+    for (const statement of node.body) {
+      hoistVarStatement(statement, scope);
     }
-    fatalBudgetError = error3;
-    tryResult = {
-      kind: "throw",
-      hasValue: true,
-      value: void 0
-    };
-  }
-  const tryOrCatchResult = fatalBudgetError === void 0 && tryResult.kind === "throw" && node.handler !== void 0 ? await evaluateCatchClause(node.handler, tryResult.value, context, evaluateNode3) : tryResult;
-  if (node.finalizer === void 0 || tryOrCatchResult.kind === "error") {
-    return tryOrCatchResult;
-  }
-  const finalizerResult = fatalBudgetError?.budget === "deadline" ? await evaluateWithoutDeadlineChecks(
-    context,
-    () => evaluateBlockCompletion(node.finalizer, context, evaluateNode3)
-  ) : await evaluateBlockCompletion(node.finalizer, context, evaluateNode3);
-  if (fatalBudgetError !== void 0) {
-    throw fatalBudgetError;
-  }
-  if (finalizerResult.kind === "normal") {
-    return tryOrCatchResult;
-  }
-  return finalizerResult;
-}
-function createCapturedException(reason, stackFrames) {
-  return {
-    reason,
-    stackFrames,
-    [capturedExceptionBrand]: true
-  };
-}
-function isCapturedException(value) {
-  return typeof value === "object" && value !== null && capturedExceptionBrand in value;
-}
-function coerceThrownValue(reason, budget, stackFrames, span) {
-  if (isSubsetErrorValue(reason)) {
-    attachErrorSpan(reason, readErrorSpan(reason) ?? span);
-    return reason;
-  }
-  if (reason instanceof Error) {
-    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
-      chargeBudget: false,
-      cause: readErrorCause(reason),
-      span
-    });
+    return;
   }
-  if (isErrorLikeValue(reason)) {
-    return createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
-      chargeBudget: false,
-      cause: readErrorCause(reason),
-      span
-    });
+  switch (node.type) {
+    case "VariableDeclaration":
+    case "IfStatement":
+    case "ForStatement":
+    case "ForInStatement":
+    case "ForOfStatement":
+    case "WhileStatement":
+    case "DoWhileStatement":
+    case "TryStatement":
+    case "SwitchStatement":
+    case "ExportNamedDeclaration":
+      hoistVarStatement(node, scope);
+      return;
+    default:
+      return;
   }
-  return deepCopyToSandbox(reason);
 }
-function surfaceThrownValue(reason, budget, stackFrames = [], span) {
-  if (reason instanceof HostCallResumabilityError) {
-    throw reason;
-  }
-  if (isSubsetErrorValue(reason)) {
-    normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
-    return reason;
-  }
-  if (reason instanceof Error) {
-    const error3 = createSubsetErrorValue(
-      reason.name || "Error",
-      reason.message,
-      stackFrames,
-      budget,
-      {
-        cause: reason,
-        chargeBudget: false,
-        span
+function hoistVarStatement(statement, scope) {
+  switch (statement.type) {
+    case "VariableDeclaration":
+      declareVarBindings(statement, scope);
+      return;
+    case "BlockStatement":
+      hoistVarDeclarations(statement, scope);
+      return;
+    case "IfStatement":
+      hoistVarStatement(statement.consequent, scope);
+      if (statement.alternate !== void 0) {
+        hoistVarStatement(statement.alternate, scope);
       }
-    );
-    normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
-    return error3;
-  }
-  if (isErrorLikeValue(reason)) {
-    const error3 = createSubsetErrorValue(
-      reason.name || "Error",
-      reason.message,
-      stackFrames,
-      budget,
-      {
-        cause: readErrorCause(reason),
-        chargeBudget: false,
-        span
+      return;
+    case "ForStatement":
+      if (statement.init?.type === "VariableDeclaration") {
+        declareVarBindings(statement.init, scope);
       }
-    );
-    normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
-    return error3;
-  }
-  return createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
-    chargeBudget: false,
-    span
-  });
-}
-function createSubsetErrorValue(name, message2, stackFrames, budget, options = {}) {
-  const resumeChecks = options.chargeBudget === false ? budget.suspendChecks() : void 0;
-  try {
-    const errorName = budget.allocateString(name === "" ? "Error" : name);
-    const errorMessage9 = budget.allocateString(coerceErrorMessage(message2));
-    const header = errorMessage9 === "" ? errorName : `${errorName}: ${errorMessage9}`;
-    const stack = budget.allocateString([header, ...[...stackFrames].reverse()].join("\n"));
-    const error3 = {
-      name: errorName,
-      message: errorMessage9,
-      stack
-    };
-    defineSandboxErrorMetadata(error3, errorName);
-    attachErrorSpan(error3, options.span);
-    attachWrappedErrorCause(error3, options.cause);
-    return error3;
-  } finally {
-    resumeChecks?.();
+      hoistVarStatement(statement.body, scope);
+      return;
+    case "ForInStatement":
+    case "ForOfStatement":
+      if (statement.left.type === "VariableDeclaration") {
+        declareVarBindings(statement.left, scope);
+      }
+      hoistVarStatement(statement.body, scope);
+      return;
+    case "WhileStatement":
+    case "DoWhileStatement":
+      hoistVarStatement(statement.body, scope);
+      return;
+    case "TryStatement":
+      hoistVarDeclarations(statement.block, scope);
+      if (statement.handler !== void 0) {
+        hoistVarDeclarations(statement.handler.body, scope);
+      }
+      if (statement.finalizer !== void 0) {
+        hoistVarDeclarations(statement.finalizer, scope);
+      }
+      return;
+    case "SwitchStatement":
+      for (const switchCase of statement.cases) {
+        for (const consequent of switchCase.consequent) {
+          hoistVarStatement(consequent, scope);
+        }
+      }
+      return;
+    case "ExportNamedDeclaration":
+      hoistVarStatement(statement.declaration, scope);
+      return;
+    case "FunctionDeclaration":
+    case "ExportDefaultDeclaration":
+    case "ImportDeclaration":
+    case "BreakStatement":
+    case "ContinueStatement":
+    case "EmptyStatement":
+    case "ExpressionStatement":
+    case "ReturnStatement":
+    case "ThrowStatement":
+      return;
   }
 }
-function isSandboxErrorConstructorInstance(value, name) {
-  return isSandboxErrorObject(value) && value[sandboxErrorBrand].chain.includes(name);
-}
-function defineSandboxErrorMetadata(error3, name) {
-  const metadataName = toSandboxErrorName(name);
-  Object.defineProperty(error3, sandboxErrorBrand, {
-    enumerable: false,
-    value: {
-      chain: metadataName === "Error" ? ["Error"] : [metadataName, "Error"],
-      name: metadataName
+function declareVarBindings(declaration, scope) {
+  if (declaration.kind !== "var") {
+    return;
+  }
+  for (const declarator of declaration.declarations) {
+    for (const name of getPatternBindingNames2(declarator.id)) {
+      scope.declareVar(name);
     }
-  });
-}
-function toSandboxErrorName(name) {
-  return isSandboxErrorName(name) ? name : "Error";
-}
-function isSandboxErrorName(name) {
-  return sandboxErrorNames.includes(name);
+  }
 }
-function isSandboxErrorObject(value) {
-  return typeof value === "object" && value !== null && sandboxErrorBrand in value;
+function getPatternBindingNames2(pattern) {
+  switch (pattern.type) {
+    case "Identifier":
+      return [pattern.name];
+    case "ArrayPattern":
+      return pattern.elements.flatMap(
+        (element) => element === null || element.type === "MemberExpression" ? [] : getNestedPatternBindingNames(element)
+      );
+    case "ObjectPattern":
+      return pattern.properties.flatMap(
+        (property) => property.type === "RestElement" ? property.argument.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.argument) : property.value.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.value)
+      );
+  }
 }
-function isSubsetErrorValue(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
+function getNestedPatternBindingNames(pattern) {
+  switch (pattern.type) {
+    case "Identifier":
+      return [pattern.name];
+    case "AssignmentPattern":
+      return pattern.left.type === "MemberExpression" ? [] : getNestedPatternBindingNames(pattern.left);
+    case "RestElement":
+      return pattern.argument.type === "MemberExpression" ? [] : getNestedPatternBindingNames(pattern.argument);
+    case "ArrayPattern":
+      return pattern.elements.flatMap(
+        (element) => element === null || element.type === "MemberExpression" ? [] : getNestedPatternBindingNames(element)
+      );
+    case "ObjectPattern":
+      return pattern.properties.flatMap(
+        (property) => property.type === "RestElement" ? property.argument.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.argument) : property.value.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.value)
+      );
   }
-  const prototype = Object.getPrototypeOf(value);
-  return (prototype === Object.prototype || prototype === null) && typeof value.name === "string" && typeof value.message === "string" && typeof value.stack === "string";
 }
-function normalizeSurfacedSubsetError(error3, budget, stackFrames, span) {
-  const resumeChecks = budget.suspendChecks();
-  try {
-    const name = budget.allocateString(toSandboxErrorName(readErrorName(error3)));
-    const message2 = budget.allocateString(readSurfacedErrorMessage(error3, name));
-    const frames = readSandboxStackFrames(error3.stack);
-    error3.name = name;
-    error3.message = message2;
-    error3.stack = budget.allocateString(
-      formatErrorStack(name, message2, frames.length > 0 ? frames : [...stackFrames].reverse())
-    );
-    attachErrorSpan(error3, readErrorSpan(error3) ?? span);
-  } finally {
-    resumeChecks();
+var init_var_hoist = __esm({
+  "packages/safejs/src/interp/var-hoist.ts"() {
+    "use strict";
   }
+});
+
+// packages/safejs/src/interp/async.ts
+function emitResumeBreakpoint(context, breakpoint) {
+  context.onYield?.({
+    ...breakpoint,
+    snapshot: () => context.snapshot?.(context.scope) ?? context.scope.snapshot()
+  });
 }
-function readErrorName(error3) {
-  return typeof error3.name === "string" && error3.name.length > 0 ? error3.name : "Error";
+async function evaluateArrowFunctionExpression(node, context, evaluateNode3) {
+  return {
+    kind: "normal",
+    hasValue: true,
+    value: createInterpretedClosure(node, context, evaluateNode3)
+  };
 }
-function readSurfacedErrorMessage(error3, name) {
-  const message2 = typeof error3.message === "string" ? error3.message : "";
-  if (message2 === "") {
-    return `${name} thrown`;
-  }
-  if (message2 === "[object Object]") {
-    return `${name} thrown with non-string message`;
+async function evaluateFunctionExpression(node, context, evaluateNode3) {
+  if (node.id === void 0) {
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: createInterpretedClosure(node, context, evaluateNode3)
+    };
   }
-  return message2;
+  const wrapperScope = context.scope.child();
+  const closure = createInterpretedClosure(node, { ...context, scope: wrapperScope }, evaluateNode3);
+  wrapperScope.declare(node.id.name, "const", closure);
+  return {
+    kind: "normal",
+    hasValue: true,
+    value: closure
+  };
 }
-function readSandboxStackFrames(stack) {
-  if (typeof stack !== "string") {
-    return [];
+function createInterpretedClosure(node, context, evaluateNode3) {
+  if (node.type !== "ArrowFunctionExpression" && node.generator) {
+    return createGeneratorClosure(node, context, evaluateNode3);
   }
-  const [, ...frames] = stack.split("\n");
-  return frames;
+  const construct = node.type !== "ArrowFunctionExpression" && !(node.type === "FunctionExpression" && node.method === true) && !node.async ? async (args, callContext) => {
+    const thisValue = {};
+    const result = await executeClosure(
+      node,
+      args,
+      thisValue,
+      {
+        ...context,
+        callStack: [...callContext?.stack ?? context.callStack]
+      },
+      evaluateNode3
+    );
+    return isConstructResult(result) ? result : thisValue;
+  } : void 0;
+  return createSandboxClosure({
+    ...node.async ? { async: true } : {},
+    ...node.type === "FunctionDeclaration" || node.type === "FunctionExpression" ? node.id === void 0 ? {} : { name: node.id.name } : {},
+    ...construct === void 0 ? {} : { construct },
+    retainedValues: () => context.scope.retainedValues(),
+    call: (args, callContext) => {
+      const invocationContext = {
+        ...context,
+        callStack: [...callContext?.stack ?? context.callStack]
+      };
+      if (!node.async)
+        return executeClosure(node, args, callContext?.thisValue, invocationContext, evaluateNode3);
+      let completePrefix;
+      const synchronousPrefix = new Promise((resolve17) => {
+        completePrefix = resolve17;
+      });
+      const execution = runAsyncPrefix(
+        () => executeClosure(
+          node,
+          args,
+          callContext?.thisValue,
+          { ...invocationContext, onSuspend: completePrefix },
+          evaluateNode3
+        )
+      );
+      execution.then(completePrefix, completePrefix);
+      return createSandboxPromise(
+        resolveSandboxValue(
+          execution.then(
+            (value) => isSandboxPromise(value) || getThenable(value) !== void 0 ? awaitSandboxValue(value, context.signal) : value
+          ),
+          { budget: context.budget }
+        ),
+        { synchronousPrefix }
+      );
+    }
+  });
 }
-function isErrorLikeValue(value) {
-  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.message === "string";
+function createGeneratorClosure(node, context, evaluateNode3) {
+  return createSandboxClosure({
+    ...node.id === void 0 ? {} : { name: node.id.name },
+    retainedValues: () => context.scope.retainedValues(),
+    call: async (args, callContext) => {
+      const closureContext = {
+        ...context,
+        callStack: [...callContext?.stack ?? context.callStack]
+      };
+      const scope = await createClosureScope(
+        node,
+        args,
+        callContext?.thisValue,
+        closureContext,
+        evaluateNode3
+      );
+      const channel = createGeneratorChannel(async (generatorYield) => {
+        const result = await evaluateNode3(node.body, {
+          ...closureContext,
+          generatorYield: (value, yieldNodeId) => {
+            generator.state = "suspended";
+            return generatorYield(value, yieldNodeId);
+          },
+          scope
+        });
+        if (result.kind === "error") {
+          throw result.error;
+        }
+        if (result.kind === "throw") {
+          throw result.value;
+        }
+        return result.hasValue ? result.value : void 0;
+      });
+      const generator = createSandboxGenerator(channel);
+      return generator;
+    }
+  });
 }
-function coerceErrorMessage(message2) {
-  if (message2 === void 0) {
-    return "";
-  }
-  if (Array.isArray(message2)) {
-    return message2.map((value) => value === null || value === void 0 ? "" : String(value)).join(",");
-  }
-  if (typeof message2 === "object" && message2 !== null) {
-    return "[object Object]";
-  }
-  return String(message2);
+function isConstructResult(value) {
+  return typeof value === "object" && value !== null;
 }
-async function evaluateWithoutDeadlineChecks(context, evaluate) {
-  const resumeDeadlineChecks = context.budget.suspendDeadlineChecks();
+async function evaluateAwaitExpression(node, context, evaluateNode3) {
+  const replayState = context.captureReplayState?.();
+  const argument = await evaluateNode3(node.argument, context);
+  if (argument.kind !== "normal") {
+    return argument;
+  }
+  context.onSuspend?.();
+  emitResumeBreakpoint(context, {
+    kind: "await",
+    replayState,
+    nodeId: node.nodeId,
+    ...getBoundOtelSpan(argument.value) === void 0 ? {} : { otelSpan: getBoundOtelSpan(argument.value) },
+    span: node.span
+  });
+  const leaveAwait = context.budget.enterAwait();
   try {
-    return await evaluate();
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: await suspendJob(awaitSandboxValue(argument.value, context.signal))
+    };
   } finally {
-    resumeDeadlineChecks();
+    leaveAwait();
   }
 }
-function isBudgetExceeded(error3) {
-  return error3 instanceof SandboxError && error3.code === "budgetExceeded";
-}
-async function evaluateCatchClause(node, thrownValue, context, evaluateNode3) {
-  const scope = context.scope.child();
-  const catchContext = {
+async function executeClosure(node, args, thisValue, context, evaluateNode3) {
+  const scope = await createClosureScope(node, args, thisValue, context, evaluateNode3);
+  const result = await evaluateNode3(node.body, {
     ...context,
     scope
-  };
-  if (node.param !== void 0) {
-    const binding = await bindPattern2(node.param, thrownValue, catchContext, evaluateNode3);
-    if (!binding.ok) {
-      return binding.result;
-    }
+  });
+  if (result.kind === "error") {
+    throw result.error;
+  }
+  if (result.kind === "throw") {
+    throw result.value;
   }
-  return evaluateBlockCompletion(node.body, catchContext, evaluateNode3);
+  if (isBlockBody(node.body)) {
+    return result.hasValue ? result.value : void 0;
+  }
+  return result.value;
 }
-async function evaluateBlockCompletion(node, context, evaluateNode3) {
-  const blockContext = {
-    ...context,
-    scope: context.scope.child()
-  };
-  predeclareBlockBindings(node, blockContext.scope);
-  let result = {
-    kind: "normal",
-    hasValue: false,
-    value: void 0
-  };
-  for (const statement of node.body) {
-    result = await evaluateNode3(statement, blockContext);
-    if (result.kind !== "normal") {
-      return result;
-    }
+async function createClosureScope(node, args, thisValue, context, evaluateNode3) {
+  const scope = context.scope.child({}, { functionBoundary: true });
+  if (node.type !== "ArrowFunctionExpression") {
+    scope.declare("this", "const", thisValue);
+    context.budget.allocateArrayLength(args.length);
+    scope.declare("arguments", "let", createSandboxArguments(args));
   }
-  return result;
+  await bindParameters(node.params, args, scope, context, evaluateNode3);
+  hoistVarDeclarations(node.body, scope);
+  return scope;
 }
-function predeclareBlockBindings(node, scope) {
-  const names = /* @__PURE__ */ new Set();
-  for (const statement of node.body) {
-    if (statement.type !== "VariableDeclaration" || statement.kind === "var") {
-      continue;
+function isBlockBody(body) {
+  return body.type === "BlockStatement";
+}
+async function bindParameters(params, args, scope, context, evaluateNode3) {
+  for (const param of params) {
+    for (const name of getParameterBindingNames(param)) {
+      scope.predeclare(name, "let");
     }
-    for (const name of getDeclarationBindingNames(statement)) {
-      if (names.has(name) || scope.hasOwnBinding(name)) {
-        throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
+  }
+  for (let index = 0; index < params.length; index += 1) {
+    const param = params[index];
+    if (param.type === "RestElement") {
+      const rest = args.slice(index);
+      context.budget.allocateArrayLength(rest.length);
+      const binding2 = await bindPattern2(param, rest, { kind: "let" }, scope, {
+        evaluate: (defaultNode) => evaluateNode3(defaultNode, { ...context, scope })
+      });
+      if (!binding2.ok) {
+        if (binding2.result.kind === "error") {
+          throw binding2.result.error;
+        }
+        if (binding2.result.kind === "throw") {
+          throw binding2.result.value;
+        }
+      }
+      return;
+    }
+    const binding = await bindPattern2(param, args[index], { kind: "let" }, scope, {
+      evaluate: (defaultNode) => evaluateNode3(defaultNode, { ...context, scope })
+    });
+    if (!binding.ok) {
+      if (binding.result.kind === "error") {
+        throw binding.result.error;
+      }
+      if (binding.result.kind === "throw") {
+        throw binding.result.value;
       }
-      names.add(name);
-      scope.predeclare(name, statement.kind);
     }
   }
 }
-function getDeclarationBindingNames(node) {
-  return node.declarations.flatMap((declarator) => getPatternBindingNames2(declarator.id));
-}
-function getPatternBindingNames2(pattern) {
+function getParameterBindingNames(pattern) {
   switch (pattern.type) {
     case "Identifier":
       return [pattern.name];
     case "MemberExpression":
       return [];
     case "AssignmentPattern":
-      return getPatternBindingNames2(pattern.left);
+      return getParameterBindingNames(pattern.left);
+    case "RestElement":
+      return getParameterBindingNames(pattern.argument);
     case "ArrayPattern":
       return pattern.elements.flatMap(
-        (element) => element === null ? [] : getPatternBindingNames2(element)
+        (element) => element === null ? [] : getParameterBindingNames(element)
       );
     case "ObjectPattern":
       return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? getPatternBindingNames2(property) : getPatternBindingNames2(property.value)
+        (property) => property.type === "RestElement" ? getParameterBindingNames(property) : getParameterBindingNames(property.value)
       );
-    case "RestElement":
-      return getPatternBindingNames2(pattern.argument);
-  }
-}
-async function bindPattern2(pattern, value, context, evaluateNode3) {
-  switch (pattern.type) {
-    case "Identifier":
-      context.scope.declare(pattern.name, "let", value);
-      return { ok: true };
-    case "MemberExpression":
-      throw new TypeError("Catch bindings do not support member expressions.");
-    case "AssignmentPattern":
-      return bindAssignmentPattern2(pattern, value, context, evaluateNode3);
-    case "ArrayPattern":
-      return bindArrayPattern2(pattern, value, context, evaluateNode3);
-    case "ObjectPattern":
-      return bindObjectPattern2(pattern, value, context, evaluateNode3);
-    case "RestElement":
-      return bindPattern2(pattern.argument, value, context, evaluateNode3);
-  }
-}
-async function bindAssignmentPattern2(pattern, value, context, evaluateNode3) {
-  let nextValue = value;
-  if (nextValue === void 0) {
-    const defaultValue = await evaluateNode3(pattern.right, context);
-    if (defaultValue.kind !== "normal") {
-      return {
-        ok: false,
-        result: defaultValue
-      };
-    }
-    nextValue = defaultValue.value;
-  }
-  return bindPattern2(pattern.left, nextValue, context, evaluateNode3);
-}
-async function bindArrayPattern2(pattern, value, context, evaluateNode3) {
-  if (!Array.isArray(value)) {
-    throw new TypeError("Array catch bindings require an array value.");
-  }
-  for (let index = 0; index < pattern.elements.length; index += 1) {
-    const element = pattern.elements[index];
-    if (element === null) {
-      continue;
-    }
-    const elementValue = element.type === "RestElement" ? value.slice(index) : value[index];
-    const binding = await bindPattern2(element, elementValue, context, evaluateNode3);
-    if (!binding.ok) {
-      return binding;
-    }
-  }
-  return { ok: true };
-}
-async function bindObjectPattern2(pattern, value, context, evaluateNode3) {
-  if (typeof value !== "object" && !Array.isArray(value) || value === null) {
-    throw new TypeError("Object catch bindings require a non-null object value.");
-  }
-  const excludedKeys = /* @__PURE__ */ new Set();
-  for (const property of pattern.properties) {
-    if (property.type === "RestElement") {
-      const restValue = copyObjectRest(value, excludedKeys);
-      const binding2 = await bindPattern2(property, restValue, context, evaluateNode3);
-      if (!binding2.ok) {
-        return binding2;
-      }
-      continue;
-    }
-    const key3 = await resolvePatternPropertyKey(property, context, evaluateNode3);
-    if (!key3.ok) {
-      return key3;
-    }
-    excludedKeys.add(String(key3.value));
-    const binding = await bindPattern2(
-      property.value,
-      getObjectPatternValue(value, key3.value),
-      context,
-      evaluateNode3
-    );
-    if (!binding.ok) {
-      return binding;
-    }
-  }
-  return { ok: true };
-}
-async function resolvePatternPropertyKey(property, context, evaluateNode3) {
-  if (!property.computed) {
-    return {
-      ok: true,
-      value: getStaticPropertyKey2(property.key)
-    };
   }
-  const computedKey = await evaluateNode3(property.key, context);
-  if (computedKey.kind !== "normal") {
-    return {
-      ok: false,
-      result: computedKey
-    };
-  }
-  if (typeof computedKey.value !== "string" && typeof computedKey.value !== "number") {
-    throw new TypeError("Computed catch binding keys must evaluate to a string or number.");
-  }
-  return {
-    ok: true,
-    value: computedKey.value
-  };
-}
-function getStaticPropertyKey2(property) {
-  switch (property.type) {
-    case "Identifier":
-      return property.name;
-    case "StringLiteral":
-    case "NumericLiteral":
-      return property.value;
-    default:
-      throw new TypeError(`Unsupported catch binding property key '${property.type}'.`);
-  }
-}
-function getObjectPatternValue(value, key3) {
-  return value[key3];
 }
-function copyObjectRest(value, excludedKeys) {
-  const rest = /* @__PURE__ */ Object.create(null);
-  for (const [key3, entryValue] of Object.entries(value)) {
-    if (excludedKeys.has(key3)) {
-      continue;
-    }
-    rest[key3] = entryValue;
+function normalizeClosureResult(result, budget) {
+  if (isSandboxPromise(result)) {
+    return result;
   }
-  return rest;
+  return createSandboxPromise(resolveSandboxValue(result, { budget }));
 }
-var capturedExceptionBrand, sandboxErrorBrand, sandboxErrorNames;
-var init_exceptions = __esm({
-  "packages/safejs/src/interp/exceptions.ts"() {
+var init_async = __esm({
+  "packages/safejs/src/interp/async.ts"() {
     "use strict";
-    init_shape();
-    init_budget2();
-    init_host_call();
+    init_generator();
+    init_otel2();
+    init_patterns();
+    init_promise();
+    init_jobs4();
+    init_cancel2();
+    init_var_hoist();
     init_values();
-    capturedExceptionBrand = /* @__PURE__ */ Symbol("CapturedException");
-    sandboxErrorBrand = /* @__PURE__ */ Symbol("SandboxError");
-    sandboxErrorNames = [
-      "Error",
-      "TypeError",
-      "RangeError",
-      "ReferenceError",
-      "SyntaxError",
-      "AbortError",
-      "AggregateError",
-      "HarnessFailure"
-    ];
   }
 });
 
@@ -141832,11 +141962,11 @@ async function stringifyProperty(key3, holder, state, indent = "") {
   if (isStringifyContainer(value)) {
     const toJSON = getOwnDataValue(value, "toJSON");
     if (isSandboxClosure(toJSON)) {
-      value = await callStringifyClosure(toJSON, [key3], state);
+      value = await callStringifyClosure(toJSON, [key3], value, state);
     }
   }
   if (state.replacer !== void 0) {
-    value = await callStringifyClosure(state.replacer, [key3, toSandboxValue(value)], state);
+    value = await callStringifyClosure(state.replacer, [key3, toSandboxValue(value)], holder, state);
   }
   return stringifyValue3(value, state, indent);
 }
@@ -141856,7 +141986,8 @@ async function stringifyValue3(value, state, indent) {
   if (typeof value === "bigint") {
     throw new TypeError("Do not know how to serialize a BigInt.");
   }
-  if (value === void 0 || isSandboxClosure(value) || isSandboxPromise(value)) {
+  if (isSandboxPromise(value)) return "{}";
+  if (value === void 0 || isSandboxClosure(value)) {
     return void 0;
   }
   if (Array.isArray(value)) {
@@ -141914,8 +142045,12 @@ ${indent}}`;
     leaveStringifyObject(value, state);
   }
 }
-async function callStringifyClosure(closure, args, state) {
-  return resolveSandboxValue(closure.call(args), { budget: state.budget });
+async function callStringifyClosure(closure, args, thisValue, state) {
+  const result = await closure.call(args, { stack: [], thisValue });
+  if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) {
+    await result.synchronousPrefix;
+  }
+  return allocateProducedSandboxValue(result, state.budget);
 }
 function enterStringifyObject(value, state) {
   if (state.stack.includes(value)) {
@@ -142011,7 +142146,6 @@ var init_console_json = __esm({
   "packages/safejs/src/interp/globals/console-json.ts"() {
     "use strict";
     init_host_bridge();
-    init_promise();
     init_values();
   }
 });
@@ -142505,7 +142639,10 @@ async function arrayFromSandboxValues(args, budget) {
   const mappedValues = [];
   for (const [index, value] of values.entries()) {
     const result = await mapFn.call([value, index]);
-    mappedValues.push(isSandboxPromise(result) ? await result.promise : result);
+    if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) {
+      await result.synchronousPrefix;
+    }
+    mappedValues.push(result);
   }
   return budgetSandboxValue2(mappedValues, budget);
 }
@@ -143241,10 +143378,7 @@ async function callMapMethod(target, methodName, args, options, stack = []) {
         const entries = [...target.entries];
         for (let index = 0; index < entries.length; index += 1) {
           const [key3, value] = entries[index];
-          const result = await options.callClosure(callback, [value, key3, target], stack);
-          if (isSandboxPromise(result)) {
-            await result.promise;
-          }
+          await options.callClosure(callback, [value, key3, target], stack);
         }
       } finally {
         leaveCallback();
@@ -144014,10 +144148,7 @@ async function callSetMethod(target, methodName, args, options, stack = []) {
         const values = [...target.values];
         for (let index = 0; index < values.length; index += 1) {
           const value = values[index];
-          const result = await options.callClosure(callback, [value, value, target], stack);
-          if (isSandboxPromise(result)) {
-            await result.promise;
-          }
+          await options.callClosure(callback, [value, value, target], stack);
         }
       } finally {
         leaveCallback();
@@ -144298,7 +144429,7 @@ async function interpret(node, options = {}) {
     peakDataSize: { enumerable: false, value: 0, writable: true }
   });
   const activeLoopIterations = /* @__PURE__ */ new Map();
-  const microtasks = [];
+  const jobs = new SandboxJobQueue();
   hoistVarDeclarations(node, scope);
   const context = {
     budget,
@@ -144307,8 +144438,8 @@ async function interpret(node, options = {}) {
     captureReplayState: options.captureReplayState,
     rootNode: node,
     scope,
+    signal: options.signal,
     stats: stats2,
-    microtasks,
     activeLoopIterations,
     restoredLoopIterations: new Map(
       Object.entries(options.snapshot?.loopIterations ?? {}).map(([nodeId, iteration]) => [
@@ -144320,8 +144451,8 @@ async function interpret(node, options = {}) {
     generatorYield: options.generatorYield,
     resumeTarget: { nodeId: options.snapshot?.resumeNodeId }
   };
-  const evaluation = await evaluateNode2(node, context);
-  await drainMicrotasks(context);
+  const evaluation = await jobs.run(() => evaluateNode2(node, context));
+  await jobs.drain();
   const snapshot2 = scope.snapshot();
   reconcileDataBudget(
     budget,
@@ -144369,24 +144500,9 @@ async function interpret(node, options = {}) {
     stats: stats2
   };
 }
-async function drainMicrotasks(context) {
-  let idleTurns = 0;
-  while (idleTurns < 20) {
-    const task = context.microtasks.shift();
-    if (task === void 0) {
-      idleTurns += 1;
-      await Promise.resolve();
-      continue;
-    }
-    idleTurns = 0;
-    context.budget.visitNode();
-    task();
-    await Promise.resolve();
-  }
-}
 async function evaluateNode2(node, context) {
   const replayWait = promiseReplayContext.getStore()?.beforeNode(node.nodeId);
-  if (replayWait !== void 0) await replayWait;
+  if (replayWait !== void 0) await suspendJob(replayWait);
   context.budget.visitNode();
   context.stats.nodeVisits += 1;
   if (node.nodeId !== void 0 && context.resumeTarget?.nodeId === node.nodeId) {
@@ -144648,7 +144764,7 @@ async function evaluateAssignmentExpression(node, context) {
     if (right2.kind !== "normal") {
       return right2;
     }
-    const binding2 = await bindPattern(node.left, right2.value, { assign: true }, context.scope, {
+    const binding2 = await bindPattern2(node.left, right2.value, { assign: true }, context.scope, {
       evaluate: (patternNode) => evaluateNode2(patternNode, context)
     });
     if (!binding2.ok) {
@@ -144905,7 +145021,7 @@ async function evaluateVariableDeclaration(node, context) {
     if (value.kind !== "normal") {
       return value;
     }
-    const binding = await bindPattern(
+    const binding = await bindPattern2(
       declarator.id,
       value.value,
       { kind: node.kind },
@@ -145305,7 +145421,7 @@ function isPlainForInObject(value) {
 }
 async function bindForInLoopVariable(left, key3, scope, context) {
   if (left.type === "Identifier") {
-    return bindPattern(left, key3, { assign: true }, scope, {
+    return bindPattern2(left, key3, { assign: true }, scope, {
       evaluate: (patternNode) => evaluateNode2(patternNode, { ...context, scope })
     });
   }
@@ -145313,7 +145429,7 @@ async function bindForInLoopVariable(left, key3, scope, context) {
   if (left.declarations.length !== 1 || declarator?.id.type !== "Identifier") {
     throw new TypeError("for...in keys are strings; destructure inside the body");
   }
-  return bindPattern(declarator.id, key3, { kind: left.kind }, scope, {
+  return bindPattern2(declarator.id, key3, { kind: left.kind }, scope, {
     evaluate: (patternNode) => evaluateNode2(patternNode, { ...context, scope })
   });
 }
@@ -145495,7 +145611,7 @@ function hasLoopLabel(labels, target) {
 }
 async function bindForOfLoopVariable(left, value, scope, context) {
   if (left.type === "Identifier") {
-    return bindPattern(left, value, { assign: true }, scope, {
+    return bindPattern2(left, value, { assign: true }, scope, {
       evaluate: (patternNode) => evaluateNode2(patternNode, { ...context, scope })
     });
   }
@@ -145506,7 +145622,7 @@ async function bindForOfLoopVariable(left, value, scope, context) {
   if (left.declarations.length !== 1 || declarator === void 0) {
     throw new TypeError("for...of declarations must include exactly one declarator.");
   }
-  return bindPattern(declarator.id, value, { kind: left.kind }, scope, {
+  return bindPattern2(declarator.id, value, { kind: left.kind }, scope, {
     evaluate: (patternNode) => evaluateNode2(patternNode, { ...context, scope })
   });
 }
@@ -145837,12 +145953,7 @@ async function evaluateMemberExpression(node, context) {
     return {
       kind: "normal",
       hasValue: true,
-      value: getPromiseMember(
-        member.object,
-        member.property,
-        context.budget,
-        (task) => enqueueMicrotask(context, task)
-      )
+      value: getPromiseMember(member.object, member.property, context.budget)
     };
   }
   if (isSandboxRegex(member.object)) {
@@ -145861,13 +145972,6 @@ async function evaluateMemberExpression(node, context) {
     value: getMemberValue(member.object, member.property, context)
   };
 }
-function enqueueMicrotask(context, task) {
-  return new Promise((resolve17, reject) => {
-    context.microtasks.push(() => {
-      task().then(resolve17, reject);
-    });
-  });
-}
 async function evaluateCallExpression(node, context) {
   if (node.callee.type === "MemberExpression") {
     context.budget.visitNode();
@@ -146120,12 +146224,7 @@ async function evaluateMemberCallExpression(node, context) {
   if (isSandboxPromise(member.object)) {
     return evaluateResolvedCallExpression(
       node,
-      getPromiseMember(
-        member.object,
-        member.property,
-        context.budget,
-        (task) => enqueueMicrotask(context, task)
-      ),
+      getPromiseMember(member.object, member.property, context.budget),
       context,
       member.object
     );
@@ -146170,15 +146269,7 @@ async function evaluateStringMethodCall(node, target, methodName, context) {
         methodName,
         args.value,
         context.budget,
-        async (closure, closureArgs) => {
-          const result = await invokeSandboxClosure(
-            closure,
-            closureArgs,
-            context,
-            context.callStack
-          );
-          return isSandboxPromise(result) ? await result.promise : result;
-        }
+        (closure, closureArgs) => invokeSandboxClosure(closure, closureArgs, context, context.callStack)
       )
     };
   } catch (error3) {
@@ -146663,6 +146754,9 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
         ...span === void 0 ? {} : { span }
       }
     ]);
+    if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) {
+      await result.synchronousPrefix;
+    }
     return callee.async === true ? normalizeClosureResult(wrapHostResult(result, stack), context.budget) : await wrapHostResult(result, stack);
   } catch (error3) {
     if (isFatalSandboxError(error3)) {
@@ -146818,6 +146912,7 @@ var init_interpreter = __esm({
   "packages/safejs/src/interp/interpreter.ts"() {
     "use strict";
     init_promise_replay();
+    init_jobs4();
     init_shape();
     init_async();
     init_host_call();
@@ -147634,7 +147729,6 @@ function run(source, options = {}) {
           }),
           ...createRegexGlobals()
         };
-        const bindings = wrapCancelableBindings(builtinBindings, options.signal);
         const initialInputs = prepareReplayInputs(
           {
             bindings: callerBindings,
@@ -147688,7 +147782,7 @@ function run(source, options = {}) {
           options.signal
         );
         const scope = new Scope(
-          bindings,
+          builtinBindings,
           void 0,
           void 0,
           { chargeData: false },
@@ -147749,6 +147843,7 @@ function run(source, options = {}) {
             dumpController.onYield(createSnapshot);
           },
           scope: executionScope,
+          signal: options.signal,
           snapshot: interpreterSnapshot,
           surfaceUnhandledThrows: true,
           useScopeDirectly: true
@@ -147790,6 +147885,7 @@ function run(source, options = {}) {
             dumpController.onYield(createSnapshot);
           },
           scope: executionScope,
+          signal: options.signal,
           snapshot: interpreterSnapshot
         });
         await throwIfReturnedPromiseRejected(result2);
@@ -147891,6 +147987,7 @@ async function callEntryPoint(input) {
     ...argumentBindings
   });
   return interpret(createEntryPointAwait(input.args.length, input.module.span), {
+    signal: input.signal,
     budget: input.budget,
     captureReplayState: input.captureReplayState,
     onYield: input.onYield,
@@ -147953,6 +148050,7 @@ function createExecutableNode(module) {
 function createRunSnapshot(input) {
   return {
     version: DUMP_FORMAT_VERSION,
+    executionSemantics: EXECUTION_SEMANTICS,
     sourceHash: input.sourceHash,
     bindings: input.bindings,
     clock: input.clock?.snapshot(),
@@ -148219,7 +148317,7 @@ var init_find_exported = __esm({
 });
 
 // packages/safejs/src/modules/agent.ts
-import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
 function createSpawnUsageAccumulator() {
   let inputTokens = 0;
   let outputTokens = 0;
@@ -149065,7 +149163,7 @@ var init_agent3 = __esm({
     init_parallel();
     init_types4();
     init_otel2();
-    activeUsageAccumulator = new AsyncLocalStorage5();
+    activeUsageAccumulator = new AsyncLocalStorage6();
     oneAttemptRetryOptions = {
       maxAttempts: 1,
       backoffMs: 0,
@@ -154007,7 +154105,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "4.0.72",
+      version: "5.0.0",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",