poe-code 5.0.3 → 6.0.0

package/dist/index.js

@@ -10952,6 +10952,14 @@ function computeExplorerLayout(opts) {
     footer
   };
 }
+function paneBodyRect(rect) {
+  return {
+    x: rect.x + 2,
+    y: rect.y + 1,
+    width: Math.max(0, rect.width - 4),
+    height: Math.max(0, rect.height - 2)
+  };
+}
 function resolveMode(cols, rows) {
   if (cols < 60 || rows < 8) {
     return "too-narrow";
@@ -11302,6 +11310,43 @@ var init_ansi_text = __esm({
   }
 });
 
+// packages/toolcraft-design/src/explorer/detail-content.ts
+function prepareDetailContent(content, width) {
+  if (content.trim().length === 0) {
+    return { text: "", lines: [[]] };
+  }
+  width = Math.max(1, width);
+  const key3 = `${contentHash(content)}:${width}`;
+  const cached2 = markdownCache.get(key3);
+  if (cached2 !== void 0) return cached2;
+  const text5 = renderMarkdown(content, { width }).trimEnd();
+  const lines = [[]];
+  for (const cell2 of ansiToCells(text5)) {
+    if (cell2.ch === "\n") lines.push([]);
+    else lines.at(-1).push(cell2);
+  }
+  const prepared = { text: text5, lines };
+  markdownCache.set(key3, prepared);
+  return prepared;
+}
+function contentHash(content) {
+  let hash = 2166136261;
+  for (let index = 0; index < content.length; index += 1) {
+    hash ^= content.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+var markdownCache;
+var init_detail_content = __esm({
+  "packages/toolcraft-design/src/explorer/detail-content.ts"() {
+    "use strict";
+    init_ansi_text();
+    init_terminal_markdown();
+    markdownCache = /* @__PURE__ */ new Map();
+  }
+});
+
 // packages/toolcraft-design/src/explorer/render/text.ts
 function cellWidth(value, startColumn = 0) {
   return displayWidth2(value, startColumn);
@@ -11421,18 +11466,11 @@ function drawPaneFrame(screen, rect, title2, style = {}, options = {}) {
     screen.put(rect.x, rect.y + rect.height - 1, `${options.focused ? "\u2517" : "\u2514"}${horizontal.repeat(innerWidth)}${options.focused ? "\u251B" : "\u2518"}`, style);
   }
 }
-function paneBodyRect(rect) {
-  return {
-    x: rect.x + 2,
-    y: rect.y + 1,
-    width: Math.max(0, rect.width - 4),
-    height: Math.max(0, rect.height - 2)
-  };
-}
 var init_pane = __esm({
   "packages/toolcraft-design/src/explorer/render/pane.ts"() {
     "use strict";
     init_text2();
+    init_layout2();
   }
 });
 
@@ -11471,7 +11509,8 @@ function renderDetailBody(state, screen, rect, row) {
     return { start: 0, max: 0 };
   }
   if (items.length === 1 && items[0]?.title === void 0) {
-    return renderBlob(screen, rect, renderItemMarkdown(items[0], rect, row), state.detail.scroll);
+    const content = prepareDetailContent(renderItem(items[0], rect, row), rect.width);
+    return renderBlob(screen, rect, content.lines, state.detail.scroll);
   }
   return renderListMode(state, screen, rect, items, row);
 }
@@ -11499,7 +11538,8 @@ function renderListMode(state, screen, rect, items, row) {
       writeLine2(screen, rect, y, `  ${item.subtitle}`, styles.muted);
       y += 1;
     }
-    for (const line of renderItemMarkdown(item, rect, row).split("\n")) {
+    const content = prepareDetailContent(renderItem(item, rect, row), rect.width);
+    for (const line of content.text.split("\n")) {
       if (y >= rect.height) {
         break;
       }
@@ -11512,12 +11552,7 @@ function renderListMode(state, screen, rect, items, row) {
   }
   return { start, max };
 }
-function renderBlob(screen, rect, text5, scroll) {
-  const allLines = [[]];
-  for (const cell2 of ansiToCells(text5)) {
-    if (cell2.ch === "\n") allLines.push([]);
-    else allLines.at(-1).push(cell2);
-  }
+function renderBlob(screen, rect, allLines, scroll) {
   const max = Math.max(0, allLines.length - rect.height);
   const start = clamp3(scroll, 0, max);
   const lines = allLines.slice(start);
@@ -11531,19 +11566,6 @@ function renderBlob(screen, rect, text5, scroll) {
   }
   return { start, max };
 }
-function renderItemMarkdown(item, rect, row) {
-  const content = renderItem(item, rect, row);
-  if (content.trim().length === 0) {
-    return "";
-  }
-  const width = Math.max(1, rect.width);
-  const key3 = `${contentHash(content)}:${width}`;
-  const cached2 = markdownCache.get(key3);
-  if (cached2 !== void 0) return cached2;
-  const rendered = renderMarkdown(content, { width }).trimEnd();
-  markdownCache.set(key3, rendered);
-  return rendered;
-}
 function renderItem(item, rect, row) {
   if (item.renderedContent !== void 0) {
     return item.renderedContent;
@@ -11573,24 +11595,14 @@ function scrollIndicator(state, start, max) {
   if (state.detail.loading) return "\u280B";
   return `${max === 0 ? 0 : Math.round(start / max * 100)}%`;
 }
-function contentHash(content) {
-  let hash = 2166136261;
-  for (let index = 0; index < content.length; index += 1) {
-    hash ^= content.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-var markdownCache;
 var init_detail = __esm({
   "packages/toolcraft-design/src/explorer/render/detail.ts"() {
     "use strict";
-    init_ansi_text();
-    init_terminal_markdown();
+    init_detail_content();
+    init_layout2();
     init_theme();
     init_pane();
     init_text2();
-    markdownCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -12927,31 +12939,18 @@ function maxDetailScroll(state) {
     return 0;
   }
   if (items.length === 1 && items[0]?.title === void 0) {
-    const visibleHeight = detailBodyHeight(state);
-    if (visibleHeight <= 0) {
+    const body = paneBodyRect(computeExplorerLayout({ ...state.size, focused: state.focused }).detail);
+    const content = items[0]?.renderedContent;
+    if (body.width <= 0 || body.height <= 0 || content === void 0) {
       return 0;
     }
-    return Math.max(0, detailContentLineCount(items[0]) - visibleHeight);
+    return Math.max(0, prepareDetailContent(content, body.width).lines.length - body.height);
   }
   return Math.max(0, items.length - 1);
 }
-function detailContentLineCount(item) {
-  return (item.renderedContent ?? "").split("\n").length;
-}
 function detailBodyHeight(state) {
-  if (state.layout === "too-narrow" || state.layout === "narrow-list-only" && state.focused !== "detail") {
-    return 0;
-  }
-  const rows = normalizeSize6(state.size.rows);
-  const footerHeight = rows > 0 ? Math.min(1, rows) : 0;
-  const headerHeight = Math.min(3, Math.max(0, rows - footerHeight));
-  const contentHeight = Math.max(0, rows - headerHeight - footerHeight);
-  if (state.layout === "narrow-vertical") {
-    const listHeight = Math.ceil(contentHeight / 2);
-    const detailHeight = contentHeight - listHeight;
-    return Math.max(0, detailHeight - 2);
-  }
-  return Math.max(0, contentHeight - 2);
+  const body = paneBodyRect(computeExplorerLayout({ ...state.size, focused: state.focused }).detail);
+  return body.width > 0 ? body.height : 0;
 }
 function extendSelection(state, delta2) {
   if (!state.multiSelect) {
@@ -13270,7 +13269,9 @@ var init_reducer = __esm({
     "use strict";
     init_terminal_width();
     init_actions();
+    init_detail_content();
     init_filter();
+    init_layout2();
     init_state();
     NO_EFFECTS = [];
     DEFAULT_ACTION_HANDLES = {
@@ -124477,11 +124478,6 @@ var init_AS001 = __esm({
           case "with":
             this.report(token.value, token.start, token.end);
             return;
-          case "new":
-            if (!this.source.slice(this.skipTriviaFrom(token.end.offset)).startsWith("RegExp")) {
-              this.report(token.value, token.start, token.end);
-            }
-            return;
           default:
             return;
         }
@@ -136544,14 +136540,29 @@ var init_budget2 = __esm({
 
 // packages/safejs/src/interp/promise-tracker.ts
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+function assertPromiseExecutionAllowed() {
+  const failure = activePromiseTracker.getStore()?.failure;
+  if (failure !== void 0 && fatalRejectionCleanup.getStore() !== true) throw failure;
+}
+function onFatalPromiseRejection(interrupt) {
+  if (fatalRejectionCleanup.getStore() === true) return void 0;
+  return activePromiseTracker.getStore()?.onFatalRejection(interrupt);
+}
+function interruptOnFatalPromiseRejection(pending) {
+  if (fatalRejectionCleanup.getStore() === true) return pending;
+  return activePromiseTracker.getStore()?.interruptOnFatalRejection(pending) ?? pending;
+}
+function withFatalPromiseCleanup(callback) {
+  return fatalRejectionCleanup.run(true, callback);
+}
 function createSandboxPromiseRejectionTracker() {
   return new SandboxPromiseRejectionTracker();
 }
 function observeSandboxPromise(promise) {
   activePromiseTracker.getStore()?.observe(promise);
 }
-function trackSandboxPromise(promise) {
-  activePromiseTracker.getStore()?.track(promise);
+function trackSandboxPromise(promise, outcome) {
+  activePromiseTracker.getStore()?.track(promise, outcome);
 }
 function withSandboxPromiseRejectionTracker(tracker, callback) {
   return activePromiseTracker.run(tracker, callback);
@@ -136561,41 +136572,76 @@ async function flushPromiseJobs() {
     await Promise.resolve();
   }
 }
-var SandboxPromiseRejectionTracker, activePromiseTracker;
+var SandboxPromiseRejectionTracker, activePromiseTracker, fatalRejectionCleanup;
 var init_promise_tracker = __esm({
   "packages/safejs/src/interp/promise-tracker.ts"() {
     "use strict";
+    init_budget2();
     SandboxPromiseRejectionTracker = class {
       records = /* @__PURE__ */ new Set();
       recordsByPromise = /* @__PURE__ */ new WeakMap();
+      fatalRejection;
+      fatalWaiters = /* @__PURE__ */ new Set();
+      get failure() {
+        return this.fatalRejection;
+      }
+      onFatalRejection(interrupt) {
+        if (this.fatalRejection === void 0) this.fatalWaiters.add(interrupt);
+        else interrupt(this.fatalRejection);
+        return () => this.fatalWaiters.delete(interrupt);
+      }
+      interruptOnFatalRejection(pending) {
+        return new Promise((resolve17, reject) => {
+          const detach = this.onFatalRejection(reject);
+          pending.then(
+            (value) => {
+              detach();
+              resolve17(value);
+            },
+            (reason) => {
+              detach();
+              reject(reason);
+            }
+          );
+        });
+      }
       observe(promise) {
         const record2 = this.recordsByPromise.get(promise);
         if (record2 !== void 0) {
           record2.observed = true;
         }
       }
-      track(promise) {
-        if (this.recordsByPromise.has(promise)) {
+      track(promise, outcome) {
+        const existing = this.recordsByPromise.get(promise);
+        if (existing !== void 0 && outcome === void 0) {
           return;
         }
-        const record2 = {
+        const record2 = existing ?? {
           observed: false,
           promise,
           rejected: false
         };
         this.records.add(record2);
         this.recordsByPromise.set(promise, record2);
-        promise.promise.then(
+        const pending = outcome ?? promise.promise;
+        pending.then(
           () => void 0,
           (reason) => {
+            if (this.fatalRejection === void 0 && reason instanceof SandboxError && (reason.code === "budgetExceeded" || reason.code === "reentry")) {
+              this.fatalRejection = reason;
+              for (const interrupt of this.fatalWaiters) interrupt(reason);
+              this.fatalWaiters.clear();
+            }
+            if (record2.rejected) return;
             record2.rejected = true;
             record2.rejectionReason = reason;
           }
         );
-        promise.promise.catch(() => void 0);
+        pending.catch(() => void 0);
       }
       async findUnhandledRejection() {
         await flushPromiseJobs();
+        if (this.fatalRejection !== void 0) throw this.fatalRejection;
         for (const record2 of this.records) {
           if (record2.rejected && !record2.observed) {
             return {
@@ -136608,6 +136654,7 @@ var init_promise_tracker = __esm({
       }
     };
     activePromiseTracker = new AsyncLocalStorage3();
+    fatalRejectionCleanup = new AsyncLocalStorage3();
   }
 });
 
@@ -136988,7 +137035,7 @@ var init_dump_format = __esm({
     init_arguments();
     init_arguments2();
     DUMP_FORMAT_VERSION = 1;
-    EXECUTION_SEMANTICS = "jobs-v1";
+    EXECUTION_SEMANTICS = "jobs-v2";
     SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
   }
 });
@@ -137753,834 +137800,6 @@ var init_promise_replay = __esm({
   }
 });
 
-// packages/safejs/src/interp/values.ts
-function createSandboxClosure(input) {
-  const closure = {
-    kind: "fn",
-    call: input.call,
-    name: input.name,
-    ...input.construct === void 0 ? {} : { construct: input.construct },
-    ...input.async === true ? { async: true } : {}
-  };
-  Object.defineProperty(closure, sandboxClosureBrand, {
-    enumerable: false,
-    value: true
-  });
-  if (input.properties !== void 0) {
-    Object.defineProperty(closure, "properties", {
-      enumerable: false,
-      value: Object.freeze(
-        typeof input.properties === "function" ? input.properties(closure) : input.properties
-      )
-    });
-  }
-  if (input.retainedValues !== void 0) {
-    Object.defineProperty(closure, sandboxRetainedValues, {
-      value: input.retainedValues
-    });
-  }
-  return Object.freeze(closure);
-}
-function createSandboxPromise(promise, metadata = {}) {
-  const sandboxPromise = {
-    kind: "promise",
-    promise: metadata.trackReplay === false ? promise : promiseReplayContext.getStore()?.track(promise) ?? promise
-  };
-  Object.defineProperty(sandboxPromise, sandboxPromiseBrand, {
-    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 });
-  }
-  if (metadata.hostCallJournal !== void 0) {
-    Object.defineProperty(sandboxPromise, "hostCallJournal", {
-      value: metadata.hostCallJournal
-    });
-  }
-  trackSandboxPromise(sandboxPromise);
-  return Object.freeze(sandboxPromise);
-}
-function createSandboxGenerator(channel, metadata = void 0) {
-  const generator = {
-    kind: "generator",
-    state: "start",
-    channel,
-    ...metadata
-  };
-  Object.defineProperty(generator, sandboxGeneratorBrand, {
-    enumerable: false,
-    value: true
-  });
-  return generator;
-}
-function createSandboxMap(entries = []) {
-  const map = {};
-  Object.defineProperties(map, {
-    kind: {
-      value: "map"
-    },
-    entries: {
-      value: new Map(entries)
-    }
-  });
-  Object.defineProperty(map, sandboxMapBrand, {
-    enumerable: false,
-    value: true
-  });
-  return Object.freeze(map);
-}
-function createSandboxSet(values = []) {
-  const set = {};
-  Object.defineProperties(set, {
-    kind: {
-      value: "set"
-    },
-    values: {
-      value: new Set(values)
-    }
-  });
-  Object.defineProperty(set, sandboxSetBrand, {
-    enumerable: false,
-    value: true
-  });
-  return Object.freeze(set);
-}
-function createSandboxRegex(source, flags = "", lastIndex = 0) {
-  const regex = { kind: "regex", source, flags, lastIndex };
-  Object.defineProperties(regex, {
-    [sandboxRegexBrand]: { value: true },
-    [sandboxRegexPattern]: { value: parseRegex(source, flags) }
-  });
-  return Object.seal(regex);
-}
-function getSandboxRegexPattern(regex) {
-  return regex[sandboxRegexPattern];
-}
-function isSandboxClosure(value) {
-  return typeof value === "object" && value !== null && sandboxClosureBrand in value;
-}
-function isSandboxMap(value) {
-  return typeof value === "object" && value !== null && sandboxMapBrand in value;
-}
-function isSandboxPromise(value) {
-  return typeof value === "object" && value !== null && sandboxPromiseBrand in value;
-}
-function isSandboxSet(value) {
-  return typeof value === "object" && value !== null && sandboxSetBrand in value;
-}
-function isSandboxGenerator(value) {
-  return typeof value === "object" && value !== null && sandboxGeneratorBrand in value;
-}
-function isSandboxRegex(value) {
-  return typeof value === "object" && value !== null && sandboxRegexBrand in value;
-}
-function deepCopyToSandbox(value) {
-  return copyToSandbox(value, {
-    seen: /* @__PURE__ */ new WeakMap()
-  });
-}
-function cloneSandboxValue(value) {
-  return copyToSandbox(
-    value,
-    {
-      seen: /* @__PURE__ */ new WeakMap()
-    },
-    "<root>",
-    true
-  );
-}
-function allocateProducedSandboxValue(value, budget) {
-  allocateSandboxValue(value, budget, /* @__PURE__ */ new WeakSet());
-  return value;
-}
-function measureSandboxData(values, options = {}) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  let usage = 0;
-  const visit = (value) => {
-    if (typeof value === "string") {
-      usage += value.length;
-      return;
-    }
-    if (typeof value !== "object" || value === null) return;
-    if (seen.has(value)) return;
-    seen.add(value);
-    usage += 1;
-    if (Array.isArray(value)) {
-      usage += value.length;
-      for (const entry of value) visit(entry);
-      return;
-    }
-    if (isSandboxMap(value)) {
-      usage += value.entries.size;
-      for (const [key3, entry] of value.entries) {
-        visit(key3);
-        visit(entry);
-      }
-      return;
-    }
-    if (isSandboxSet(value)) {
-      usage += value.values.size;
-      for (const entry of value.values) visit(entry);
-      return;
-    }
-    if (isSandboxClosure(value)) {
-      if (options.ignoreClosures) return;
-      if (value.properties !== void 0) visit(value.properties);
-      if (!options.ignoreClosureCaptures)
-        for (const retained of value[sandboxRetainedValues]?.() ?? []) visit(retained);
-      return;
-    }
-    if (isSandboxGenerator(value)) {
-      const snapshot2 = value.channel.snapshot();
-      usage += snapshot2.sent.length;
-      for (const completion of snapshot2.sent) visit(completion.value);
-      return;
-    }
-    if (isSandboxPromise(value)) return;
-    if (isSandboxRegex(value)) {
-      usage += value.source.length + value.flags.length;
-      return;
-    }
-    const entries = isSandboxArguments(value) ? getSandboxArgumentEntries(value) : Object.entries(value);
-    usage += entries.length;
-    for (const [key3, entry] of entries) {
-      usage += key3.length;
-      visit(entry);
-    }
-  };
-  for (const value of values) visit(value);
-  return usage;
-}
-function deepCopyFromSandbox(value, options = {}) {
-  return copyFromSandbox(
-    value,
-    {
-      seen: /* @__PURE__ */ new WeakMap()
-    },
-    "<root>",
-    options
-  );
-}
-function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections = false, depth = 0) {
-  assertSandboxDataDepth(depth);
-  if (isSandboxPrimitive(value)) {
-    return value;
-  }
-  if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxRegex(value) || isSandboxPromise(value)) {
-    return value;
-  }
-  if (isSandboxMap(value)) {
-    if (!cloneSandboxCollections) return value;
-    const existing = state.seen.get(value);
-    if (existing !== void 0) return existing;
-    const copy = createSandboxMap();
-    state.seen.set(value, copy);
-    for (const [key3, entry] of value.entries) {
-      copy.entries.set(
-        copyToSandbox(key3, state, `${path189}.<key>`, true, depth + 1),
-        copyToSandbox(entry, state, `${path189}.<value>`, true, depth + 1)
-      );
-    }
-    return copy;
-  }
-  if (isSandboxSet(value)) {
-    if (!cloneSandboxCollections) return value;
-    const existing = state.seen.get(value);
-    if (existing !== void 0) return existing;
-    const copy = createSandboxSet();
-    state.seen.set(value, copy);
-    for (const entry of value.values) {
-      copy.values.add(copyToSandbox(entry, state, `${path189}.<value>`, true, depth + 1));
-    }
-    return copy;
-  }
-  if (isHostPromise(value)) {
-    const promise = Promise.resolve(value).then(
-      (resolved) => copyToSandbox(resolved, { seen: /* @__PURE__ */ new WeakMap() }),
-      (reason) => Promise.reject(copyToSandbox(reason, { seen: /* @__PURE__ */ new WeakMap() }))
-    );
-    const sandboxPromise = createSandboxPromise(promise);
-    const span = getBoundOtelSpan(value);
-    if (span !== void 0) {
-      bindOtelSpan(promise, span);
-      bindOtelSpan(sandboxPromise, span);
-    }
-    return sandboxPromise;
-  }
-  if (value instanceof Map) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const copy = createSandboxMap();
-    state.seen.set(value, copy);
-    for (const [key3, entry] of value) {
-      copy.entries.set(
-        copyToSandbox(key3, state, `${path189}.<key>`, cloneSandboxCollections, depth + 1),
-        copyToSandbox(entry, state, `${path189}.<value>`, cloneSandboxCollections, depth + 1)
-      );
-    }
-    return copy;
-  }
-  if (value instanceof Set) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const copy = createSandboxSet();
-    state.seen.set(value, copy);
-    for (const entry of value) {
-      copy.values.add(
-        copyToSandbox(entry, state, `${path189}.<value>`, cloneSandboxCollections, depth + 1)
-      );
-    }
-    return copy;
-  }
-  if (isPlainArray(value)) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const copy = new Array(value.length);
-    state.seen.set(value, copy);
-    for (const entry of getEnumerableArrayEntries(value, path189)) {
-      defineOwnDataProperty(
-        copy,
-        entry.key,
-        copyToSandbox(
-          entry.value,
-          state,
-          joinArrayPath(path189, entry.key),
-          cloneSandboxCollections,
-          depth + 1
-        )
-      );
-    }
-    return copy;
-  }
-  if (isSandboxArguments(value)) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) return existing;
-    const copy = createSandboxArguments([]);
-    state.seen.set(value, copy);
-    copySandboxArgumentProperties(
-      value,
-      copy,
-      (entry, key3) => copyToSandbox(entry, state, joinPath(path189, key3), cloneSandboxCollections, depth + 1)
-    );
-    return copy;
-  }
-  if (isPlainObject10(value)) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const copy = createPlainObject(true);
-    state.seen.set(value, copy);
-    for (const entry of getEnumerableObjectEntries(value, path189)) {
-      defineOwnDataProperty(
-        copy,
-        entry.key,
-        copyToSandbox(
-          entry.value,
-          state,
-          joinPath(path189, entry.key),
-          cloneSandboxCollections,
-          depth + 1
-        )
-      );
-    }
-    return copy;
-  }
-  throw new TypeError(`Unsupported sandbox value at ${path189}: ${describeValue(value)}`);
-}
-function copyFromSandbox(value, state, path189 = "<root>", options, depth = 0) {
-  assertSandboxDataDepth(depth);
-  if (isSandboxPrimitive(value)) {
-    return value;
-  }
-  if (isSandboxClosure(value)) {
-    if (options.wrapClosure === void 0) {
-      throw new TypeError(
-        "Sandbox closures cannot cross into host values without an explicit wrapper."
-      );
-    }
-    const existing = state.seen.get(value);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const wrapped = options.wrapClosure(value);
-    state.seen.set(value, wrapped);
-    return wrapped;
-  }
-  if (isSandboxPromise(value)) {
-    observeSandboxPromise(value);
-    return value.promise.then(
-      (resolved) => copyFromSandbox(resolved, { seen: /* @__PURE__ */ new WeakMap() }, "<root>", options),
-      (reason) => Promise.reject(
-        reason instanceof SandboxError ? reason : copyFromSandbox(reason, { seen: /* @__PURE__ */ new WeakMap() }, "<root>", options)
-      )
-    );
-  }
-  if (isSandboxGenerator(value)) {
-    throw new TypeError("Sandbox generators cannot cross into host values.");
-  }
-  if (isSandboxRegex(value)) {
-    const regex = new RegExp(value.source, value.flags);
-    regex.lastIndex = value.lastIndex;
-    return regex;
-  }
-  if (isSandboxMap(value)) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const copy = /* @__PURE__ */ new Map();
-    state.seen.set(value, copy);
-    for (const [key3, entry] of value.entries) {
-      copy.set(
-        copyFromSandbox(key3, state, `${path189}.<key>`, options, depth + 1),
-        copyFromSandbox(entry, state, `${path189}.<value>`, options, depth + 1)
-      );
-    }
-    return copy;
-  }
-  if (isSandboxSet(value)) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const copy = /* @__PURE__ */ new Set();
-    state.seen.set(value, copy);
-    for (const entry of value.values) {
-      copy.add(copyFromSandbox(entry, state, `${path189}.<value>`, options, depth + 1));
-    }
-    return copy;
-  }
-  if (isPlainArray(value)) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const copy = new Array(value.length);
-    state.seen.set(value, copy);
-    for (const entry of getEnumerableArrayEntries(value, path189)) {
-      defineOwnDataProperty(
-        copy,
-        entry.key,
-        copyFromSandbox(entry.value, state, joinArrayPath(path189, entry.key), options, depth + 1)
-      );
-    }
-    return copy;
-  }
-  if (isSandboxArguments(value)) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) return existing;
-    const copy = createSandboxArguments([]);
-    state.seen.set(value, copy);
-    copySandboxArgumentProperties(
-      value,
-      copy,
-      (entry, key3) => copyFromSandbox(entry, state, joinPath(path189, key3), options, depth + 1)
-    );
-    return copy;
-  }
-  if (isPlainObject10(value)) {
-    const existing = state.seen.get(value);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const copy = createPlainObject(Object.getPrototypeOf(value) === null);
-    state.seen.set(value, copy);
-    for (const entry of getEnumerableObjectEntries(value, path189)) {
-      defineOwnDataProperty(
-        copy,
-        entry.key,
-        copyFromSandbox(entry.value, state, joinPath(path189, entry.key), options, depth + 1)
-      );
-    }
-    return copy;
-  }
-  throw new TypeError(`Unsupported sandbox value at ${path189}: ${describeValue(value)}`);
-}
-function isSandboxPrimitive(value) {
-  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function isHostPromise(value) {
-  return value instanceof Promise;
-}
-function allocateSandboxValue(value, budget, seen) {
-  if (typeof value === "string") {
-    budget.allocateString(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    if (seen.has(value)) {
-      return;
-    }
-    seen.add(value);
-    budget.allocateArrayLength(value.length);
-    for (const entry of value) {
-      allocateSandboxValue(entry, budget, seen);
-    }
-    return;
-  }
-  if (isSandboxMap(value)) {
-    if (seen.has(value)) {
-      return;
-    }
-    seen.add(value);
-    budget.allocateCollectionEntries(value.entries.size);
-    for (const [key3, entry] of value.entries) {
-      allocateSandboxValue(key3, budget, seen);
-      allocateSandboxValue(entry, budget, seen);
-    }
-    return;
-  }
-  if (isSandboxSet(value)) {
-    if (seen.has(value)) {
-      return;
-    }
-    seen.add(value);
-    budget.allocateCollectionEntries(value.values.size);
-    for (const entry of value.values) {
-      allocateSandboxValue(entry, budget, seen);
-    }
-    return;
-  }
-  if (typeof value !== "object" || value === null || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value)) {
-    return;
-  }
-  if (seen.has(value)) {
-    return;
-  }
-  seen.add(value);
-  const entries = isSandboxArguments(value) ? getSandboxArgumentEntries(value).map(([, entry]) => entry) : Object.values(value);
-  for (const entry of entries) {
-    allocateSandboxValue(entry, budget, seen);
-  }
-}
-function isPlainObject10(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function isPlainArray(value) {
-  return Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype;
-}
-function createPlainObject(useNullPrototype) {
-  return useNullPrototype ? /* @__PURE__ */ Object.create(null) : {};
-}
-function defineOwnDataProperty(target, key3, value) {
-  Object.defineProperty(target, key3, {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value
-  });
-}
-function getEnumerableObjectEntries(value, path189) {
-  const descriptors = Object.getOwnPropertyDescriptors(value);
-  const entries = [];
-  for (const [key3, descriptor] of Object.entries(descriptors)) {
-    if (!descriptor.enumerable) {
-      continue;
-    }
-    if ("get" in descriptor || "set" in descriptor) {
-      throw new TypeError(`Unsupported sandbox value at ${joinPath(path189, key3)}: accessor property`);
-    }
-    entries.push({
-      key: key3,
-      value: descriptor.value
-    });
-  }
-  return entries;
-}
-function getEnumerableArrayEntries(value, path189) {
-  const descriptors = Object.getOwnPropertyDescriptors(value);
-  const entries = [];
-  for (const [key3, descriptor] of Object.entries(descriptors)) {
-    if (key3 === "length" || !descriptor.enumerable) {
-      continue;
-    }
-    if ("get" in descriptor || "set" in descriptor) {
-      throw new TypeError(
-        `Unsupported sandbox value at ${joinArrayPath(path189, key3)}: accessor property`
-      );
-    }
-    entries.push({
-      key: key3,
-      value: descriptor.value
-    });
-  }
-  return entries;
-}
-function isArrayIndexKey(value) {
-  if (value === "") {
-    return false;
-  }
-  const index = Number(value);
-  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === value;
-}
-function describeValue(value) {
-  if (typeof value === "function") {
-    return "function";
-  }
-  if (typeof value === "bigint" || typeof value === "symbol") {
-    return typeof value;
-  }
-  if (typeof value === "object" && value !== null) {
-    return value.constructor?.name ?? "Object";
-  }
-  return typeof value;
-}
-function joinPath(path189, key3) {
-  return path189 === "<root>" ? `<root>.${key3}` : `${path189}.${key3}`;
-}
-function joinArrayPath(path189, key3) {
-  return isArrayIndexKey(key3) ? `${path189}[${key3}]` : joinPath(path189, key3);
-}
-var sandboxClosureBrand, sandboxGeneratorBrand, sandboxMapBrand, sandboxPromiseBrand, sandboxRegexBrand, sandboxRegexPattern, sandboxSetBrand, sandboxRetainedValues;
-var init_values = __esm({
-  "packages/safejs/src/interp/values.ts"() {
-    "use strict";
-    init_otel2();
-    init_budget2();
-    init_promise_tracker();
-    init_promise_replay();
-    init_parse5();
-    init_graph_depth();
-    init_arguments();
-    init_arguments();
-    sandboxClosureBrand = /* @__PURE__ */ Symbol("SandboxClosure");
-    sandboxGeneratorBrand = /* @__PURE__ */ Symbol("SandboxGenerator");
-    sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
-    sandboxPromiseBrand = /* @__PURE__ */ Symbol("SandboxPromise");
-    sandboxRegexBrand = /* @__PURE__ */ Symbol("SandboxRegex");
-    sandboxRegexPattern = /* @__PURE__ */ Symbol("SandboxRegexPattern");
-    sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
-    sandboxRetainedValues = /* @__PURE__ */ Symbol("SandboxRetainedValues");
-  }
-});
-
-// packages/safejs/src/interp/globals/math.ts
-function createMathGlobals(options = {}) {
-  const random = options.random ?? Math.random;
-  const mathObject = {
-    E: Math.E,
-    LN2: Math.LN2,
-    LN10: Math.LN10,
-    LOG2E: Math.LOG2E,
-    LOG10E: Math.LOG10E,
-    PI: Math.PI,
-    SQRT1_2: Math.SQRT1_2,
-    SQRT2: Math.SQRT2,
-    random: createSandboxClosure({
-      call: () => random(),
-      name: "random"
-    })
-  };
-  for (const [name, method] of Object.entries(mathMethods)) {
-    mathObject[name] = createSandboxClosure({
-      call: (args) => Reflect.apply(method, Math, args),
-      name
-    });
-  }
-  return {
-    Infinity: Infinity,
-    Math: mathObject,
-    NaN: Number.NaN
-  };
-}
-function createSeededRandom(seed) {
-  let state = normalizeSeed(seed);
-  return {
-    next: () => {
-      state = Math.imul(state, 1664525) + 1013904223 >>> 0;
-      return state / 4294967296;
-    },
-    snapshot: () => state,
-    restore: (nextState) => {
-      state = normalizeSeed(nextState);
-    }
-  };
-}
-function normalizeSeed(seed) {
-  if (!Number.isFinite(seed)) {
-    throw new TypeError("Seeded random requires a finite numeric seed.");
-  }
-  return Math.trunc(seed) >>> 0;
-}
-var mathMethods;
-var init_math = __esm({
-  "packages/safejs/src/interp/globals/math.ts"() {
-    "use strict";
-    init_values();
-    mathMethods = {
-      abs: Math.abs,
-      acos: Math.acos,
-      acosh: Math.acosh,
-      asin: Math.asin,
-      asinh: Math.asinh,
-      atan: Math.atan,
-      atan2: Math.atan2,
-      atanh: Math.atanh,
-      ceil: Math.ceil,
-      cbrt: Math.cbrt,
-      clz32: Math.clz32,
-      cos: Math.cos,
-      cosh: Math.cosh,
-      exp: Math.exp,
-      expm1: Math.expm1,
-      floor: Math.floor,
-      fround: Math.fround,
-      hypot: Math.hypot,
-      imul: Math.imul,
-      log: Math.log,
-      log1p: Math.log1p,
-      log10: Math.log10,
-      log2: Math.log2,
-      max: Math.max,
-      min: Math.min,
-      pow: Math.pow,
-      round: Math.round,
-      sign: Math.sign,
-      sin: Math.sin,
-      sinh: Math.sinh,
-      sqrt: Math.sqrt,
-      tan: Math.tan,
-      tanh: Math.tanh,
-      trunc: Math.trunc
-    };
-  }
-});
-
-// packages/safejs/src/random.ts
-import { randomInt } from "node:crypto";
-function createReplayableRandom(options = {}) {
-  const snapshot2 = options.snapshot;
-  const saved = snapshot2?.random;
-  let initialState = options.seed;
-  if (saved !== void 0) {
-    const hasLoopState = typeof snapshot2?.loopIterations === "object" && snapshot2.loopIterations !== null && Object.keys(snapshot2.loopIterations).length > 0;
-    const replaysFromStart = snapshot2?.replay !== void 0 || Array.isArray(snapshot2?.pendingAwaits) && snapshot2.pendingAwaits.length > 0 && !hasLoopState;
-    initialState = replaysFromStart ? saved.initialState ?? saved.seed : saved.resumeState ?? saved.state;
-  }
-  const generator = createSeededRandom(initialState ?? randomInt(4294967296));
-  return { seed: saved?.seed ?? generator.snapshot(), ...generator };
-}
-var init_random = __esm({
-  "packages/safejs/src/random.ts"() {
-    "use strict";
-    init_math();
-  }
-});
-
-// packages/safejs/src/interp/running-state.ts
-function enterRunningState(object) {
-  if (runningObjects.has(object)) {
-    throw new SandboxError("reentry");
-  }
-  runningObjects.add(object);
-  let active = true;
-  return () => {
-    if (!active) return;
-    active = false;
-    runningObjects.delete(object);
-  };
-}
-function enterCollectionCallback(object) {
-  const leaveRunning = enterRunningState(object);
-  lockedCollections.add(object);
-  return () => {
-    lockedCollections.delete(object);
-    leaveRunning();
-  };
-}
-function assertCollectionMutable(object) {
-  if (lockedCollections.has(object)) {
-    throw new SandboxError("reentry");
-  }
-}
-function enterSnapshotRun(snapshot2) {
-  if (activeSnapshots.has(snapshot2)) {
-    throw new SandboxError("reentry");
-  }
-  activeSnapshots.add(snapshot2);
-  return () => activeSnapshots.delete(snapshot2);
-}
-function assertSnapshotInactive(snapshot2) {
-  if (activeSnapshots.has(snapshot2)) {
-    throw new SandboxError("reentry");
-  }
-}
-var runningObjects, lockedCollections, activeSnapshots;
-var init_running_state = __esm({
-  "packages/safejs/src/interp/running-state.ts"() {
-    "use strict";
-    init_budget2();
-    runningObjects = /* @__PURE__ */ new WeakSet();
-    lockedCollections = /* @__PURE__ */ new WeakSet();
-    activeSnapshots = /* @__PURE__ */ new WeakSet();
-  }
-});
-
-// packages/safejs/src/restore.ts
-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);
-  }
-  return snapshot2;
-}
-var SnapshotMismatchError;
-var init_restore = __esm({
-  "packages/safejs/src/restore.ts"() {
-    "use strict";
-    init_hash();
-    init_shape();
-    init_validation();
-    init_dump_format();
-    init_running_state();
-    SnapshotMismatchError = class extends Error {
-      actualHash;
-      expectedHash;
-      constructor(expectedHash, actualHash) {
-        super(
-          `source changed since snapshot was taken (hash ${expectedHash} expected, got ${actualHash}); pass --reset to discard`
-        );
-        this.name = "SnapshotMismatchError";
-        this.actualHash = actualHash;
-        this.expectedHash = expectedHash;
-        replaceErrorStack(this);
-      }
-    };
-  }
-});
-
 // packages/safejs/src/snapshot/replay-data.ts
 function encodeReplayData(value, options = {}) {
   const nodes = [];
@@ -138737,6 +137956,9 @@ function decodeReplayData(input, options = {}) {
       }
       return createSandboxClosure({
         ...capability,
+        boundTarget: capability.boundTarget,
+        cancellationSignal: capability.cancellationSignal,
+        sandbox: capability.sandbox,
         retainedValues: () => [capability],
         properties: (closure) => {
           restored.set(id, closure);
@@ -139443,10 +138665,11 @@ async function evaluateTryStatement(node, context, evaluateNode3) {
   if (node.finalizer === void 0 || tryOrCatchResult.kind === "error") {
     return tryOrCatchResult;
   }
-  const finalizerResult = fatalBudgetError?.budget === "deadline" ? await evaluateWithoutDeadlineChecks(
+  const evaluateFinalizer = () => fatalBudgetError?.budget === "deadline" ? evaluateWithoutDeadlineChecks(
     context,
     () => evaluateBlockCompletion(node.finalizer, context, evaluateNode3)
-  ) : await evaluateBlockCompletion(node.finalizer, context, evaluateNode3);
+  ) : evaluateBlockCompletion(node.finalizer, context, evaluateNode3);
+  const finalizerResult = await (fatalBudgetError === void 0 ? evaluateFinalizer() : withFatalPromiseCleanup(evaluateFinalizer));
   if (fatalBudgetError !== void 0) {
     throw fatalBudgetError;
   }
@@ -139843,6 +139066,7 @@ var init_exceptions = __esm({
     init_shape();
     init_budget2();
     init_host_call();
+    init_promise_tracker();
     init_values();
     capturedExceptionBrand = /* @__PURE__ */ Symbol("CapturedException");
     sandboxErrorBrand = /* @__PURE__ */ Symbol("SandboxError");
@@ -139859,6 +139083,136 @@ var init_exceptions = __esm({
   }
 });
 
+// packages/safejs/src/interp/running-state.ts
+function enterRunningState(object) {
+  if (runningObjects.has(object)) {
+    throw new SandboxError("reentry");
+  }
+  runningObjects.add(object);
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    runningObjects.delete(object);
+  };
+}
+function enterCollectionCallback(object) {
+  const leaveRunning = enterRunningState(object);
+  lockedCollections.add(object);
+  return () => {
+    lockedCollections.delete(object);
+    leaveRunning();
+  };
+}
+function assertCollectionMutable(object) {
+  if (lockedCollections.has(object)) {
+    throw new SandboxError("reentry");
+  }
+}
+function enterSnapshotRun(snapshot2) {
+  if (activeSnapshots.has(snapshot2)) {
+    throw new SandboxError("reentry");
+  }
+  activeSnapshots.add(snapshot2);
+  return () => activeSnapshots.delete(snapshot2);
+}
+function assertSnapshotInactive(snapshot2) {
+  if (activeSnapshots.has(snapshot2)) {
+    throw new SandboxError("reentry");
+  }
+}
+var runningObjects, lockedCollections, activeSnapshots;
+var init_running_state = __esm({
+  "packages/safejs/src/interp/running-state.ts"() {
+    "use strict";
+    init_budget2();
+    runningObjects = /* @__PURE__ */ new WeakSet();
+    lockedCollections = /* @__PURE__ */ new WeakSet();
+    activeSnapshots = /* @__PURE__ */ new WeakSet();
+  }
+});
+
+// packages/safejs/src/interp/iteration.ts
+function getSandboxIterator(value) {
+  if (isSandboxGenerator(value)) {
+    return generatorIterator(value);
+  }
+  if (typeof value === "string") {
+    return syncIterator(value[Symbol.iterator]());
+  }
+  if (isSandboxMap(value)) {
+    return syncIterator(
+      Array.from(value.entries, ([key3, entry]) => [key3, entry])[Symbol.iterator]()
+    );
+  }
+  if (isSandboxSet(value)) {
+    return syncIterator(value.values[Symbol.iterator]());
+  }
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return void 0;
+  }
+  const iteratorMethod = value[Symbol.iterator];
+  if (typeof iteratorMethod !== "function") {
+    return void 0;
+  }
+  return syncIterator(Reflect.apply(iteratorMethod, value, []));
+}
+function generatorIterator(generator) {
+  const invoke2 = async (method, value) => {
+    const leaveRunning = enterRunningState(generator);
+    generator.state = "running";
+    try {
+      const result = await generator.channel[method](value);
+      generator.state = result.done ? "done" : "suspended";
+      return result;
+    } catch (error3) {
+      generator.state = "done";
+      throw error3;
+    } finally {
+      leaveRunning();
+    }
+  };
+  return {
+    generator: true,
+    next: (value) => invoke2("next", value),
+    return: (value) => invoke2("return", value),
+    throw: (error3) => invoke2("throw", error3)
+  };
+}
+function syncIterator(iterator) {
+  const next = iterator.next;
+  const invoke2 = (method, args) => {
+    const leaveRunning = enterRunningState(iterator);
+    try {
+      return Reflect.apply(method, iterator, args);
+    } finally {
+      leaveRunning();
+    }
+  };
+  return {
+    next: (...args) => invoke2(next, args),
+    get return() {
+      const method = iterator.return;
+      if (method === void 0 || method === null) return void 0;
+      if (typeof method !== "function") throw new TypeError("Iterator return must be callable.");
+      return (...args) => invoke2(method, args);
+    },
+    get throw() {
+      const method = iterator.throw;
+      if (method === void 0 || method === null) return void 0;
+      if (typeof method !== "function") throw new TypeError("Iterator throw must be callable.");
+      return (...args) => invoke2(method, args);
+    }
+  };
+}
+var init_iteration = __esm({
+  "packages/safejs/src/interp/iteration.ts"() {
+    "use strict";
+    init_values();
+    init_running_state();
+  }
+});
+
 // packages/safejs/src/interp/jobs.ts
 import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
 function runPromiseJob(task) {
@@ -139952,177 +139306,453 @@ var init_jobs4 = __esm({
 });
 
 // packages/safejs/src/interp/promise.ts
+function isSandboxPromiseConstructor(value) {
+  return isSandboxClosure(value) && promiseConstructors.has(value);
+}
 function createPromiseGlobals(options) {
-  return {
-    Promise: {
+  promisePrototypes.delete(options.budget);
+  const prototype = getPromisePrototype(options.budget);
+  const construct = async ([executor], context) => {
+    if (!isSandboxClosure(executor)) throw new TypeError("Promise executor must be a function.");
+    let fulfill;
+    let reject;
+    const pending = createSandboxPromise(
+      new Promise((resolve17, rejectPromise) => {
+        fulfill = resolve17;
+        reject = rejectPromise;
+      }),
+      { span: context?.span }
+    );
+    let settled = false;
+    const settle = (state, value) => {
+      if (settled) return;
+      settled = true;
+      try {
+        if (state === "rejected") {
+          reject(budgetSandboxValue(value, options.budget));
+        } else if (value === pending) {
+          reject(
+            createSubsetErrorValue(
+              "TypeError",
+              "Promise cannot resolve to itself.",
+              context?.stack ?? [],
+              options.budget
+            )
+          );
+        } else {
+          fulfill(resolveSandboxValue(value, { budget: options.budget, self: pending }));
+        }
+      } catch (error3) {
+        reject(error3);
+      }
+    };
+    try {
+      const result = executor.call(
+        [
+          createSandboxClosure({
+            sandbox: true,
+            name: "resolve",
+            retainedValues: () => [pending],
+            call: ([value]) => {
+              settle("fulfilled", value);
+              return void 0;
+            }
+          }),
+          createSandboxClosure({
+            sandbox: true,
+            name: "reject",
+            retainedValues: () => [pending],
+            call: ([reason]) => {
+              settle("rejected", reason);
+              return void 0;
+            }
+          })
+        ],
+        { stack: context?.stack ?? [], thisValue: void 0 }
+      );
+      if (executor.async !== true) await result;
+      else if (isSandboxPromise(result) && result.synchronousPrefix !== void 0)
+        await result.synchronousPrefix;
+      else if (isPromiseLike3(result)) createSandboxPromise(Promise.resolve(result));
+    } catch (error3) {
+      if (error3 instanceof SandboxError && (error3.code === "budgetExceeded" || error3.code === "reentry")) {
+        observeSandboxPromise(pending);
+        throw error3;
+      }
+      settle("rejected", error3);
+    }
+    return pending;
+  };
+  const promiseConstructor = createSandboxClosure({
+    sandbox: true,
+    name: "Promise",
+    construct,
+    call: () => {
+      throw new TypeError("Constructor Promise requires 'new'.");
+    },
+    properties: {
+      prototype,
       all: createSandboxClosure({
-        async: true,
-        call: ([values]) => createSandboxPromise(
-          settleIterable(values, (entries) => Promise.all(entries), options.budget)
+        sandbox: true,
+        call: ([values], context) => settleIterable(
+          values,
+          "all",
+          options.budget,
+          context === void 0 ? promiseConstructor : context.thisValue,
+          context
         ),
         name: "all"
       }),
       race: createSandboxClosure({
-        async: true,
-        call: ([values]) => createSandboxPromise(
-          settleIterable(values, (entries) => Promise.race(entries), options.budget)
+        sandbox: true,
+        call: ([values], context) => settleIterable(
+          values,
+          "race",
+          options.budget,
+          context === void 0 ? promiseConstructor : context.thisValue,
+          context
         ),
         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
-          )
+        sandbox: true,
+        call: ([values], context) => settleIterable(
+          values,
+          "allSettled",
+          options.budget,
+          context === void 0 ? promiseConstructor : context.thisValue,
+          context
         ),
         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
-          )
+        sandbox: true,
+        call: ([values], context) => settleIterable(
+          values,
+          "any",
+          options.budget,
+          context === void 0 ? promiseConstructor : context.thisValue,
+          context
         ),
         name: "any"
       }),
       resolve: createSandboxClosure({
-        async: true,
-        call: ([value]) => isSandboxPromise(value) ? value : createSandboxPromise(resolveSandboxValue(value, { budget: options.budget })),
+        sandbox: true,
+        call: ([value], context) => {
+          const constructor = context === void 0 ? promiseConstructor : context.thisValue;
+          if (typeof constructor !== "object" || constructor === null) {
+            throw new TypeError("Promise.resolve requires an object receiver.");
+          }
+          if (isSandboxPromise(value) && getPromiseMember("constructor", options.budget) === constructor) {
+            return value;
+          }
+          return isSandboxPromiseConstructor(constructor) ? createSandboxPromise(resolveSandboxValue(value, { budget: options.budget })) : settleConstructedPromise(constructor, value, "fulfilled", options.budget, context);
+        },
         name: "resolve"
       }),
       reject: createSandboxClosure({
-        async: true,
-        call: ([reason], context) => createRejectedSandboxPromise(reason, options.budget, context?.span),
+        sandbox: true,
+        call: ([reason], context) => {
+          const constructor = context === void 0 ? promiseConstructor : context.thisValue;
+          return isSandboxPromiseConstructor(constructor) ? createRejectedSandboxPromise(reason, options.budget, context?.span) : settleConstructedPromise(constructor, reason, "rejected", options.budget, context);
+        },
         name: "reject"
       })
     }
-  };
+  });
+  Object.defineProperty(prototype, "constructor", {
+    value: promiseConstructor,
+    writable: true,
+    configurable: true
+  });
+  promiseConstructors.add(promiseConstructor);
+  intrinsicPromiseConstructors.set(options.budget, promiseConstructor);
+  return { Promise: promiseConstructor };
 }
-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;
-      },
-      name: "then"
+function getPromiseMember(property, budget) {
+  const prototype = getPromisePrototype(budget);
+  return Object.hasOwn(prototype, property) ? prototype[property] : void 0;
+}
+async function settleConstructedPromise(constructor, value, state, budget, context) {
+  const capability = await createPromiseCapability(constructor, budget, context);
+  await callPromiseClosure(
+    state === "fulfilled" ? capability.resolve : capability.reject,
+    [value],
+    void 0,
+    budget,
+    context
+  );
+  return capability.promise;
+}
+async function createPromiseCapability(constructor, budget, context) {
+  if (!isSandboxClosure(constructor) || constructor.construct === void 0) {
+    throw new TypeError("Promise method requires a constructor receiver.");
+  }
+  let resolve17;
+  let reject;
+  const executor = createSandboxClosure({
+    sandbox: true,
+    retainedValues: () => [resolve17, reject],
+    call: (args) => {
+      if (resolve17 !== void 0 || reject !== void 0) {
+        throw new TypeError("Promise capability is already initialized.");
+      }
+      [resolve17, reject] = args;
+      return void 0;
+    }
+  });
+  const leaveCall = budget.enterCall();
+  try {
+    const promise = await constructor.construct([executor], {
+      stack: context?.stack ?? [],
+      thisValue: void 0,
+      ...context?.span === void 0 ? {} : { span: context.span }
     });
+    if (!isSandboxClosure(resolve17) || !isSandboxClosure(reject)) {
+      throw new TypeError("Promise capability requires callable resolve and reject functions.");
+    }
+    return { promise, resolve: resolve17, reject };
+  } finally {
+    leaveCall();
   }
-  if (property === "catch") {
-    return createSandboxClosure({
-      async: true,
-      call: ([onRejected]) => {
+}
+async function callPromiseClosure(callback, args, thisValue, budget, context) {
+  const leaveCall = budget.enterCall();
+  try {
+    const stack = context?.stack ?? [];
+    const values = args.map(
+      (value) => value instanceof Error && !(value instanceof SandboxError) ? coerceThrownValue(value, budget, stack) : value
+    );
+    let result = callback.call(values, { stack, thisValue });
+    if (callback.async !== true) result = await result;
+    else if (isPromiseLike3(result)) result = createSandboxPromise(Promise.resolve(result));
+    if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) {
+      await result.synchronousPrefix;
+    }
+    return result;
+  } finally {
+    leaveCall();
+  }
+}
+function getPromisePrototype(budget) {
+  const existing = promisePrototypes.get(budget);
+  if (existing !== void 0) return existing;
+  const prototype = {
+    then: createSandboxClosure({
+      sandbox: true,
+      call: ([onFulfilled, onRejected], context) => {
+        const target = context?.thisValue;
+        if (!isSandboxPromise(target))
+          throw new TypeError("Promise.then requires a promise receiver.");
+        validatePromiseConstructorProperty(target, prototype);
         observeSandboxPromise(target);
         const chained = createSandboxPromise(
           target.promise.then(
-            (value) => runPromiseReaction(void 0, value, "fulfilled", budget, chained),
-            (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained)
+            (value) => {
+              consumeSettledHostCall(target);
+              return runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained);
+            },
+            (reason) => {
+              consumeSettledHostCall(target);
+              return runPromiseReaction(onRejected, reason, "rejected", budget, chained);
+            }
           )
         );
         return chained;
       },
+      name: "then"
+    }),
+    catch: createSandboxClosure({
+      sandbox: true,
+      call: ([onRejected], context) => {
+        const target = context?.thisValue;
+        const then = readPromiseReceiverProperty(target, "then", prototype);
+        if (!isSandboxClosure(then)) throw new TypeError("Promise.catch requires a callable then.");
+        return then.call([void 0, onRejected], {
+          stack: context?.stack ?? [],
+          thisValue: target
+        });
+      },
       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;
+    }),
+    finally: createSandboxClosure({
+      sandbox: true,
+      call: ([onFinally], context) => {
+        const target = context?.thisValue;
+        if (typeof target !== "object" || target === null) {
+          throw new TypeError("Promise.finally requires an object receiver.");
+        }
+        validatePromiseConstructorProperty(target, prototype);
+        const then = readPromiseReceiverProperty(target, "then", prototype);
+        if (!isSandboxClosure(then))
+          throw new TypeError("Promise.finally requires a callable then.");
+        const handlers = isSandboxClosure(onFinally) ? ["fulfilled", "rejected"].map(
+          (state) => createSandboxClosure({
+            sandbox: true,
+            retainedValues: () => [onFinally],
+            call: async ([value]) => {
+              const result = await callPromiseClosure(
+                onFinally,
+                [],
+                void 0,
+                budget,
+                context
+              );
+              const pending = isSandboxPromise(result) && getPromiseMember("constructor", budget) === intrinsicPromiseConstructors.get(budget) ? result : createSandboxPromise(resolveSandboxValue(result, { budget }));
+              const cleanupThen = getPromiseMember("then", budget);
+              if (!isSandboxClosure(cleanupThen))
+                throw new TypeError("Promise cleanup requires a callable then.");
+              return callPromiseClosure(
+                cleanupThen,
+                [
+                  createSandboxClosure({
+                    sandbox: true,
+                    retainedValues: () => [value],
+                    call: () => {
+                      if (state === "rejected") throw value;
+                      return value;
+                    }
+                  })
+                ],
+                pending,
+                budget,
+                context
+              );
+            }
+          })
+        ) : [onFinally, onFinally];
+        return then.call(handlers, { stack: context?.stack ?? [], thisValue: target });
       },
       name: "finally"
-    });
+    })
+  };
+  for (const name of Object.keys(prototype)) {
+    Object.defineProperty(prototype, name, { enumerable: false });
   }
-  return void 0;
+  promisePrototypes.set(budget, prototype);
+  return prototype;
 }
-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 readPromiseReceiverProperty(receiver, property, prototype) {
+  const properties = isSandboxPromise(receiver) ? prototype : isSandboxClosure(receiver) ? receiver.properties : receiver;
+  return typeof properties === "object" && properties !== null && Object.hasOwn(properties, property) ? properties[property] : void 0;
 }
-function getPromiseIterator(iterable) {
-  if (typeof iterable === "string") {
-    return iterable[Symbol.iterator]();
+function validatePromiseConstructorProperty(receiver, prototype) {
+  const constructor = readPromiseReceiverProperty(receiver, "constructor", prototype);
+  if (constructor !== void 0 && (typeof constructor !== "object" || constructor === null)) {
+    throw new TypeError("Promise constructor property must be an object.");
   }
-  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.");
+async function settleIterable(iterable, method, budget, constructor, context) {
+  const capability = await createPromiseCapability(constructor, budget, context);
+  const prototype = getPromisePrototype(budget);
+  const values = [];
+  let remaining = 1;
+  const complete = async () => {
+    if (remaining !== 0 || method === "race") return;
+    if (method === "any") {
+      const error3 = createSubsetErrorValue(
+        "AggregateError",
+        "All promises were rejected",
+        [],
+        budget
+      );
+      error3.errors = values;
+      await callPromiseClosure(
+        capability.reject,
+        [budgetSandboxValue(error3, budget)],
+        void 0,
+        budget,
+        context
+      );
+    } else {
+      await callPromiseClosure(
+        capability.resolve,
+        [budgetSandboxValue(values, budget)],
+        void 0,
+        budget,
+        context
+      );
+    }
+  };
+  try {
+    const promiseResolve = readPromiseReceiverProperty(constructor, "resolve", prototype);
+    if (!isSandboxClosure(promiseResolve))
+      throw new TypeError("Promise constructor requires a callable resolve.");
+    const iterator = getSandboxIterator(iterable);
+    if (iterator === void 0) throw new TypeError("Promise helpers require an iterable.");
+    let index = 0;
+    while (true) {
+      budget.visitNode();
+      const next = iterator.generator ? await iterator.next() : iterator.next();
+      if (typeof next !== "object" || next === null)
+        throw new TypeError("Iterator result must be an object.");
+      if (next.done) break;
+      const value = next.value;
+      try {
+        budget.allocateArrayLength(index + 1);
+        const entryIndex = index++;
+        if (method !== "race") values.push(void 0);
+        const entry = await callPromiseClosure(
+          promiseResolve,
+          [value],
+          constructor,
+          budget,
+          context
+        );
+        let called = false;
+        const handlers = ["fulfilled", "rejected"].map((state) => {
+          if (method === "race" || method === "any" && state === "fulfilled")
+            return state === "fulfilled" ? capability.resolve : capability.reject;
+          if (method === "all" && state === "rejected") return capability.reject;
+          return createSandboxClosure({
+            sandbox: true,
+            retainedValues: () => [
+              capability.promise,
+              capability.resolve,
+              capability.reject,
+              values
+            ],
+            call: async ([settlement]) => {
+              if (called) return void 0;
+              called = true;
+              values[entryIndex] = method === "allSettled" ? state === "fulfilled" ? { status: state, value: settlement } : { status: state, reason: settlement } : settlement;
+              remaining--;
+              await complete();
+              return void 0;
+            }
+          });
+        });
+        remaining++;
+        const then = readPromiseReceiverProperty(entry, "then", prototype);
+        if (!isSandboxClosure(then))
+          throw new TypeError("Promise resolver result requires a callable then.");
+        await callPromiseClosure(then, handlers, entry, budget, context);
+      } catch (error3) {
+        try {
+          const closed = iterator.return?.();
+          if (iterator.generator) await closed;
+        } catch {
+          throw error3;
+        }
+        throw error3;
+      }
+    }
+    remaining--;
+    await complete();
+  } catch (error3) {
+    if (error3 instanceof SandboxError && (error3.code === "budgetExceeded" || error3.code === "reentry")) {
+      if (isSandboxPromise(capability.promise)) observeSandboxPromise(capability.promise);
+      throw error3;
+    }
+    await callPromiseClosure(
+      capability.reject,
+      [error3],
+      void 0,
+      budget,
+      context
+    );
   }
-  return next;
+  return capability.promise;
 }
 function schedulePromise(promise, budget) {
   return Promise.resolve().then(
@@ -140138,11 +139768,15 @@ function createRejectedSandboxPromise(reason, budget, span) {
   return createSandboxPromise(promise, { span });
 }
 function budgetSandboxValue(value, budget) {
-  allocateSandboxValue2(value, budget, /* @__PURE__ */ new WeakSet());
+  allocateSandboxValue(value, budget, /* @__PURE__ */ new WeakSet());
   return value;
 }
 function resolveSandboxValue(value, options = {}) {
-  return Promise.resolve().then(() => resolveSandboxValueNow(value, options, /* @__PURE__ */ new WeakSet()));
+  try {
+    return resolveSandboxValueNow(value, options);
+  } catch (error3) {
+    return Promise.reject(error3);
+  }
 }
 function consumeSettledHostCall(value) {
   if (value.hostCall?.lifecycle !== "settled") {
@@ -140150,19 +139784,22 @@ function consumeSettledHostCall(value) {
   }
   value.hostCallJournal?.consume(value.hostCall);
 }
-function resolveSandboxValueNow(value, options, seenThenables) {
+function resolveSandboxValueNow(value, options) {
   if (isPromiseLike3(value)) {
     return Promise.resolve(value).then(
-      (resolved) => resolveSandboxValueNow(resolved, options, seenThenables),
+      (resolved) => resolveSandboxValueNow(resolved, options),
       (reason) => Promise.reject(budgetIfNeeded(reason, options.budget))
     );
   }
   if (isSandboxPromise(value)) {
+    if (options.budget !== void 0) {
+      return resolvePromiseResult(value, options.budget, options.self);
+    }
     observeSandboxPromise(value);
     return value.promise.then(
       (resolved) => {
         consumeSettledHostCall(value);
-        return resolveSandboxValueNow(resolved, options, seenThenables);
+        return resolveSandboxValueNow(resolved, options);
       },
       (reason) => {
         consumeSettledHostCall(value);
@@ -140172,21 +139809,14 @@ function resolveSandboxValueNow(value, options, seenThenables) {
   }
   const then = getThenable(value);
   if (then !== void 0) {
-    return resolveThenable(value, then, options, seenThenables);
+    return resolveThenable(value, then, options);
   }
   return Promise.resolve(budgetIfNeeded(value, options.budget));
 }
-function resolveThenable(value, then, options, seenThenables) {
+function resolveThenable(value, then, options) {
   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;
@@ -140196,7 +139826,9 @@ function resolveThenable(value, then, options, seenThenables) {
       completed = true;
       try {
         if (settlement.state === "fulfilled") {
-          resolve17(resolveSandboxValueNow(settlement.value, options, seenThenables));
+          resolve17(
+            isSandboxPromise(settlement.value) || getThenable(settlement.value) !== void 0 ? resolveSandboxValueNow(settlement.value, options) : budgetIfNeeded(settlement.value, options.budget)
+          );
         } else {
           reject(budgetIfNeeded(settlement.value, options.budget));
         }
@@ -140215,6 +139847,7 @@ function resolveThenable(value, then, options, seenThenables) {
       then,
       [
         createSandboxClosure({
+          sandbox: true,
           call: ([resolved]) => {
             recordSettlement("fulfilled", resolved);
             return void 0;
@@ -140222,6 +139855,7 @@ function resolveThenable(value, then, options, seenThenables) {
           name: "resolve"
         }),
         createSandboxClosure({
+          sandbox: true,
           call: ([reason]) => {
             recordSettlement("rejected", reason);
             return void 0;
@@ -140229,57 +139863,137 @@ function resolveThenable(value, then, options, seenThenables) {
           name: "reject"
         })
       ],
-      value
-    ).then(
-      () => {
-        invocationPending = false;
-        complete();
-      },
-      (error3) => {
-        invocationPending = false;
-        recordSettlement("rejected", error3);
-        complete();
+      value,
+      {
+        fulfilled: () => {
+          invocationPending = false;
+          complete();
+        },
+        rejected: (error3) => {
+          invocationPending = false;
+          if (error3 instanceof SandboxError && (error3.code === "budgetExceeded" || error3.code === "reentry")) {
+            completed = true;
+            reject(error3);
+            return;
+          }
+          recordSettlement("rejected", error3);
+          complete();
+        }
       }
-    );
-  }).then((resolved) => budgetIfNeeded(resolved, options.budget));
+    ).catch(reject);
+  });
 }
 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)
-    )
-  );
+  return new Promise((resolve17, reject) => {
+    if (state === "rejected" && value instanceof SandboxError && (value.code === "budgetExceeded" || value.code === "reentry")) {
+      reject(value);
+      return;
+    }
+    const argument = state === "rejected" && value instanceof Error ? coerceThrownValue(value, budget, []) : value;
+    const fulfilled = (result) => {
+      if (isPromiseLike3(result)) {
+        resolve17(resolvePromiseResult(result, budget, self));
+      } else if (isSelfResolution(result, self)) {
+        reject(
+          createSubsetErrorValue("TypeError", "Promise cannot resolve to itself.", [], budget)
+        );
+      } else if (isSandboxPromise(result) || getThenable(result) !== void 0) {
+        resolve17(resolvePromiseResult(result, budget, self));
+      } else {
+        resolve17(budgetSandboxValue(result, budget));
+      }
+    };
+    if (isSandboxClosure(handler)) {
+      callInPromiseJob(handler, [argument], void 0, { fulfilled, rejected: reject }).catch(
+        reject
+      );
+    } else {
+      runPromiseJob(() => {
+        if (state === "fulfilled") fulfilled(value);
+        else reject(budgetSandboxValue(value, budget));
+      }).catch(reject);
+    }
+  });
 }
-function callInPromiseJob(handler, args, thisValue = void 0) {
+function callInPromiseJob(handler, args, thisValue = void 0, completion) {
   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;
+    try {
+      let result = handler.call(args, { stack: [], thisValue });
+      if (handler.async !== true) result = await result;
+      if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) {
+        await result.synchronousPrefix;
+      }
+      completion?.fulfilled(result);
+      return { value: result };
+    } catch (error3) {
+      if (completion === void 0) throw error3;
+      completion.rejected(error3);
+      return { value: void 0 };
     }
-    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 resolvePromiseResult(result, budget, self) {
+  if (isPromiseLike3(result)) {
+    return Promise.resolve(result).then((resolved) => resolvePromiseResult(resolved, budget, self));
+  }
+  if (isSelfResolution(result, self)) {
+    return Promise.reject(
+      createSubsetErrorValue("TypeError", "Promise cannot resolve to itself.", [], budget)
+    );
+  }
+  if (!isSandboxPromise(result)) return resolveSandboxValue(result, { budget, self });
+  const then = getPromiseMember("then", budget);
+  if (!isSandboxClosure(then)) return Promise.resolve(result);
+  return new Promise((resolve17, reject) => {
+    let settled = false;
+    const settle = (state, value) => {
+      if (settled) return;
+      settled = true;
+      try {
+        if (state === "rejected") reject(budgetSandboxValue(value, budget));
+        else if (isSandboxPromise(value) || getThenable(value) !== void 0) {
+          resolve17(resolvePromiseResult(value, budget, self));
+        } else {
+          resolve17(budgetSandboxValue(value, budget));
+        }
+      } catch (error3) {
+        reject(error3);
+      }
+    };
+    runPromiseJob(async () => {
+      try {
+        const completion = await callPromiseClosure(
+          then,
+          [
+            createSandboxClosure({
+              sandbox: true,
+              call: ([value]) => {
+                settle("fulfilled", value);
+                return void 0;
+              }
+            }),
+            createSandboxClosure({
+              sandbox: true,
+              call: ([reason]) => {
+                settle("rejected", reason);
+                return void 0;
+              }
+            })
+          ],
+          result,
+          budget
+        );
+        if (isSandboxPromise(completion)) {
+          completion.promise.catch((reason) => {
+            if (reason instanceof SandboxError && (reason.code === "budgetExceeded" || reason.code === "reentry")) {
+              reject(reason);
+            }
+          });
+        }
+      } catch (error3) {
+        settle("rejected", error3);
+      }
+    }).catch(reject);
   });
 }
 function isSelfResolution(result, self) {
@@ -140295,7 +140009,7 @@ function getThenable(value) {
 function budgetIfNeeded(value, budget) {
   return budget === void 0 ? value : budgetSandboxValue(value, budget);
 }
-function allocateSandboxValue2(value, budget, seen) {
+function allocateSandboxValue(value, budget, seen) {
   if (typeof value === "string") {
     budget.allocateString(value);
     return;
@@ -140307,7 +140021,7 @@ function allocateSandboxValue2(value, budget, seen) {
     }
     seen.add(value);
     for (const entry of value) {
-      allocateSandboxValue2(entry, budget, seen);
+      allocateSandboxValue(entry, budget, seen);
     }
     return;
   }
@@ -140319,100 +140033,137 @@ function allocateSandboxValue2(value, budget, seen) {
   }
   seen.add(value);
   for (const entry of Object.values(value)) {
-    allocateSandboxValue2(entry, budget, seen);
+    allocateSandboxValue(entry, budget, seen);
   }
 }
 function isPromiseLike3(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function" && !isSandboxClosure(value) && !isSandboxPromise(value);
 }
+var promiseConstructors, intrinsicPromiseConstructors, promisePrototypes;
 var init_promise = __esm({
   "packages/safejs/src/interp/promise.ts"() {
     "use strict";
+    init_budget2();
     init_exceptions();
+    init_iteration();
     init_jobs4();
     init_promise_tracker();
     init_values();
+    promiseConstructors = /* @__PURE__ */ new WeakSet();
+    intrinsicPromiseConstructors = /* @__PURE__ */ new WeakMap();
+    promisePrototypes = /* @__PURE__ */ new WeakMap();
   }
 });
 
 // packages/safejs/src/interp/cancel.ts
+import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
+function withCancellationSignal(signal, task) {
+  return activeCancellation.run({ signal, host: false }, task);
+}
+function invokeCancelableClosure(closure, operation, args, context, construct = false) {
+  assertPromiseExecutionAllowed();
+  const active = activeCancellation.getStore();
+  if (active === void 0) return operation(args, context);
+  if (closure.sandbox === true) {
+    return activeCancellation.run(
+      { signal: active.signal, host: false },
+      () => operation(args, context)
+    );
+  }
+  const signal = active.signal;
+  const managed = signal !== void 0 && closure.cancellationSignal === signal;
+  if (signal?.aborted && !managed) {
+    if (!construct && closure.async === true)
+      return createRejectedSandboxPromise2(readAbortReason(signal));
+    throw readAbortReason(signal);
+  }
+  return activeCancellation.run({ signal, host: true }, () => {
+    const result = operation(args, context);
+    if (signal === void 0 || managed) return result;
+    if (isPromiseLike4(result))
+      return awaitWithSignal(result, signal).then((value) => {
+        registerCancelablePromises(value, signal);
+        return value;
+      });
+    registerCancelablePromises(result, signal);
+    return result;
+  });
+}
 function wrapCancelableBindings(bindings, signal) {
-  if (signal === void 0) {
-    return bindings;
-  }
-  return wrapCancelableValue(bindings, signal, /* @__PURE__ */ new WeakMap());
+  if (signal !== void 0) registerCancelablePromises(bindings, signal);
+  return bindings;
 }
-function wrapCancelableValue(value, signal, seen) {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  const existing = seen.get(value);
-  if (existing !== void 0) {
-    return existing;
+function registerPromiseCancellation(promise) {
+  const active = activeCancellation.getStore();
+  if (active?.host === false) sandboxPromises.add(promise);
+  else if (active?.signal !== void 0) managePromiseCancellation(promise, active.signal);
+}
+function readPromiseCancellation(promise, original) {
+  const signal = activeCancellation.getStore()?.signal;
+  return signal === void 0 ? original : cancelableOutcomes.get(promise)?.get(signal) ?? original;
+}
+function managePromiseCancellation(promise, signal) {
+  let outcomes = cancelableOutcomes.get(promise);
+  if (outcomes?.has(signal)) return;
+  if (outcomes === void 0) {
+    outcomes = /* @__PURE__ */ new WeakMap();
+    cancelableOutcomes.set(promise, outcomes);
   }
-  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;
+  const outcome = awaitWithSignal(promise.promise, signal);
+  outcomes.set(signal, outcome);
+  trackSandboxPromise(promise, outcome);
+}
+function registerCancelablePromises(value, signal) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const pending = [value];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (typeof current !== "object" || current === null || seen.has(current)) continue;
+    seen.add(current);
+    if (isSandboxPromise(current)) {
+      if (!sandboxPromises.has(current)) managePromiseCancellation(current, signal);
+      continue;
+    }
+    if (isSandboxClosure(current)) {
+      if (current.properties !== void 0) pending.push(current.properties);
+    } else if (isSandboxMap(current)) {
+      for (const [key3, entry] of current.entries) pending.push(key3, entry);
+    } else if (isSandboxSet(current)) {
+      for (const entry of current.values) pending.push(entry);
+    } else {
+      for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(current))) {
+        if ("value" in descriptor) pending.push(descriptor.value);
+      }
+    }
   }
+}
+function awaitSandboxValue(value, signal, budget) {
+  let resolved;
   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 }
+    const outcome = signal === void 0 ? value.promise : cancelableOutcomes.get(value)?.get(signal) ?? value.promise;
+    resolved = new Promise((resolve17, reject) => {
+      const detach = onFatalPromiseRejection(reject);
+      const complete = (state, result) => {
+        detach?.();
+        try {
+          consumeSettledHostCall(value);
+          if (state === "fulfilled") resolve17(result);
+          else reject(result);
+        } catch (error3) {
+          reject(error3);
+        }
+      };
+      outcome.then(
+        (result) => complete("fulfilled", result),
+        (reason) => complete("rejected", reason)
+      );
     });
-    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);
+  } else {
+    resolved = resolveSandboxValue(value, { budget });
   }
-  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);
+  const pending = isSandboxPromise(value) && (value.synchronousPrefix !== void 0 || signal !== void 0 && cancelableOutcomes.get(value)?.has(signal)) ? resolved : awaitWithSignal(resolved, signal);
+  return isSandboxPromise(value) ? pending : interruptOnFatalPromiseRejection(pending);
 }
 function awaitWithSignal(promise, signal) {
   if (signal === void 0) return Promise.resolve(promise);
@@ -140455,15 +140206,6 @@ function awaitWithSignal(promise, signal) {
     );
   });
 }
-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();
 }
@@ -140484,9 +140226,9 @@ function createRejectedSandboxPromise2(reason) {
   return createSandboxPromise(promise);
 }
 function isPromiseLike4(value) {
-  return typeof value === "object" && value !== null && "then" in value;
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
-var cancellationSignals;
+var activeCancellation, sandboxPromises, cancelableOutcomes;
 var init_cancel2 = __esm({
   "packages/safejs/src/interp/cancel.ts"() {
     "use strict";
@@ -140494,7 +140236,804 @@ var init_cancel2 = __esm({
     init_promise_tracker();
     init_shape();
     init_promise();
-    cancellationSignals = /* @__PURE__ */ new WeakMap();
+    activeCancellation = new AsyncLocalStorage6();
+    sandboxPromises = /* @__PURE__ */ new WeakSet();
+    cancelableOutcomes = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safejs/src/interp/values.ts
+function createSandboxClosure(input) {
+  const closure = {
+    kind: "fn",
+    call: (args, context) => invokeCancelableClosure(closure, input.call, args, context),
+    name: input.name,
+    ...input.construct === void 0 ? {} : {
+      construct: (args, context) => invokeCancelableClosure(closure, input.construct, args, context, true)
+    },
+    ...input.async === true ? { async: true } : {}
+  };
+  Object.defineProperty(closure, sandboxClosureBrand, {
+    enumerable: false,
+    value: true
+  });
+  if (input.sandbox === true) {
+    Object.defineProperty(closure, "sandbox", { value: true });
+  }
+  if (input.boundTarget !== void 0) {
+    Object.defineProperty(closure, "boundTarget", { value: input.boundTarget });
+  }
+  if (input.cancellationSignal !== void 0) {
+    Object.defineProperty(closure, "cancellationSignal", {
+      value: input.cancellationSignal
+    });
+  }
+  if (input.properties !== void 0) {
+    Object.defineProperty(closure, "properties", {
+      enumerable: false,
+      value: Object.freeze(
+        typeof input.properties === "function" ? input.properties(closure) : input.properties
+      )
+    });
+  }
+  if (input.retainedValues !== void 0) {
+    Object.defineProperty(closure, sandboxRetainedValues, {
+      value: input.retainedValues
+    });
+  }
+  return Object.freeze(closure);
+}
+function createSandboxPromise(promise, metadata = {}) {
+  const original = metadata.trackReplay === false ? promise : promiseReplayContext.getStore()?.track(promise) ?? promise;
+  const sandboxPromise = {
+    kind: "promise",
+    get promise() {
+      return readPromiseCancellation(sandboxPromise, original);
+    }
+  };
+  Object.defineProperty(sandboxPromise, sandboxPromiseBrand, {
+    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 });
+  }
+  if (metadata.hostCallJournal !== void 0) {
+    Object.defineProperty(sandboxPromise, "hostCallJournal", {
+      value: metadata.hostCallJournal
+    });
+  }
+  trackSandboxPromise(sandboxPromise);
+  registerPromiseCancellation(sandboxPromise);
+  return Object.freeze(sandboxPromise);
+}
+function createSandboxGenerator(channel, metadata = void 0) {
+  const generator = {
+    kind: "generator",
+    state: "start",
+    channel,
+    ...metadata
+  };
+  Object.defineProperty(generator, sandboxGeneratorBrand, {
+    enumerable: false,
+    value: true
+  });
+  return generator;
+}
+function createSandboxMap(entries = []) {
+  const map = {};
+  Object.defineProperties(map, {
+    kind: {
+      value: "map"
+    },
+    entries: {
+      value: new Map(entries)
+    }
+  });
+  Object.defineProperty(map, sandboxMapBrand, {
+    enumerable: false,
+    value: true
+  });
+  return Object.freeze(map);
+}
+function createSandboxSet(values = []) {
+  const set = {};
+  Object.defineProperties(set, {
+    kind: {
+      value: "set"
+    },
+    values: {
+      value: new Set(values)
+    }
+  });
+  Object.defineProperty(set, sandboxSetBrand, {
+    enumerable: false,
+    value: true
+  });
+  return Object.freeze(set);
+}
+function createSandboxRegex(source, flags = "", lastIndex = 0) {
+  const regex = { kind: "regex", source, flags, lastIndex };
+  Object.defineProperties(regex, {
+    [sandboxRegexBrand]: { value: true },
+    [sandboxRegexPattern]: { value: parseRegex(source, flags) }
+  });
+  return Object.seal(regex);
+}
+function getSandboxRegexPattern(regex) {
+  return regex[sandboxRegexPattern];
+}
+function isSandboxClosure(value) {
+  return typeof value === "object" && value !== null && sandboxClosureBrand in value;
+}
+function isSandboxMap(value) {
+  return typeof value === "object" && value !== null && sandboxMapBrand in value;
+}
+function isSandboxPromise(value) {
+  return typeof value === "object" && value !== null && sandboxPromiseBrand in value;
+}
+function isSandboxSet(value) {
+  return typeof value === "object" && value !== null && sandboxSetBrand in value;
+}
+function isSandboxGenerator(value) {
+  return typeof value === "object" && value !== null && sandboxGeneratorBrand in value;
+}
+function isSandboxRegex(value) {
+  return typeof value === "object" && value !== null && sandboxRegexBrand in value;
+}
+function deepCopyToSandbox(value) {
+  return copyToSandbox(value, {
+    seen: /* @__PURE__ */ new WeakMap()
+  });
+}
+function cloneSandboxValue(value) {
+  return copyToSandbox(
+    value,
+    {
+      seen: /* @__PURE__ */ new WeakMap()
+    },
+    "<root>",
+    true
+  );
+}
+function allocateProducedSandboxValue(value, budget) {
+  allocateSandboxValue2(value, budget, /* @__PURE__ */ new WeakSet());
+  return value;
+}
+function measureSandboxData(values, options = {}) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  let usage = 0;
+  const visit = (value) => {
+    if (typeof value === "string") {
+      usage += value.length;
+      return;
+    }
+    if (typeof value !== "object" || value === null) return;
+    if (seen.has(value)) return;
+    seen.add(value);
+    usage += 1;
+    if (Array.isArray(value)) {
+      usage += value.length;
+      for (const entry of value) visit(entry);
+      return;
+    }
+    if (isSandboxMap(value)) {
+      usage += value.entries.size;
+      for (const [key3, entry] of value.entries) {
+        visit(key3);
+        visit(entry);
+      }
+      return;
+    }
+    if (isSandboxSet(value)) {
+      usage += value.values.size;
+      for (const entry of value.values) visit(entry);
+      return;
+    }
+    if (isSandboxClosure(value)) {
+      if (options.ignoreClosures) return;
+      if (value.properties !== void 0) visit(value.properties);
+      if (!options.ignoreClosureCaptures)
+        for (const retained of value[sandboxRetainedValues]?.() ?? []) visit(retained);
+      return;
+    }
+    if (isSandboxGenerator(value)) {
+      const snapshot2 = value.channel.snapshot();
+      usage += snapshot2.sent.length;
+      for (const completion of snapshot2.sent) visit(completion.value);
+      return;
+    }
+    if (isSandboxPromise(value)) return;
+    if (isSandboxRegex(value)) {
+      usage += value.source.length + value.flags.length;
+      return;
+    }
+    const entries = isSandboxArguments(value) ? getSandboxArgumentEntries(value) : Object.entries(value);
+    usage += entries.length;
+    for (const [key3, entry] of entries) {
+      usage += key3.length;
+      visit(entry);
+    }
+  };
+  for (const value of values) visit(value);
+  return usage;
+}
+function deepCopyFromSandbox(value, options = {}) {
+  return copyFromSandbox(
+    value,
+    {
+      seen: /* @__PURE__ */ new WeakMap()
+    },
+    "<root>",
+    options
+  );
+}
+function copyToSandbox(value, state, path189 = "<root>", cloneSandboxCollections = false, depth = 0) {
+  assertSandboxDataDepth(depth);
+  if (isSandboxPrimitive(value)) {
+    return value;
+  }
+  if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxRegex(value) || isSandboxPromise(value)) {
+    return value;
+  }
+  if (isSandboxMap(value)) {
+    if (!cloneSandboxCollections) return value;
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = createSandboxMap();
+    state.seen.set(value, copy);
+    for (const [key3, entry] of value.entries) {
+      copy.entries.set(
+        copyToSandbox(key3, state, `${path189}.<key>`, true, depth + 1),
+        copyToSandbox(entry, state, `${path189}.<value>`, true, depth + 1)
+      );
+    }
+    return copy;
+  }
+  if (isSandboxSet(value)) {
+    if (!cloneSandboxCollections) return value;
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = createSandboxSet();
+    state.seen.set(value, copy);
+    for (const entry of value.values) {
+      copy.values.add(copyToSandbox(entry, state, `${path189}.<value>`, true, depth + 1));
+    }
+    return copy;
+  }
+  if (isHostPromise(value)) {
+    const promise = Promise.resolve(value).then(
+      (resolved) => copyToSandbox(resolved, { seen: /* @__PURE__ */ new WeakMap() }),
+      (reason) => Promise.reject(copyToSandbox(reason, { seen: /* @__PURE__ */ new WeakMap() }))
+    );
+    const sandboxPromise = createSandboxPromise(promise);
+    const span = getBoundOtelSpan(value);
+    if (span !== void 0) {
+      bindOtelSpan(promise, span);
+      bindOtelSpan(sandboxPromise, span);
+    }
+    return sandboxPromise;
+  }
+  if (value instanceof Map) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const copy = createSandboxMap();
+    state.seen.set(value, copy);
+    for (const [key3, entry] of value) {
+      copy.entries.set(
+        copyToSandbox(key3, state, `${path189}.<key>`, cloneSandboxCollections, depth + 1),
+        copyToSandbox(entry, state, `${path189}.<value>`, cloneSandboxCollections, depth + 1)
+      );
+    }
+    return copy;
+  }
+  if (value instanceof Set) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const copy = createSandboxSet();
+    state.seen.set(value, copy);
+    for (const entry of value) {
+      copy.values.add(
+        copyToSandbox(entry, state, `${path189}.<value>`, cloneSandboxCollections, depth + 1)
+      );
+    }
+    return copy;
+  }
+  if (isPlainArray(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const copy = new Array(value.length);
+    state.seen.set(value, copy);
+    for (const entry of getEnumerableArrayEntries(value, path189)) {
+      defineOwnDataProperty(
+        copy,
+        entry.key,
+        copyToSandbox(
+          entry.value,
+          state,
+          joinArrayPath(path189, entry.key),
+          cloneSandboxCollections,
+          depth + 1
+        )
+      );
+    }
+    return copy;
+  }
+  if (isSandboxArguments(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = createSandboxArguments([]);
+    state.seen.set(value, copy);
+    copySandboxArgumentProperties(
+      value,
+      copy,
+      (entry, key3) => copyToSandbox(entry, state, joinPath(path189, key3), cloneSandboxCollections, depth + 1)
+    );
+    return copy;
+  }
+  if (isPlainObject10(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const copy = createPlainObject(true);
+    state.seen.set(value, copy);
+    for (const entry of getEnumerableObjectEntries(value, path189)) {
+      defineOwnDataProperty(
+        copy,
+        entry.key,
+        copyToSandbox(
+          entry.value,
+          state,
+          joinPath(path189, entry.key),
+          cloneSandboxCollections,
+          depth + 1
+        )
+      );
+    }
+    return copy;
+  }
+  throw new TypeError(`Unsupported sandbox value at ${path189}: ${describeValue(value)}`);
+}
+function copyFromSandbox(value, state, path189 = "<root>", options, depth = 0) {
+  assertSandboxDataDepth(depth);
+  if (isSandboxPrimitive(value)) {
+    return value;
+  }
+  if (isSandboxClosure(value)) {
+    if (options.wrapClosure === void 0) {
+      throw new TypeError(
+        "Sandbox closures cannot cross into host values without an explicit wrapper."
+      );
+    }
+    const existing = state.seen.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const wrapped = options.wrapClosure(value);
+    state.seen.set(value, wrapped);
+    return wrapped;
+  }
+  if (isSandboxPromise(value)) {
+    observeSandboxPromise(value);
+    return value.promise.then(
+      (resolved) => copyFromSandbox(resolved, { seen: /* @__PURE__ */ new WeakMap() }, "<root>", options),
+      (reason) => Promise.reject(
+        reason instanceof SandboxError ? reason : copyFromSandbox(reason, { seen: /* @__PURE__ */ new WeakMap() }, "<root>", options)
+      )
+    );
+  }
+  if (isSandboxGenerator(value)) {
+    throw new TypeError("Sandbox generators cannot cross into host values.");
+  }
+  if (isSandboxRegex(value)) {
+    const regex = new RegExp(value.source, value.flags);
+    regex.lastIndex = value.lastIndex;
+    return regex;
+  }
+  if (isSandboxMap(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const copy = /* @__PURE__ */ new Map();
+    state.seen.set(value, copy);
+    for (const [key3, entry] of value.entries) {
+      copy.set(
+        copyFromSandbox(key3, state, `${path189}.<key>`, options, depth + 1),
+        copyFromSandbox(entry, state, `${path189}.<value>`, options, depth + 1)
+      );
+    }
+    return copy;
+  }
+  if (isSandboxSet(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const copy = /* @__PURE__ */ new Set();
+    state.seen.set(value, copy);
+    for (const entry of value.values) {
+      copy.add(copyFromSandbox(entry, state, `${path189}.<value>`, options, depth + 1));
+    }
+    return copy;
+  }
+  if (isPlainArray(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const copy = new Array(value.length);
+    state.seen.set(value, copy);
+    for (const entry of getEnumerableArrayEntries(value, path189)) {
+      defineOwnDataProperty(
+        copy,
+        entry.key,
+        copyFromSandbox(entry.value, state, joinArrayPath(path189, entry.key), options, depth + 1)
+      );
+    }
+    return copy;
+  }
+  if (isSandboxArguments(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = createSandboxArguments([]);
+    state.seen.set(value, copy);
+    copySandboxArgumentProperties(
+      value,
+      copy,
+      (entry, key3) => copyFromSandbox(entry, state, joinPath(path189, key3), options, depth + 1)
+    );
+    return copy;
+  }
+  if (isPlainObject10(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const copy = createPlainObject(Object.getPrototypeOf(value) === null);
+    state.seen.set(value, copy);
+    for (const entry of getEnumerableObjectEntries(value, path189)) {
+      defineOwnDataProperty(
+        copy,
+        entry.key,
+        copyFromSandbox(entry.value, state, joinPath(path189, entry.key), options, depth + 1)
+      );
+    }
+    return copy;
+  }
+  throw new TypeError(`Unsupported sandbox value at ${path189}: ${describeValue(value)}`);
+}
+function isSandboxPrimitive(value) {
+  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isHostPromise(value) {
+  return value instanceof Promise;
+}
+function allocateSandboxValue2(value, budget, seen) {
+  if (typeof value === "string") {
+    budget.allocateString(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    budget.allocateArrayLength(value.length);
+    for (const entry of value) {
+      allocateSandboxValue2(entry, budget, seen);
+    }
+    return;
+  }
+  if (isSandboxMap(value)) {
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    budget.allocateCollectionEntries(value.entries.size);
+    for (const [key3, entry] of value.entries) {
+      allocateSandboxValue2(key3, budget, seen);
+      allocateSandboxValue2(entry, budget, seen);
+    }
+    return;
+  }
+  if (isSandboxSet(value)) {
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    budget.allocateCollectionEntries(value.values.size);
+    for (const entry of value.values) {
+      allocateSandboxValue2(entry, budget, seen);
+    }
+    return;
+  }
+  if (typeof value !== "object" || value === null || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value)) {
+    return;
+  }
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  const entries = isSandboxArguments(value) ? getSandboxArgumentEntries(value).map(([, entry]) => entry) : Object.values(value);
+  for (const entry of entries) {
+    allocateSandboxValue2(entry, budget, seen);
+  }
+}
+function isPlainObject10(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype;
+}
+function createPlainObject(useNullPrototype) {
+  return useNullPrototype ? /* @__PURE__ */ Object.create(null) : {};
+}
+function defineOwnDataProperty(target, key3, value) {
+  Object.defineProperty(target, key3, {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value
+  });
+}
+function getEnumerableObjectEntries(value, path189) {
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const entries = [];
+  for (const [key3, descriptor] of Object.entries(descriptors)) {
+    if (!descriptor.enumerable) {
+      continue;
+    }
+    if ("get" in descriptor || "set" in descriptor) {
+      throw new TypeError(`Unsupported sandbox value at ${joinPath(path189, key3)}: accessor property`);
+    }
+    entries.push({
+      key: key3,
+      value: descriptor.value
+    });
+  }
+  return entries;
+}
+function getEnumerableArrayEntries(value, path189) {
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const entries = [];
+  for (const [key3, descriptor] of Object.entries(descriptors)) {
+    if (key3 === "length" || !descriptor.enumerable) {
+      continue;
+    }
+    if ("get" in descriptor || "set" in descriptor) {
+      throw new TypeError(
+        `Unsupported sandbox value at ${joinArrayPath(path189, key3)}: accessor property`
+      );
+    }
+    entries.push({
+      key: key3,
+      value: descriptor.value
+    });
+  }
+  return entries;
+}
+function isArrayIndexKey(value) {
+  if (value === "") {
+    return false;
+  }
+  const index = Number(value);
+  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === value;
+}
+function describeValue(value) {
+  if (typeof value === "function") {
+    return "function";
+  }
+  if (typeof value === "bigint" || typeof value === "symbol") {
+    return typeof value;
+  }
+  if (typeof value === "object" && value !== null) {
+    return value.constructor?.name ?? "Object";
+  }
+  return typeof value;
+}
+function joinPath(path189, key3) {
+  return path189 === "<root>" ? `<root>.${key3}` : `${path189}.${key3}`;
+}
+function joinArrayPath(path189, key3) {
+  return isArrayIndexKey(key3) ? `${path189}[${key3}]` : joinPath(path189, key3);
+}
+var sandboxClosureBrand, sandboxGeneratorBrand, sandboxMapBrand, sandboxPromiseBrand, sandboxRegexBrand, sandboxRegexPattern, sandboxSetBrand, sandboxRetainedValues;
+var init_values = __esm({
+  "packages/safejs/src/interp/values.ts"() {
+    "use strict";
+    init_otel2();
+    init_budget2();
+    init_promise_tracker();
+    init_promise_replay();
+    init_cancel2();
+    init_parse5();
+    init_graph_depth();
+    init_arguments();
+    init_arguments();
+    sandboxClosureBrand = /* @__PURE__ */ Symbol("SandboxClosure");
+    sandboxGeneratorBrand = /* @__PURE__ */ Symbol("SandboxGenerator");
+    sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
+    sandboxPromiseBrand = /* @__PURE__ */ Symbol("SandboxPromise");
+    sandboxRegexBrand = /* @__PURE__ */ Symbol("SandboxRegex");
+    sandboxRegexPattern = /* @__PURE__ */ Symbol("SandboxRegexPattern");
+    sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
+    sandboxRetainedValues = /* @__PURE__ */ Symbol("SandboxRetainedValues");
+  }
+});
+
+// packages/safejs/src/interp/globals/math.ts
+function createMathGlobals(options = {}) {
+  const random = options.random ?? Math.random;
+  const mathObject = {
+    E: Math.E,
+    LN2: Math.LN2,
+    LN10: Math.LN10,
+    LOG2E: Math.LOG2E,
+    LOG10E: Math.LOG10E,
+    PI: Math.PI,
+    SQRT1_2: Math.SQRT1_2,
+    SQRT2: Math.SQRT2,
+    random: createSandboxClosure({ sandbox: true, call: () => random(), name: "random" })
+  };
+  for (const [name, method] of Object.entries(mathMethods)) {
+    mathObject[name] = createSandboxClosure({
+      sandbox: true,
+      call: (args) => Reflect.apply(method, Math, args),
+      name
+    });
+  }
+  return {
+    Infinity: Infinity,
+    Math: mathObject,
+    NaN: Number.NaN
+  };
+}
+function createSeededRandom(seed) {
+  let state = normalizeSeed(seed);
+  return {
+    next: () => {
+      state = Math.imul(state, 1664525) + 1013904223 >>> 0;
+      return state / 4294967296;
+    },
+    snapshot: () => state,
+    restore: (nextState) => {
+      state = normalizeSeed(nextState);
+    }
+  };
+}
+function normalizeSeed(seed) {
+  if (!Number.isFinite(seed)) {
+    throw new TypeError("Seeded random requires a finite numeric seed.");
+  }
+  return Math.trunc(seed) >>> 0;
+}
+var mathMethods;
+var init_math = __esm({
+  "packages/safejs/src/interp/globals/math.ts"() {
+    "use strict";
+    init_values();
+    mathMethods = {
+      abs: Math.abs,
+      acos: Math.acos,
+      acosh: Math.acosh,
+      asin: Math.asin,
+      asinh: Math.asinh,
+      atan: Math.atan,
+      atan2: Math.atan2,
+      atanh: Math.atanh,
+      ceil: Math.ceil,
+      cbrt: Math.cbrt,
+      clz32: Math.clz32,
+      cos: Math.cos,
+      cosh: Math.cosh,
+      exp: Math.exp,
+      expm1: Math.expm1,
+      floor: Math.floor,
+      fround: Math.fround,
+      hypot: Math.hypot,
+      imul: Math.imul,
+      log: Math.log,
+      log1p: Math.log1p,
+      log10: Math.log10,
+      log2: Math.log2,
+      max: Math.max,
+      min: Math.min,
+      pow: Math.pow,
+      round: Math.round,
+      sign: Math.sign,
+      sin: Math.sin,
+      sinh: Math.sinh,
+      sqrt: Math.sqrt,
+      tan: Math.tan,
+      tanh: Math.tanh,
+      trunc: Math.trunc
+    };
+  }
+});
+
+// packages/safejs/src/random.ts
+import { randomInt } from "node:crypto";
+function createReplayableRandom(options = {}) {
+  const snapshot2 = options.snapshot;
+  const saved = snapshot2?.random;
+  let initialState = options.seed;
+  if (saved !== void 0) {
+    const hasLoopState = typeof snapshot2?.loopIterations === "object" && snapshot2.loopIterations !== null && Object.keys(snapshot2.loopIterations).length > 0;
+    const replaysFromStart = snapshot2?.replay !== void 0 || Array.isArray(snapshot2?.pendingAwaits) && snapshot2.pendingAwaits.length > 0 && !hasLoopState;
+    initialState = replaysFromStart ? saved.initialState ?? saved.seed : saved.resumeState ?? saved.state;
+  }
+  const generator = createSeededRandom(initialState ?? randomInt(4294967296));
+  return { seed: saved?.seed ?? generator.snapshot(), ...generator };
+}
+var init_random = __esm({
+  "packages/safejs/src/random.ts"() {
+    "use strict";
+    init_math();
+  }
+});
+
+// packages/safejs/src/restore.ts
+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);
+  }
+  return snapshot2;
+}
+var SnapshotMismatchError;
+var init_restore = __esm({
+  "packages/safejs/src/restore.ts"() {
+    "use strict";
+    init_hash();
+    init_shape();
+    init_validation();
+    init_dump_format();
+    init_running_state();
+    SnapshotMismatchError = class extends Error {
+      actualHash;
+      expectedHash;
+      constructor(expectedHash, actualHash) {
+        super(
+          `source changed since snapshot was taken (hash ${expectedHash} expected, got ${actualHash}); pass --reset to discard`
+        );
+        this.name = "SnapshotMismatchError";
+        this.actualHash = actualHash;
+        this.expectedHash = expectedHash;
+        replaceErrorStack(this);
+      }
+    };
   }
 });
 
@@ -141001,6 +141540,7 @@ function createInterpretedClosure(node, context, evaluateNode3) {
     return isConstructResult(result) ? result : thisValue;
   } : void 0;
   return createSandboxClosure({
+    sandbox: true,
     ...node.async ? { async: true } : {},
     ...node.type === "FunctionDeclaration" || node.type === "FunctionExpression" ? node.id === void 0 ? {} : { name: node.id.name } : {},
     ...construct === void 0 ? {} : { construct },
@@ -141016,30 +141556,42 @@ function createInterpretedClosure(node, context, evaluateNode3) {
       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 }
-      );
+      const promise = new Promise((resolve17, reject) => {
+        runAsyncPrefix(async () => {
+          try {
+            const value = await executeClosure(
+              node,
+              args,
+              callContext?.thisValue,
+              { ...invocationContext, onSuspend: completePrefix },
+              evaluateNode3
+            );
+            resolve17(
+              isSandboxPromise(value) || getThenable(value) !== void 0 ? awaitSandboxValue(
+                createSandboxPromise(resolveSandboxValue(value, { budget: context.budget }), {
+                  trackReplay: false
+                }),
+                context.signal,
+                context.budget
+              ) : allocateProducedSandboxValue(value, context.budget)
+            );
+          } catch (error3) {
+            reject(error3);
+          } finally {
+            completePrefix();
+          }
+        }).catch((error3) => {
+          reject(error3);
+          completePrefix();
+        });
+      });
+      return createSandboxPromise(promise, { synchronousPrefix });
     }
   });
 }
 function createGeneratorClosure(node, context, evaluateNode3) {
   return createSandboxClosure({
+    sandbox: true,
     ...node.id === void 0 ? {} : { name: node.id.name },
     retainedValues: () => context.scope.retainedValues(),
     call: async (args, callContext) => {
@@ -141098,7 +141650,7 @@ async function evaluateAwaitExpression(node, context, evaluateNode3) {
     return {
       kind: "normal",
       hasValue: true,
-      value: await suspendJob(awaitSandboxValue(argument.value, context.signal))
+      value: await suspendJob(awaitSandboxValue(argument.value, context.signal, context.budget))
     };
   } finally {
     leaveAwait();
@@ -141193,10 +141745,12 @@ function getParameterBindingNames(pattern) {
   }
 }
 function normalizeClosureResult(result, budget) {
-  if (isSandboxPromise(result)) {
+  if (isSandboxPromise(result) && (result.synchronousPrefix !== void 0 || result.hostCall !== void 0)) {
     return result;
   }
-  return createSandboxPromise(resolveSandboxValue(result, { budget }));
+  return createSandboxPromise(resolveSandboxValue(result, { budget }), {
+    ...isSandboxPromise(result) ? { synchronousPrefix: Promise.resolve() } : {}
+  });
 }
 var init_async = __esm({
   "packages/safejs/src/interp/async.ts"() {
@@ -141239,8 +141793,10 @@ function wrapCallerInjectedFunction(name, value, options, state) {
   const callable = value;
   return createSandboxClosure({
     ...isAsyncFunction(callable) ? { async: true } : {},
+    cancellationSignal: options.signal,
     call: (args, context) => {
       try {
+        if (options.signal?.aborted) throw readAbortReason2(options.signal);
         const stackFrames = context?.stack ?? [];
         const callbacks = {
           journal: options.hostCalls,
@@ -141394,16 +141950,16 @@ function executeHostCall(record2, restored, invoke2, stackFrames, options, span,
       }
     })();
     void promise.catch(() => void 0);
-    return createSandboxPromise(promise);
+    return createSandboxPromise(promise, { hostCall: record2, hostCallJournal: hostCalls });
   }
   if (replayed !== void 0) {
     restoreReplayedHostState(record2, replayed, onReplay);
-    if (record2.asynchronous) return createReplayedHostCallResult(replayed);
+    if (record2.asynchronous) return createReplayedHostCallResult(replayed, record2, hostCalls);
     if (replayed.status === "rejected") throw replayed.reason;
     return replayed.value;
   }
   if (restored && record2.policy === "read-side-effect" && record2.lifecycle === "consumed" && record2.outcome !== void 0) {
-    return createReplayedHostCallResult(record2.outcome);
+    return createReplayedHostCallResult(record2.outcome, record2, hostCalls);
   }
   if (restored && record2.policy === "read-side-effect" && record2.lifecycle === "settled" && record2.outcome !== void 0) {
     return createHostCallPromise(record2, Promise.resolve(record2.outcome), hostCalls);
@@ -141492,10 +142048,10 @@ function restoreReplayedHostState(record2, outcome, onReplay) {
     throw error3;
   }
 }
-function createReplayedHostCallResult(outcome) {
+function createReplayedHostCallResult(outcome, record2, hostCalls) {
   const promise = outcome.status === "fulfilled" ? Promise.resolve(outcome.value) : Promise.reject(outcome.reason);
   promise.catch(() => void 0);
-  return createSandboxPromise(promise);
+  return createSandboxPromise(promise, { hostCall: record2, hostCallJournal: hostCalls });
 }
 function createHostCallPromise(record2, outcomePromise, hostCalls) {
   const promise = outcomePromise.then((outcome) => {
@@ -141984,16 +142540,19 @@ function createConsoleJsonGlobals(options) {
   return {
     JSON: {
       parse: createSandboxClosure({
+        sandbox: true,
         call: async ([text5]) => parseJson4(text5, options.budget),
         name: "parse"
       }),
       stringify: createSandboxClosure({
+        sandbox: true,
         call: async ([value, replacer, indent]) => stringifyJson4(value, replacer, indent, options.budget),
         name: "stringify"
       })
     },
     console: options.hostCalls === void 0 ? {
       error: createSandboxClosure({
+        sandbox: true,
         call: async (args) => {
           sink.error(...args.map((value) => deepCopyFromSandbox(value)));
           return void 0;
@@ -142001,6 +142560,7 @@ function createConsoleJsonGlobals(options) {
         name: "error"
       }),
       log: createSandboxClosure({
+        sandbox: true,
         call: async (args) => {
           sink.log(...args.map((value) => deepCopyFromSandbox(value)));
           return void 0;
@@ -142256,79 +142816,10 @@ var init_console_json = __esm({
   }
 });
 
-// packages/safejs/src/interp/iteration.ts
-function getSandboxIterator(value) {
-  if (isSandboxGenerator(value)) {
-    return generatorIterator(value);
-  }
-  if (typeof value === "string") {
-    return syncIterator(value[Symbol.iterator]());
-  }
-  if (isSandboxMap(value)) {
-    return syncIterator(
-      Array.from(value.entries, ([key3, entry]) => [key3, entry])[Symbol.iterator]()
-    );
-  }
-  if (isSandboxSet(value)) {
-    return syncIterator(value.values[Symbol.iterator]());
-  }
-  if (typeof value !== "object" && typeof value !== "function" || value === null) {
-    return void 0;
-  }
-  const iteratorMethod = value[Symbol.iterator];
-  if (typeof iteratorMethod !== "function") {
-    return void 0;
-  }
-  return syncIterator(Reflect.apply(iteratorMethod, value, []));
-}
-function generatorIterator(generator) {
-  const invoke2 = async (method, value) => {
-    const leaveRunning = enterRunningState(generator);
-    generator.state = "running";
-    try {
-      const result = await generator.channel[method](value);
-      generator.state = result.done ? "done" : "suspended";
-      return result;
-    } catch (error3) {
-      generator.state = "done";
-      throw error3;
-    } finally {
-      leaveRunning();
-    }
-  };
-  return {
-    generator: true,
-    next: (value) => invoke2("next", value),
-    return: (value) => invoke2("return", value),
-    throw: (error3) => invoke2("throw", error3)
-  };
-}
-function syncIterator(iterator) {
-  const invoke2 = async (method, value) => {
-    const leaveRunning = enterRunningState(iterator);
-    try {
-      return await iterator[method](value);
-    } finally {
-      leaveRunning();
-    }
-  };
-  return {
-    next: (value) => invoke2("next", value),
-    ...typeof iterator.return === "function" ? { return: (value) => invoke2("return", value) } : {},
-    ...typeof iterator.throw === "function" ? { throw: (error3) => invoke2("throw", error3) } : {}
-  };
-}
-var init_iteration = __esm({
-  "packages/safejs/src/interp/iteration.ts"() {
-    "use strict";
-    init_values();
-    init_running_state();
-  }
-});
-
 // packages/safejs/src/interp/globals/collections.ts
 function createCollectionGlobals(options) {
   const mapConstructor = createSandboxClosure({
+    sandbox: true,
     call: () => {
       throw new TypeError("Constructor Map requires 'new'.");
     },
@@ -142342,6 +142833,7 @@ function createCollectionGlobals(options) {
     name: "Map"
   });
   const setConstructor = createSandboxClosure({
+    sandbox: true,
     call: () => {
       throw new TypeError("Constructor Set requires 'new'.");
     },
@@ -142462,11 +142954,7 @@ function isSandboxErrorConstructor(value) {
 }
 function createErrorConstructor(name, budget) {
   const call = (args, context) => createSubsetError(name, args, context?.stack ?? [], budget);
-  const closure = createSandboxClosure({
-    call,
-    construct: call,
-    name
-  });
+  const closure = createSandboxClosure({ sandbox: true, call, construct: call, name });
   errorConstructorNames.set(closure, name);
   return closure;
 }
@@ -142509,7 +142997,7 @@ var init_error = __esm({
 function createRegexGlobals() {
   const construct = (args) => createSandboxRegex(String(args[0] ?? ""), String(args[1] ?? ""));
   return {
-    RegExp: createSandboxClosure({ name: "RegExp", call: construct, construct })
+    RegExp: createSandboxClosure({ sandbox: true, name: "RegExp", call: construct, construct })
   };
 }
 var init_regex = __esm({
@@ -142523,22 +143011,27 @@ var init_regex = __esm({
 function createMiscGlobals(options) {
   return {
     structuredClone: createSandboxClosure({
+      sandbox: true,
       call: ([value]) => structuredCloneSandboxValue(value, options.budget),
       name: "structuredClone"
     }),
     parseInt: createSandboxClosure({
+      sandbox: true,
       call: (args) => Reflect.apply(globalThis.parseInt, globalThis, [...args]),
       name: "parseInt"
     }),
     parseFloat: createSandboxClosure({
+      sandbox: true,
       call: (args) => Reflect.apply(globalThis.parseFloat, globalThis, [...args]),
       name: "parseFloat"
     }),
     isNaN: createSandboxClosure({
+      sandbox: true,
       call: ([value]) => globalThis.isNaN(value),
       name: "isNaN"
     }),
     isFinite: createSandboxClosure({
+      sandbox: true,
       call: ([value]) => globalThis.isFinite(value),
       name: "isFinite"
     })
@@ -142588,30 +143081,37 @@ function createObjectArrayGlobals(options) {
   return {
     Object: {
       keys: createSandboxClosure({
+        sandbox: true,
         call: ([value]) => budgetSandboxValue2(getOwnEnumerableKeys(value), options.budget),
         name: "keys"
       }),
       values: createSandboxClosure({
+        sandbox: true,
         call: ([value]) => budgetSandboxValue2(getOwnEnumerableValues(value), options.budget),
         name: "values"
       }),
       entries: createSandboxClosure({
+        sandbox: true,
         call: ([value]) => budgetSandboxValue2(getOwnEnumerableEntries(value), options.budget),
         name: "entries"
       }),
       hasOwn: createSandboxClosure({
+        sandbox: true,
         call: ([value, key3]) => Reflect.apply(Object.hasOwn, Object, [value, key3]),
         name: "hasOwn"
       }),
       is: createSandboxClosure({
+        sandbox: true,
         call: ([left, right]) => Reflect.apply(Object.is, Object, [left, right]),
         name: "is"
       }),
       fromEntries: createSandboxClosure({
+        sandbox: true,
         call: ([value]) => budgetSandboxValue2(Reflect.apply(Object.fromEntries, Object, [value]), options.budget),
         name: "fromEntries"
       }),
       freeze: createSandboxClosure({
+        sandbox: true,
         call: ([value]) => {
           if (typeof value === "object" && value !== null) {
             Object.freeze(value);
@@ -142621,76 +143121,93 @@ function createObjectArrayGlobals(options) {
         name: "freeze"
       }),
       isFrozen: createSandboxClosure({
+        sandbox: true,
         call: ([value]) => Object.isFrozen(value),
         name: "isFrozen"
       }),
       assign: createSandboxClosure({
+        sandbox: true,
         call: ([target, ...sources]) => assignSandboxValues(target, sources),
         name: "assign"
       })
     },
     Array: createSandboxClosure({
+      sandbox: true,
       call: (args) => createArrayFromConstructorArgs(args, options.budget),
       construct: (args) => createArrayFromConstructorArgs(args, options.budget),
       name: "Array",
       properties: {
         isArray: createSandboxClosure({
+          sandbox: true,
           call: ([value]) => Array.isArray(value),
           name: "isArray"
         }),
         from: createSandboxClosure({
+          sandbox: true,
           call: (args) => arrayFromSandboxValues(args, options.budget),
           name: "from"
         }),
         of: createSandboxClosure({
+          sandbox: true,
           call: (args) => budgetSandboxValue2(Reflect.apply(Array.of, Array, [...args]), options.budget),
           name: "of"
         })
       }
     }),
     String: createSandboxClosure({
+      sandbox: true,
       call: ([value]) => options.budget.allocateString(String(value)),
       name: "String",
       properties: {
         raw: createSandboxClosure({
+          sandbox: true,
           call: (args) => stringRaw(args, options.budget),
           name: "raw"
         }),
         fromCharCode: createSandboxClosure({
+          sandbox: true,
           call: (args) => options.budget.allocateString(Reflect.apply(String.fromCharCode, String, [...args])),
           name: "fromCharCode"
         }),
         fromCodePoint: createSandboxClosure({
+          sandbox: true,
           call: (args) => options.budget.allocateString(Reflect.apply(String.fromCodePoint, String, [...args])),
           name: "fromCodePoint"
         })
       }
     }),
     Number: createSandboxClosure({
+      sandbox: true,
       call: ([value]) => Number(value),
       name: "Number",
       properties: {
         isFinite: createSandboxClosure({
+          sandbox: true,
           call: ([value]) => typeof value === "number" && Number.isFinite(value),
           name: "isFinite"
         }),
         isNaN: createSandboxClosure({
+          sandbox: true,
           call: ([value]) => typeof value === "number" && Number.isNaN(value),
           name: "isNaN"
         }),
         isInteger: createSandboxClosure({
+          sandbox: true,
           call: ([value]) => typeof value === "number" && Number.isInteger(value),
           name: "isInteger"
         }),
         parseInt: createSandboxClosure({
+          sandbox: true,
           call: (args) => Reflect.apply(Number.parseInt, Number, [...args]),
           name: "parseInt"
         }),
         parseFloat: createSandboxClosure({
+          sandbox: true,
           call: (args) => Reflect.apply(Number.parseFloat, Number, [...args]),
           name: "parseFloat"
         }),
         isSafeInteger: createSandboxClosure({
+          sandbox: true,
           call: ([value]) => typeof value === "number" && Number.isSafeInteger(value),
           name: "isSafeInteger"
         }),
@@ -142702,6 +143219,7 @@ function createObjectArrayGlobals(options) {
       }
     }),
     Boolean: createSandboxClosure({
+      sandbox: true,
       call: ([value]) => Boolean(value),
       name: "Boolean"
     })
@@ -142831,6 +143349,7 @@ function getArrayMember(value, property, options) {
   }
   if (isArrayMethodName(property)) {
     return createSandboxClosure({
+      sandbox: true,
       name: `Array#${property}`,
       call: (args, context) => callArrayMethod(value, property, args, options, context?.stack ?? [])
     });
@@ -143408,6 +143927,7 @@ function getFunctionMember(target, property, options) {
     return void 0;
   }
   return createSandboxClosure({
+    sandbox: true,
     name: `Function#${property}`,
     call: (args, context) => callFunctionMethod(target, property, args, options, context?.stack ?? [])
   });
@@ -143417,6 +143937,25 @@ function isFunctionMethodName(property) {
 }
 function callFunctionMethod(target, methodName, args, options, stack) {
   const thisValue = args[0];
+  if (methodName === "bind") {
+    const boundArgs = args.slice(1);
+    return createSandboxClosure({
+      sandbox: true,
+      name: `bound ${target.name ?? ""}`,
+      boundTarget: target,
+      retainedValues: () => [target, thisValue, ...boundArgs],
+      call: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], thisValue),
+      ...target.construct === void 0 ? {} : {
+        construct: (callArgs, context) => options.callClosure(
+          target,
+          [...boundArgs, ...callArgs],
+          context?.stack ?? [],
+          void 0,
+          true
+        )
+      }
+    });
+  }
   if (methodName === "call") {
     return options.callClosure(target, args.slice(1), stack, thisValue);
   }
@@ -143434,7 +143973,7 @@ var init_function = __esm({
   "packages/safejs/src/interp/methods/function.ts"() {
     "use strict";
     init_values();
-    functionMethodNames = /* @__PURE__ */ new Set(["apply", "call"]);
+    functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call"]);
   }
 });
 
@@ -143450,6 +143989,7 @@ function getMapMember(target, property, options) {
     return void 0;
   }
   return createSandboxClosure({
+    sandbox: true,
     call: (args, context) => callMapMethod(target, property, args, options, context?.stack ?? []),
     name: property
   });
@@ -143528,6 +144068,7 @@ function getNumberMember(value, property, budget) {
     return void 0;
   }
   return createSandboxClosure({
+    sandbox: true,
     name: `Number#${property}`,
     call: (args) => callNumberMethod(value, property, args, budget)
   });
@@ -143604,6 +144145,7 @@ function getGeneratorMember(target, property, budget) {
     return void 0;
   }
   return createSandboxClosure({
+    sandbox: true,
     name: property,
     call: async ([value]) => {
       const iterator = getSandboxIterator(target);
@@ -143873,6 +144415,7 @@ function getRegexMember(target, property) {
     return void 0;
   }
   return createSandboxClosure({
+    sandbox: true,
     name: `RegExp#${property}`,
     call: (args) => callRegexMethod(target, property, args)
   });
@@ -143926,6 +144469,7 @@ function getStringMember(value, property, budget) {
     return void 0;
   }
   return createSandboxClosure({
+    sandbox: true,
     name: `String#${property}`,
     call: (args) => callStringMethod(value, property, args, budget)
   });
@@ -144222,6 +144766,7 @@ function getSetMember(target, property, options) {
     return void 0;
   }
   return createSandboxClosure({
+    sandbox: true,
     call: (args, context) => callSetMethod(target, property, args, options, context?.stack ?? []),
     name: property
   });
@@ -144557,7 +145102,10 @@ async function interpret(node, options = {}) {
     generatorYield: options.generatorYield,
     resumeTarget: { nodeId: options.snapshot?.resumeNodeId }
   };
-  const evaluation = await jobs.run(() => evaluateNode2(node, context));
+  const evaluation = await withCancellationSignal(
+    options.signal,
+    () => jobs.run(() => evaluateNode2(node, context))
+  );
   await jobs.drain();
   const snapshot2 = scope.snapshot();
   reconcileDataBudget(
@@ -144609,6 +145157,7 @@ async function interpret(node, options = {}) {
 async function evaluateNode2(node, context) {
   const replayWait = promiseReplayContext.getStore()?.beforeNode(node.nodeId);
   if (replayWait !== void 0) await suspendJob(replayWait);
+  assertPromiseExecutionAllowed();
   context.budget.visitNode();
   context.stats.nodeVisits += 1;
   if (node.nodeId !== void 0 && context.resumeTarget?.nodeId === node.nodeId) {
@@ -146059,7 +146608,7 @@ async function evaluateMemberExpression(node, context) {
     return {
       kind: "normal",
       hasValue: true,
-      value: getPromiseMember(member.object, member.property, context.budget)
+      value: getPromiseMember(member.property, context.budget)
     };
   }
   if (isSandboxRegex(member.object)) {
@@ -146096,36 +146645,27 @@ async function evaluateNewExpression(node, context) {
     return callee;
   }
   const name = getConstructorName(node.callee);
-  if (!isSandboxClosure(callee.value) || callee.value.construct === void 0) {
-    throw new TypeError(`${name} is not a constructor.`);
-  }
   const args = await evaluateCallArguments(node.arguments, context);
   if (!args.ok) {
     return args.result;
   }
-  const stack = [...context.callStack, formatStackFrame(node, callee.value.name ?? name)];
-  const leaveCall = context.budget.enterCall();
-  try {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: await wrapHostResult(
-        callee.value.construct(args.value, {
-          stack,
-          thisValue: void 0,
-          span: node.span
-        }),
-        stack
-      )
-    };
-  } catch (error3) {
-    if (isFatalSandboxError(error3)) {
-      throw error3;
-    }
-    throw captureException(error3, stack);
-  } finally {
-    leaveCall();
+  if (!isSandboxClosure(callee.value) || callee.value.construct === void 0) {
+    throw new TypeError(`${name} is not a constructor.`);
   }
+  const stack = [...context.callStack, formatStackFrame(node, callee.value.name ?? name)];
+  return {
+    kind: "normal",
+    hasValue: true,
+    value: await invokeSandboxClosure(
+      callee.value,
+      args.value,
+      context,
+      stack,
+      node.span,
+      void 0,
+      true
+    )
+  };
 }
 function getConstructorName(callee) {
   if (callee.type === "Identifier") {
@@ -146330,7 +146870,7 @@ async function evaluateMemberCallExpression(node, context) {
   if (isSandboxPromise(member.object)) {
     return evaluateResolvedCallExpression(
       node,
-      getPromiseMember(member.object, member.property, context.budget),
+      getPromiseMember(member.property, context.budget),
       context,
       member.object
     );
@@ -146541,6 +147081,8 @@ function applyBinaryOperator(node, left, right, context) {
     case ">>>":
       return toNumber(left) >>> toNumber(right);
     case "instanceof":
+      while (isSandboxClosure(right) && right.boundTarget !== void 0) right = right.boundTarget;
+      if (isSandboxPromiseConstructor(right)) return isSandboxPromise(left);
       if (isSandboxMapConstructor(right) && isSandboxMap(left)) {
         return true;
       }
@@ -146846,13 +147388,15 @@ function createSetMethodOptions(context) {
 }
 function createFunctionMethodOptions(context) {
   return {
-    callClosure: (closure, args, stack, thisValue) => invokeSandboxClosure(closure, args, context, stack, void 0, thisValue)
+    callClosure: (closure, args, stack, thisValue, construct) => invokeSandboxClosure(closure, args, context, stack, void 0, thisValue, construct)
   };
 }
-async function invokeSandboxClosure(callee, args, context, stack, span, thisValue = void 0) {
+async function invokeSandboxClosure(callee, args, context, stack, span, thisValue = void 0, construct = false) {
   const leaveCall = context.budget.enterCall();
   try {
-    const result = Reflect.apply(callee.call, void 0, [
+    const invoke2 = construct ? callee.construct : callee.call;
+    if (invoke2 === void 0) throw new TypeError("Value is not a constructor.");
+    const result = Reflect.apply(invoke2, void 0, [
       args,
       {
         stack,
@@ -146863,7 +147407,7 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
     if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) {
       await result.synchronousPrefix;
     }
-    return callee.async === true ? normalizeClosureResult(wrapHostResult(result, stack), context.budget) : await wrapHostResult(result, stack);
+    return !construct && callee.async === true ? normalizeClosureResult(wrapHostResult(result, stack), context.budget) : await wrapHostResult(result, stack);
   } catch (error3) {
     if (isFatalSandboxError(error3)) {
       throw error3;
@@ -147018,7 +147562,9 @@ var init_interpreter = __esm({
   "packages/safejs/src/interp/interpreter.ts"() {
     "use strict";
     init_promise_replay();
+    init_promise_tracker();
     init_jobs4();
+    init_cancel2();
     init_shape();
     init_async();
     init_host_call();
@@ -148423,7 +148969,7 @@ var init_find_exported = __esm({
 });
 
 // packages/safejs/src/modules/agent.ts
-import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage7 } from "node:async_hooks";
 function createSpawnUsageAccumulator() {
   let inputTokens = 0;
   let outputTokens = 0;
@@ -149269,7 +149815,7 @@ var init_agent3 = __esm({
     init_parallel();
     init_types4();
     init_otel2();
-    activeUsageAccumulator = new AsyncLocalStorage6();
+    activeUsageAccumulator = new AsyncLocalStorage7();
     oneAttemptRetryOptions = {
       maxAttempts: 1,
       backoffMs: 0,
@@ -154211,7 +154757,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "5.0.3",
+      version: "6.0.0",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",