@poe-platform/safe-js 0.1.426 → 0.1.428

package/dist/safe-js/chunks/{chunk-V3XJABDF.js → chunk-KHHM7HUO.js}

@@ -3315,12 +3315,16 @@ var Parser = class {
       span: createSpan2(start.start, this.previousToken().end)
     };
   }
-  parseStatement() {
+  parseStatement(allowResourceDeclaration = true) {
     const emptyStatement = this.parseEmptyStatement();
     if (emptyStatement !== void 0) {
       return emptyStatement;
     }
     const token = this.currentToken();
+    if (this.resourceDeclarationHint() !== void 0) {
+      if (!allowResourceDeclaration) throw unexpectedTokenError(token);
+      return this.parseResourceDeclaration();
+    }
     if (token.type === "identifier" && this.peekToken(1).type === "punctuator" && this.peekToken(1).value === ":") {
       this.index += 2;
       return this.parseLabeledStatement([token.value], token);
@@ -3455,7 +3459,7 @@ var Parser = class {
       if (token.type === "keyword" && token.value === "while") return this.parseWhileStatement(labels);
       if (token.type === "keyword" && token.value === "do") return this.parseDoWhileStatement(labels);
       if (token.type === "punctuator" && token.value === "{") return { ...this.parseBlockStatement(), labels };
-      if (["let", "const", "class", "function", "import", "export"].includes(token.value) || this.isAsyncFunctionDeclarationStart())
+      if (["let", "const", "class", "function", "import", "export"].includes(token.value) || this.isAsyncFunctionDeclarationStart() || this.resourceDeclarationHint() !== void 0)
         throw new DisallowedSyntaxError("labeled declaration", firstLabelToken.start);
       const statement = this.parseStatement();
       if (statement.type === "ImportDeclaration" || statement.type === "ExportDefaultDeclaration" || statement.type === "ExportNamedDeclaration")
@@ -3478,14 +3482,14 @@ var Parser = class {
       this.expectPunctuator("(");
       const test = this.parseExpression({ allowSequence: true }).node;
       this.expectPunctuator(")");
-      const consequent = this.parseStatement();
+      const consequent = this.parseStatement(false);
       if (consequent.type !== "BlockStatement") {
         while (this.currentToken().type === "punctuator" && this.currentToken().value === ";" && this.peekToken(1).type === "keyword" && this.peekToken(1).value === "else") {
           this.index += 1;
         }
       }
       const elseToken = this.consumeKeyword("else");
-      const alternate = elseToken === void 0 ? void 0 : this.parseStatement();
+      const alternate = elseToken === void 0 ? void 0 : this.parseStatement(false);
       return {
         type: "IfStatement",
         test,
@@ -3576,11 +3580,12 @@ var Parser = class {
         throw new Error("for await requires an of loop.");
       }
       if (iterationOperator?.value === "in") {
+        if (this.resourceDeclarationHint() !== void 0) throw unexpectedTokenError(this.currentToken());
         const left = this.parseForOfLeft();
         this.expectKeyword("in");
         const right = this.parseExpression().node;
         this.expectPunctuator(")");
-        const body2 = this.withLoopContext(() => this.parseStatement());
+        const body2 = this.withLoopContext(() => this.parseStatement(false));
         return {
           type: "ForInStatement",
           left,
@@ -3595,7 +3600,7 @@ var Parser = class {
         this.expectKeyword("of");
         const right = this.parseExpression().node;
         this.expectPunctuator(")");
-        const body2 = this.withLoopContext(() => this.parseStatement());
+        const body2 = this.withLoopContext(() => this.parseStatement(false));
         return {
           type: "ForOfStatement",
           ...awaitToken === void 0 ? {} : { await: true },
@@ -3608,7 +3613,7 @@ var Parser = class {
       }
       let init;
       if (this.consumePunctuator(";") === void 0) {
-        init = (this.currentToken().type === "keyword" || this.currentToken().type === "identifier") && (this.currentToken().value === "const" || this.currentToken().value === "let" || this.currentToken().value === "var") ? this.parseVariableDeclaration() : this.parseExpression({ allowSequence: true }).node;
+        init = this.resourceDeclarationHint() !== void 0 ? this.parseResourceDeclaration() : (this.currentToken().type === "keyword" || this.currentToken().type === "identifier") && (this.currentToken().value === "const" || this.currentToken().value === "let" || this.currentToken().value === "var") ? this.parseVariableDeclaration() : this.parseExpression({ allowSequence: true }).node;
         this.expectPunctuator(";");
       }
       let test;
@@ -3618,7 +3623,7 @@ var Parser = class {
       }
       const update = this.currentToken().type === "punctuator" && this.currentToken().value === ")" ? void 0 : this.parseExpression({ allowSequence: true }).node;
       this.expectPunctuator(")");
-      const body = this.withLoopContext(() => this.parseStatement());
+      const body = this.withLoopContext(() => this.parseStatement(false));
       return {
         type: "ForStatement",
         init,
@@ -3631,6 +3636,9 @@ var Parser = class {
     });
   }
   parseForOfLeft() {
+    if (this.resourceDeclarationHint() !== void 0 && this.peekToken(1).value !== "of") {
+      return this.parseResourceDeclaration(true);
+    }
     if ((this.currentToken().type === "keyword" || this.currentToken().type === "identifier") && (this.currentToken().value === "const" || this.currentToken().value === "let" || this.currentToken().value === "var")) {
       return this.parseForOfDeclaration();
     }
@@ -3671,7 +3679,7 @@ var Parser = class {
     this.expectPunctuator("(");
     const test = this.parseExpression({ allowSequence: true }).node;
     this.expectPunctuator(")");
-    const body = this.withLoopContext(() => this.parseStatement());
+    const body = this.withLoopContext(() => this.parseStatement(false));
     return {
       type: "WhileStatement",
       test,
@@ -3682,7 +3690,7 @@ var Parser = class {
   }
   parseDoWhileStatement(labels) {
     const doToken = this.expectKeyword("do");
-    const body = this.withLoopContext(() => this.parseStatement());
+    const body = this.withLoopContext(() => this.parseStatement(false));
     this.expectKeyword("while");
     this.expectPunctuator("(");
     const test = this.parseExpression({ allowSequence: true }).node;
@@ -3877,6 +3885,35 @@ var Parser = class {
       span: createSpan2(kindToken.start, declarations[declarations.length - 1].span.end)
     };
   }
+  resourceDeclarationHint() {
+    const token = this.currentToken();
+    const offset = token.value === "await" && this.peekToken(1).value === "using" ? 1 : 0;
+    const using = offset === 0 ? token : this.peekToken(1);
+    const binding = this.peekToken(offset + 1);
+    if (using.value !== "using" || hasLineBreakBetween(using, binding) || !isIdentifierLikeToken(binding)) return void 0;
+    if (offset === 1 && hasLineBreakBetween(token, using)) throw unexpectedTokenError(using);
+    return offset === 1 ? "async" : "sync";
+  }
+  parseResourceDeclaration(iteration = false) {
+    const start = this.currentToken();
+    const disposal = this.resourceDeclarationHint();
+    if (disposal === "async") {
+      if (!this.lexicalContext.await || !["top-level", "async", "async-generator"].includes(this.functionContext)) {
+        throw unexpectedTokenError(start);
+      }
+      this.index++;
+    }
+    this.index++;
+    const declarations = [];
+    do {
+      const id = this.parseBindingIdentifier();
+      if (id.name === "let" || disposal === "async" && id.name === "await" || iteration && disposal === "sync" && id.name === "of") throw new Error(`Invalid resource binding '${id.name}'.`);
+      this.declarePatternBindings(id);
+      const init = iteration ? void 0 : (this.expectPunctuator("="), this.parseExpression().node);
+      declarations.push({ type: "VariableDeclarator", id, ...init === void 0 ? {} : { init }, span: createSpan2(id.span.start, init?.span.end ?? id.span.end) });
+    } while (!iteration && this.consumePunctuator(",") !== void 0);
+    return { type: "VariableDeclaration", kind: "const", disposal, declarations, span: createSpan2(start.start, declarations.at(-1).span.end) };
+  }
   parseFunctionDeclaration(defaultExport = false) {
     const asyncToken = this.consumeKeyword("async");
     const functionToken = this.expectKeyword("function");
@@ -5683,6 +5720,7 @@ var Parser = class {
   }
   shouldParseTopLevelStatement() {
     const token = this.currentToken();
+    if (this.resourceDeclarationHint() !== void 0) return true;
     if (this.isAsyncFunctionDeclarationStart()) {
       return true;
     }
@@ -7786,6 +7824,7 @@ var wellKnownSymbols = Object.freeze({
 // packages/safe-js/src/interp/intrinsics.ts
 var identities = /* @__PURE__ */ new WeakMap();
 var realms2 = /* @__PURE__ */ new WeakMap();
+var mutableBuiltinBindings = /* @__PURE__ */ new WeakMap();
 function registerBuiltinIdentities(budget, bindings) {
   let realm = realms2.get(budget);
   if (realm === void 0) realms2.set(budget, realm = /* @__PURE__ */ new Map());
@@ -9336,6 +9375,485 @@ function restoreRegexProperties(value, data, decode) {
 // packages/safe-js/src/snapshot/validation.ts
 import { types as types10 } from "node:util";
 
+// packages/safe-js/src/interp/promise-continuations.ts
+var thenableContinuations = /* @__PURE__ */ new WeakMap();
+var thenableStates = /* @__PURE__ */ new WeakMap();
+var thenableResolvers = /* @__PURE__ */ new WeakMap();
+var promiseCapabilityExecutors = /* @__PURE__ */ new WeakMap();
+var promiseAggregateHandlers = /* @__PURE__ */ new WeakMap();
+var promiseAggregateStates = /* @__PURE__ */ new WeakMap();
+var promiseAggregateEntries = /* @__PURE__ */ new WeakMap();
+var promiseAdoptions = /* @__PURE__ */ new WeakMap();
+var promiseAdoptionBridges = /* @__PURE__ */ new WeakMap();
+var promiseAdoptionResolvers = /* @__PURE__ */ new WeakMap();
+var promiseContinuations = /* @__PURE__ */ new WeakMap();
+var promiseReactionResults = /* @__PURE__ */ new WeakMap();
+var promiseProducers = /* @__PURE__ */ new WeakMap();
+function linkPromiseAggregateProducer(producer, aggregate) {
+  const continuation = promiseContinuations.get(producer);
+  if (continuation?.kind !== "reaction") return;
+  continuation.aggregate = aggregate;
+  let producers = promiseProducers.get(aggregate);
+  if (producers === void 0) promiseProducers.set(aggregate, producers = /* @__PURE__ */ new Set());
+  producers.add(producer);
+}
+function trackPromiseContinuation(promise, continuation) {
+  promiseContinuations.set(promise, continuation);
+  if (continuation.kind === "reaction") {
+    let results = promiseReactionResults.get(continuation.source);
+    if (results === void 0) promiseReactionResults.set(continuation.source, results = /* @__PURE__ */ new Set());
+    results.add(promise);
+    if (continuation.capability !== void 0) {
+      let producers = promiseProducers.get(continuation.capability.promise);
+      if (producers === void 0) promiseProducers.set(continuation.capability.promise, producers = /* @__PURE__ */ new Set());
+      producers.add(promise);
+    }
+  }
+  const release = () => {
+    promiseContinuations.delete(promise);
+    if (continuation.kind === "capability") delete continuation.resolution;
+    else {
+      const results = promiseReactionResults.get(continuation.source);
+      results?.delete(promise);
+      if (results?.size === 0) promiseReactionResults.delete(continuation.source);
+      if (continuation.capability !== void 0) {
+        const producers = promiseProducers.get(continuation.capability.promise);
+        producers?.delete(promise);
+        if (producers?.size === 0) promiseProducers.delete(continuation.capability.promise);
+      }
+      if (continuation.aggregate !== void 0) {
+        const producers = promiseProducers.get(continuation.aggregate);
+        producers?.delete(promise);
+        if (producers?.size === 0) promiseProducers.delete(continuation.aggregate);
+      }
+    }
+  };
+  promise.promise.then(release, release);
+}
+
+// packages/safe-js/src/interp/jobs.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+var activeJob = new AsyncLocalStorage3();
+var SandboxJobQueue = class {
+  running = false;
+  pending = [];
+  ready = [];
+  idle = [];
+  generation = 0;
+  bind(task) {
+    return activeJob.run({ queue: this, ownsExecution: false }, task);
+  }
+  acquire(job) {
+    return new Promise((resolve) => {
+      this.pending.push(() => {
+        this.running = true;
+        this.generation += 1;
+        job.ownsExecution = true;
+        resolve();
+      });
+      this.advance();
+    });
+  }
+  release(job) {
+    job.prefixParent = void 0;
+    if (!job.ownsExecution) return;
+    job.ownsExecution = false;
+    this.running = false;
+    this.advance();
+  }
+  async run(task) {
+    const job = { queue: this, ownsExecution: false };
+    await this.acquire(job);
+    return activeJob.run(job, async () => {
+      try {
+        return await task();
+      } finally {
+        this.release(job);
+      }
+    });
+  }
+  async drain() {
+    let idleTurns = 0;
+    while (idleTurns < 20) {
+      const generation = this.generation;
+      if (this.running) await new Promise((resolve) => this.idle.push(resolve));
+      await Promise.resolve();
+      idleTurns = generation === this.generation ? idleTurns + 1 : 0;
+    }
+  }
+  advance() {
+    if (this.running) return;
+    if (this.ready.length === 0 && this.pending.length > 0) {
+      const empty = this.ready;
+      this.ready = this.pending.reverse();
+      this.pending = empty;
+    }
+    const next = this.ready.pop();
+    if (next !== void 0) {
+      next();
+    } else {
+      for (const resolve of this.idle.splice(0)) resolve();
+    }
+  }
+};
+function runPromiseJob(task) {
+  const job = activeJob.getStore();
+  return job === void 0 ? Promise.resolve().then(task) : job.queue.run(task);
+}
+function createResumableJobContext() {
+  let frame;
+  return { run: (task) => {
+    const parent = activeJob.getStore();
+    if (parent === void 0) return task();
+    frame ??= { queue: parent.queue, ownsExecution: false };
+    for (let ancestor = parent; ancestor !== void 0; ancestor = ancestor.prefixParent) {
+      if (ancestor === frame) return activeJob.run(frame, task);
+    }
+    frame.queue = parent.queue;
+    frame.prefixParent = parent;
+    return activeJob.run(frame, task);
+  }, release: () => {
+    if (frame !== void 0) frame.queue.release(frame);
+  } };
+}
+function runAsyncPrefix(task) {
+  const parent = activeJob.getStore();
+  if (parent === void 0) return task();
+  let owner = parent;
+  while (owner !== void 0 && !owner.ownsExecution) owner = owner.prefixParent;
+  if (owner === void 0) return parent.queue.run(task);
+  const job = { queue: parent.queue, ownsExecution: false, prefixParent: parent };
+  return activeJob.run(job, async () => {
+    try {
+      return await task();
+    } finally {
+      job.queue.release(job);
+    }
+  });
+}
+async function suspendJob(pending) {
+  const job = activeJob.getStore();
+  if (job === void 0) return pending;
+  job.queue.release(job);
+  try {
+    return await pending;
+  } finally {
+    await job.queue.acquire(job);
+  }
+}
+
+// packages/safe-js/src/interp/async-function-driver.ts
+var asyncFunctionDrivers = /* @__PURE__ */ new WeakMap();
+var asyncFunctionHandlers = /* @__PURE__ */ new WeakMap();
+var asyncFunctionSignals = /* @__PURE__ */ new WeakMap();
+var abortReleases = /* @__PURE__ */ new WeakMap();
+function bindAsyncFunctionSignal(driver, signal, budget, context) {
+  abortReleases.get(driver)?.();
+  if (signal === void 0) asyncFunctionSignals.delete(driver);
+  else asyncFunctionSignals.set(driver, signal);
+  if (driver.phase !== "waiting") return;
+  const generation = driver.generation;
+  let notify;
+  const aborted = new Promise((resolve) => {
+    notify = resolve;
+  });
+  let active = true;
+  const abort = () => notify(signal?.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+  const release = () => {
+    active = false;
+    signal?.removeEventListener("abort", abort);
+    detachFatal?.();
+    if (abortReleases.get(driver) === release) abortReleases.delete(driver);
+  };
+  abortReleases.set(driver, release);
+  signal?.addEventListener("abort", abort, { once: true });
+  const detachFatal = onFatalPromiseRejection(notify);
+  void aborted.then((reason) => runPromiseJob(async () => {
+    if (!active || driver.phase !== "waiting" || driver.generation !== generation) return;
+    if (isFatalSandboxError(reason)) {
+      release();
+      driver.phase = "running";
+      await withFatalPromiseCleanup(async () => {
+        if (driver.generator?.state !== "done") await driver.generator?.channel.throw(reason);
+      });
+      throw reason;
+    }
+    const handler = createAsyncFunctionHandler(driver, "rejected", generation, budget, context);
+    await handler.call([createThrowCompletion(reason, budget, context?.stack ?? []).value], context);
+  })).catch((error) => {
+    release();
+    driver.phase = "done";
+    if (driver.generator !== void 0) driver.generator.state = "done";
+    const reject = pendingPromiseRejectors.get(driver.capability.promise);
+    if (reject === void 0) throw new TypeError("Missing async function rejection capability.");
+    reject(error);
+  });
+  if (signal?.aborted) abort();
+}
+function startAsyncFunction(initialize, budget, context, signal) {
+  let completePrefix;
+  let failPrefix;
+  const prefix = new Promise((resolve, reject) => {
+    completePrefix = resolve;
+    failPrefix = reject;
+  });
+  void prefix.catch(() => void 0);
+  const capability = createPendingPromiseCapability(budget, context, prefix);
+  const driver = { capability: { promise: capability.promise, resolve: capability.resolve, reject: capability.reject }, phase: "running", generation: 0 };
+  asyncFunctionDrivers.set(driver, driver);
+  bindAsyncFunctionSignal(driver, signal, budget, context);
+  void runAsyncPrefix(async () => {
+    try {
+      driver.generator = await initialize(completePrefix);
+      await advanceAsyncFunction(driver, "fulfilled", void 0, budget, context);
+    } catch (error) {
+      driver.phase = "done";
+      if (isFatalSandboxError(error)) throw error;
+      await capability.reject.call([createThrowCompletion(error, budget, context?.stack ?? []).value], context);
+    }
+  }).then(completePrefix, (error) => {
+    capability.rejectNative(error);
+    failPrefix(error);
+  });
+  return capability.promise;
+}
+function createAsyncFunctionHandler(driver, action, generation, budget, context) {
+  const handler = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "",
+    length: 1,
+    retainedValues: () => [driver],
+    call: async ([value]) => {
+      if (driver.phase !== "waiting" || driver.generation !== generation) return void 0;
+      abortReleases.get(driver)?.();
+      driver.phase = "running";
+      if (driver.generator?.state === "done") {
+        driver.phase = "done";
+        const settle = (action === "fulfilled" ? pendingPromiseFulfillers : pendingPromiseRejectors).get(driver.capability.promise);
+        if (settle === void 0) throw new TypeError("Missing async function settlement capability.");
+        settle(value);
+        return void 0;
+      }
+      await advanceAsyncFunction(driver, action, value, budget, context);
+      return void 0;
+    }
+  });
+  asyncFunctionHandlers.set(handler, { driver, action, generation });
+  return handler;
+}
+async function advanceAsyncFunction(driver, action, value, budget, context) {
+  const release = retainValues(budget, () => [driver]);
+  try {
+    const generator = driver.generator;
+    if (generator === void 0) throw new TypeError("Missing async function frame.");
+    generator.state = "running";
+    const result = await generator.channel[action === "fulfilled" ? "next" : "throw"](value);
+    if (result.done) {
+      generator.state = "done";
+      if (!requiresPromiseResolution(result.value, budget)) {
+        driver.phase = "done";
+        await driver.capability.resolve.call([result.value], context);
+        return;
+      }
+    } else {
+      generator.state = "suspended";
+    }
+    const prepared = result.value;
+    let awaited;
+    if (!result.done && isSandboxPromise(prepared)) awaited = prepared;
+    else {
+      const wrapper = promiseReplayContext.exit(() => createPendingPromiseCapability(budget, context));
+      await wrapper.resolve.call([prepared], context);
+      awaited = wrapper.promise;
+    }
+    driver.phase = "waiting";
+    driver.generation++;
+    bindAsyncFunctionSignal(driver, asyncFunctionSignals.get(driver), budget, context);
+    const reaction = promiseReplayContext.exit(() => createPendingPromiseCapability(budget, context));
+    attachPendingPromiseReaction(
+      awaited,
+      reaction,
+      createAsyncFunctionHandler(driver, "fulfilled", driver.generation, budget, context),
+      createAsyncFunctionHandler(driver, "rejected", driver.generation, budget, context),
+      budget,
+      context
+    );
+    linkPromiseAggregateProducer(reaction.promise, driver.capability.promise);
+  } catch (error) {
+    abortReleases.get(driver)?.();
+    driver.phase = "done";
+    if (driver.generator !== void 0) driver.generator.state = "done";
+    if (isFatalSandboxError(error)) throw error;
+    await driver.capability.reject.call([createThrowCompletion(error, budget, context?.stack ?? []).value], context);
+  } finally {
+    release();
+  }
+}
+
+// packages/safe-js/src/interp/async-generator-driver.ts
+var asyncGeneratorDrivers = /* @__PURE__ */ new WeakMap();
+var asyncGeneratorRequestOwners = /* @__PURE__ */ new WeakMap();
+var asyncGeneratorHandlers = /* @__PURE__ */ new WeakMap();
+var generatorSignals = /* @__PURE__ */ new WeakMap();
+var interruptReleases = /* @__PURE__ */ new WeakMap();
+function bindAsyncGeneratorSignal(generator, signal, budget, context) {
+  if (signal === void 0) generatorSignals.delete(generator);
+  else generatorSignals.set(generator, signal);
+  const driver = asyncGeneratorDrivers.get(generator);
+  if (driver === void 0) return;
+  interruptReleases.get(driver)?.();
+  if (driver.phase !== "waiting") return;
+  const generation = driver.generation;
+  let notify;
+  const interrupted = new Promise((resolve) => {
+    notify = resolve;
+  });
+  let active = true;
+  const abort = () => notify(signal?.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+  const release = () => {
+    active = false;
+    signal?.removeEventListener("abort", abort);
+    detachFatal?.();
+    if (interruptReleases.get(driver) === release) interruptReleases.delete(driver);
+  };
+  interruptReleases.set(driver, release);
+  signal?.addEventListener("abort", abort, { once: true });
+  const detachFatal = onFatalPromiseRejection(notify);
+  void interrupted.then((reason) => runPromiseJob(async () => {
+    if (!active || driver.phase !== "waiting" || driver.generation !== generation) return;
+    if (isFatalSandboxError(reason)) {
+      release();
+      driver.phase = "running";
+      await withFatalPromiseCleanup(async () => {
+        if (generator.state !== "done") await generator.channel.throw(reason, false);
+      });
+      throw reason;
+    }
+    const handler = createAsyncGeneratorHandler(driver, "rejected", generation, budget, context);
+    await handler.call([createThrowCompletion(reason, budget, context?.stack ?? []).value], context);
+  })).catch((error) => rejectGeneratorQueue(driver, error));
+  if (signal?.aborted) abort();
+}
+function enqueueAsyncGeneratorRequest(generator, method, value, budget, context) {
+  let driver = asyncGeneratorDrivers.get(generator);
+  if (driver === void 0) {
+    driver = { generator, requests: [], phase: "idle", suspension: "yield", awaitKind: "body", generation: 0 };
+    asyncGeneratorDrivers.set(generator, driver);
+    asyncGeneratorDrivers.set(driver, driver);
+  }
+  const startsRequest = driver.phase === "idle";
+  let completePrefix;
+  const prefix = startsRequest ? new Promise((resolve) => {
+    completePrefix = resolve;
+  }) : void 0;
+  const capability = createPendingPromiseCapability(budget, context, prefix);
+  driver.requests.push({ method, value, capability: { promise: capability.promise, resolve: capability.resolve, reject: capability.reject } });
+  asyncGeneratorRequestOwners.set(capability.promise, driver);
+  if (startsRequest) {
+    driver.phase = "running";
+    const active = driver;
+    void runAsyncPrefix(() => advanceAsyncGenerator(active, method, value, budget, context)).then(
+      () => completePrefix?.(),
+      (error) => {
+        rejectGeneratorQueue(active, error);
+        completePrefix?.();
+      }
+    );
+  }
+  return capability.promise;
+}
+function rejectGeneratorQueue(driver, error) {
+  interruptReleases.get(driver)?.();
+  driver.generator.state = "done";
+  driver.phase = "idle";
+  for (const request of driver.requests.splice(0)) {
+    asyncGeneratorRequestOwners.delete(request.capability.promise);
+    pendingPromiseRejectors.get(request.capability.promise)?.(error);
+  }
+}
+function createAsyncGeneratorHandler(driver, action, generation, budget, context, owner = driver.requests[0]?.capability.promise) {
+  if (owner === void 0) throw new TypeError("Missing async generator handler owner.");
+  const handler = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "",
+    length: 1,
+    retainedValues: () => [driver, owner],
+    call: async ([value]) => {
+      if (driver.phase !== "waiting" || driver.generation !== generation) return void 0;
+      interruptReleases.get(driver)?.();
+      driver.phase = "running";
+      if (driver.awaitKind === "return") await settleGeneratorRequest(driver, action, value, true, budget, context);
+      else await advanceAsyncGenerator(driver, action === "fulfilled" ? "next" : "throw", value, budget, context, false);
+      return void 0;
+    }
+  });
+  asyncGeneratorHandlers.set(handler, { driver, owner, action, generation });
+  return handler;
+}
+async function settleGeneratorRequest(driver, action, value, done, budget, context) {
+  const request = driver.requests[0];
+  if (request === void 0) throw new TypeError("Missing async generator request.");
+  if (action === "fulfilled") await request.capability.resolve.call([allocateProducedSandboxValue({ value, done }, budget)], context);
+  else await request.capability.reject.call([value], context);
+  driver.requests.shift();
+  asyncGeneratorRequestOwners.delete(request.capability.promise);
+  const next = driver.requests[0];
+  if (next === void 0) driver.phase = "idle";
+  else await advanceAsyncGenerator(driver, next.method, next.value, budget, context);
+}
+async function awaitGeneratorRequest(driver, value, kind, budget, context) {
+  let awaited;
+  if (kind === "body" && isSandboxPromise(value)) awaited = value;
+  else {
+    const wrapper = promiseReplayContext.exit(() => createPendingPromiseCapability(budget, context));
+    await wrapper.resolve.call([value], context);
+    awaited = wrapper.promise;
+  }
+  driver.phase = "waiting";
+  driver.awaitKind = kind;
+  driver.generation++;
+  const reaction = promiseReplayContext.exit(() => createPendingPromiseCapability(budget, context));
+  attachPendingPromiseReaction(
+    awaited,
+    reaction,
+    createAsyncGeneratorHandler(driver, "fulfilled", driver.generation, budget, context),
+    createAsyncGeneratorHandler(driver, "rejected", driver.generation, budget, context),
+    budget,
+    context
+  );
+  const request = driver.requests[0];
+  if (request === void 0) throw new TypeError("Missing async generator await owner.");
+  linkPromiseAggregateProducer(reaction.promise, request.capability.promise);
+  bindAsyncGeneratorSignal(driver.generator, generatorSignals.get(driver.generator), budget, context);
+}
+async function advanceAsyncGenerator(driver, method, value, budget, context, record4 = true) {
+  const release = retainValues(budget, () => [driver]);
+  const generator = driver.generator;
+  try {
+    driver.phase = "running";
+    const initial = generator.state;
+    generator.state = "running";
+    const result = await generator.channel[method](value, record4);
+    generator.state = result.done ? "done" : "suspended";
+    const produced = result.value;
+    if (!result.done && driver.suspension === "await") await awaitGeneratorRequest(driver, produced, "body", budget, context);
+    else if (result.done && (requiresPromiseResolution(produced, budget) || method === "return" && (initial === "start" || initial === "done")))
+      await awaitGeneratorRequest(driver, produced, "return", budget, context);
+    else await settleGeneratorRequest(driver, "fulfilled", produced, result.done === true, budget, context);
+  } catch (error) {
+    generator.state = "done";
+    if (isFatalSandboxError(error)) {
+      rejectGeneratorQueue(driver, error);
+      throw error;
+    }
+    await settleGeneratorRequest(driver, "rejected", createThrowCompletion(error, budget, context?.stack ?? []).value, true, budget, context);
+  } finally {
+    release();
+  }
+}
+
 // packages/safe-js/src/interp/running-state.ts
 var runningObjects = /* @__PURE__ */ new WeakSet();
 var lockedCollections = /* @__PURE__ */ new WeakSet();
@@ -9457,8 +9975,8 @@ function getRegExpIteratorMember(property, budget) {
 }
 
 // packages/safe-js/src/interp/cancel.ts
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
-var activeCancellation = new AsyncLocalStorage3();
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+var activeCancellation = new AsyncLocalStorage4();
 var sandboxPromises = /* @__PURE__ */ new WeakSet();
 var cancelableOutcomes = /* @__PURE__ */ new WeakMap();
 function withCancellationSignal(signal, task) {
@@ -9643,101 +10161,6 @@ function isPromiseLike(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
 
-// packages/safe-js/src/interp/jobs.ts
-import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
-var activeJob = new AsyncLocalStorage4();
-var SandboxJobQueue = class {
-  running = false;
-  pending = [];
-  ready = [];
-  idle = [];
-  generation = 0;
-  bind(task) {
-    return activeJob.run({ queue: this, ownsExecution: false }, task);
-  }
-  acquire(job) {
-    return new Promise((resolve) => {
-      this.pending.push(() => {
-        this.running = true;
-        this.generation += 1;
-        job.ownsExecution = true;
-        resolve();
-      });
-      this.advance();
-    });
-  }
-  release(job) {
-    job.prefixParent = void 0;
-    if (!job.ownsExecution) return;
-    job.ownsExecution = false;
-    this.running = false;
-    this.advance();
-  }
-  async run(task) {
-    const job = { queue: this, ownsExecution: false };
-    await this.acquire(job);
-    return activeJob.run(job, async () => {
-      try {
-        return await task();
-      } finally {
-        this.release(job);
-      }
-    });
-  }
-  async drain() {
-    let idleTurns = 0;
-    while (idleTurns < 20) {
-      const generation = this.generation;
-      if (this.running) await new Promise((resolve) => this.idle.push(resolve));
-      await Promise.resolve();
-      idleTurns = generation === this.generation ? idleTurns + 1 : 0;
-    }
-  }
-  advance() {
-    if (this.running) return;
-    if (this.ready.length === 0 && this.pending.length > 0) {
-      const empty = this.ready;
-      this.ready = this.pending.reverse();
-      this.pending = empty;
-    }
-    const next = this.ready.pop();
-    if (next !== void 0) {
-      next();
-    } else {
-      for (const resolve of this.idle.splice(0)) resolve();
-    }
-  }
-};
-function runPromiseJob(task) {
-  const job = activeJob.getStore();
-  return job === void 0 ? Promise.resolve().then(task) : job.queue.run(task);
-}
-function runAsyncPrefix(task) {
-  const parent = activeJob.getStore();
-  if (parent === void 0) return task();
-  let owner = parent;
-  while (owner !== void 0 && !owner.ownsExecution) owner = owner.prefixParent;
-  if (owner === void 0) return parent.queue.run(task);
-  const job = { queue: parent.queue, ownsExecution: false, prefixParent: parent };
-  return activeJob.run(job, async () => {
-    try {
-      return await task();
-    } finally {
-      job.queue.release(job);
-    }
-  });
-}
-async function suspendJob(pending) {
-  const job = activeJob.getStore();
-  if (job === void 0) return pending;
-  job.queue.release(job);
-  try {
-    return await pending;
-  } finally {
-    await job.queue.acquire(job);
-  }
-}
-
 // packages/safe-js/src/interp/iteration.ts
 function mapIteratorSnapshot(snapshot, map) {
   if (snapshot.kind === "unsupported") throw new TypeError("Host-owned iterator cannot be portably snapshotted.");
@@ -9808,15 +10231,25 @@ async function getSandboxIteratorFromMethod(value, factory, budget, context, asy
   return guestIterator(iterator, next, asyncProtocol, budget, context, signal);
 }
 function guestIterator(iterator, next, asyncProtocol, budget, context, signal) {
+  const resumeAwait = async (state, value) => {
+    if (state.kind !== "result") throw new TypeError("Invalid async iterator await state.");
+    const result = await value();
+    if (typeof result !== "object" && typeof result !== "function" || result === null)
+      throw new TypeError("Iterator result must be an object.");
+    return result;
+  };
   const invoke = async (operation, args) => {
     if (!isSandboxClosure(operation)) throw new TypeError("Iterator operation must be callable.");
     const returned = await invokeBuiltinClosure(operation, args, budget, context, iterator);
+    if (asyncProtocol && wrapper.awaitValue !== void 0)
+      return resumeAwait({ kind: "result" }, () => wrapper.awaitValue(returned, { kind: "result" }));
     const result = asyncProtocol ? await awaitSandboxValue(returned, signal, budget, context) : returned;
     if (typeof result !== "object" && typeof result !== "function" || result === null)
       throw new TypeError("Iterator result must be an object.");
     return result;
   };
-  return {
+  const wrapper = {
+    resumeAwait,
     ...asyncProtocol ? { asyncProtocol: true } : {},
     asynchronous: true,
     retainedValue: [iterator, next],
@@ -9830,6 +10263,7 @@ function guestIterator(iterator, next, asyncProtocol, budget, context, signal) {
       value: await context.getProperty(result, property)
     })
   };
+  return wrapper;
 }
 async function readIteratorResult(iterator, result, property) {
   return iterator.readResultProperty === void 0 ? { value: result[property] } : iterator.readResultProperty(result, property);
@@ -9888,6 +10322,16 @@ function nativeAsyncIterator(value, method, signal) {
   };
 }
 function asyncFromSyncIterator(iterator, budget, signal, context) {
+  const resumeAwait = async (state, value) => {
+    if (state.kind !== "value") throw new TypeError("Invalid async-from-sync await state.");
+    try {
+      return { done: state.done, value: await value() };
+    } catch (error) {
+      if (isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
+      if (state.closeOnReject) await closeIterator(iterator, true);
+      throw error;
+    }
+  };
   const invoke = async (method, args) => {
     const operation = iterator.getOperation === void 0 ? iterator[method] : await iterator.getOperation(method);
     if (operation === void 0) {
@@ -9904,6 +10348,10 @@ function asyncFromSyncIterator(iterator, budget, signal, context) {
     }
     const done = Boolean((await readIteratorResult(iterator, result, "done")).value);
     const resultValue = (await readIteratorResult(iterator, result, "value")).value;
+    if (wrapper.awaitValue !== void 0) {
+      const state = { kind: "value", done, closeOnReject: !done && method !== "return" };
+      return resumeAwait(state, () => wrapper.awaitValue(resultValue, state));
+    }
     try {
       return { done, value: await awaitSandboxValue(resultValue, signal, budget, context) };
     } catch (error) {
@@ -9912,7 +10360,8 @@ function asyncFromSyncIterator(iterator, budget, signal, context) {
       throw error;
     }
   };
-  return {
+  const wrapper = {
+    resumeAwait,
     asyncProtocol: true,
     snapshotIndex: iterator.snapshotIndex,
     snapshot: () => ({ kind: "async-from-sync", inner: iterator.snapshot?.() ?? { kind: "unsupported" } }),
@@ -9923,13 +10372,14 @@ function asyncFromSyncIterator(iterator, budget, signal, context) {
     return: (...args) => invoke("return", args),
     throw: (...args) => invoke("throw", args)
   };
+  return wrapper;
 }
-async function closeIterator(iterator, preserveThrow = false) {
+async function closeIterator(iterator, preserveThrow = false, awaitResult = suspendJob) {
   try {
     const close = iterator.getOperation === void 0 ? iterator.return : await iterator.getOperation("return");
     if (close === void 0) return;
     const returned = close();
-    const result = iterator.asyncProtocol ? await suspendJob(Promise.resolve(returned)) : iterator.generator || iterator.asynchronous ? await returned : returned;
+    const result = iterator.asyncProtocol ? iterator.awaitValue === void 0 ? await awaitResult(Promise.resolve(returned)) : await returned : iterator.generator || iterator.asynchronous ? await returned : returned;
     if (typeof result !== "object" && typeof result !== "function" || result === null) {
       throw new TypeError("Iterator return result must be an object.");
     }
@@ -10072,7 +10522,6 @@ function collectionIterator(collection, value) {
   adapter.snapshot = () => ({ kind: "builtin", value, index: adapter.snapshotIndex() });
   return adapter;
 }
-var asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
 function guestProtocolAdapter(value, budget, context, asyncProtocol, signal) {
   const bridge = {
     ...context,
@@ -10128,13 +10577,8 @@ function generatorObjectIterator(generator, budget, context) {
 function generatorIterator(generator, budget, context) {
   const invoke = async (method, value) => {
     const leaveRunning = enterRunningState(generator);
-    const initialState = generator.state;
     generator.state = "running";
     try {
-      if (generator.async && method === "return" && (initialState === "start" || initialState === "done")) {
-        if (initialState === "start") await generator.channel.return();
-        value = await awaitSandboxValue(value, void 0, budget, context);
-      }
       const result = await generator.channel[method](value);
       generator.state = result.done ? "done" : "suspended";
       return result;
@@ -10147,13 +10591,7 @@ function generatorIterator(generator, budget, context) {
   };
   const request = (method, value) => {
     if (!generator.async) return invoke(method, value);
-    const previous = asyncGeneratorRequests.get(generator) ?? Promise.resolve();
-    const result = previous.then(() => invoke(method, value));
-    asyncGeneratorRequests.set(
-      generator,
-      result.catch(() => void 0)
-    );
-    return result;
+    return enqueueAsyncGeneratorRequest(generator, method, value, budget ?? new Budget(), context).promise;
   };
   return {
     generator: true,
@@ -10194,67 +10632,13 @@ function syncIterator(iterator) {
 var promiseResolvingFunctions = /* @__PURE__ */ new WeakMap();
 var promiseResolverActions = /* @__PURE__ */ new WeakMap();
 
-// packages/safe-js/src/interp/promise-continuations.ts
-var thenableContinuations = /* @__PURE__ */ new WeakMap();
-var thenableStates = /* @__PURE__ */ new WeakMap();
-var thenableResolvers = /* @__PURE__ */ new WeakMap();
-var promiseCapabilityExecutors = /* @__PURE__ */ new WeakMap();
-var promiseAggregateHandlers = /* @__PURE__ */ new WeakMap();
-var promiseAggregateStates = /* @__PURE__ */ new WeakMap();
-var promiseAggregateEntries = /* @__PURE__ */ new WeakMap();
-var promiseAdoptions = /* @__PURE__ */ new WeakMap();
-var promiseAdoptionBridges = /* @__PURE__ */ new WeakMap();
-var promiseAdoptionResolvers = /* @__PURE__ */ new WeakMap();
-var promiseContinuations = /* @__PURE__ */ new WeakMap();
-var promiseReactionResults = /* @__PURE__ */ new WeakMap();
-var promiseProducers = /* @__PURE__ */ new WeakMap();
-function linkPromiseAggregateProducer(producer, aggregate) {
-  const continuation = promiseContinuations.get(producer);
-  if (continuation?.kind !== "reaction") return;
-  continuation.aggregate = aggregate;
-  let producers = promiseProducers.get(aggregate);
-  if (producers === void 0) promiseProducers.set(aggregate, producers = /* @__PURE__ */ new Set());
-  producers.add(producer);
-}
-function trackPromiseContinuation(promise, continuation) {
-  promiseContinuations.set(promise, continuation);
-  if (continuation.kind === "reaction") {
-    let results = promiseReactionResults.get(continuation.source);
-    if (results === void 0) promiseReactionResults.set(continuation.source, results = /* @__PURE__ */ new Set());
-    results.add(promise);
-    if (continuation.capability !== void 0) {
-      let producers = promiseProducers.get(continuation.capability.promise);
-      if (producers === void 0) promiseProducers.set(continuation.capability.promise, producers = /* @__PURE__ */ new Set());
-      producers.add(promise);
-    }
-  }
-  const release = () => {
-    promiseContinuations.delete(promise);
-    if (continuation.kind === "capability") delete continuation.resolution;
-    else {
-      const results = promiseReactionResults.get(continuation.source);
-      results?.delete(promise);
-      if (results?.size === 0) promiseReactionResults.delete(continuation.source);
-      if (continuation.capability !== void 0) {
-        const producers = promiseProducers.get(continuation.capability.promise);
-        producers?.delete(promise);
-        if (producers?.size === 0) promiseProducers.delete(continuation.capability.promise);
-      }
-      if (continuation.aggregate !== void 0) {
-        const producers = promiseProducers.get(continuation.aggregate);
-        producers?.delete(promise);
-        if (producers?.size === 0) promiseProducers.delete(continuation.aggregate);
-      }
-    }
-  };
-  promise.promise.then(release, release);
-}
-
 // packages/safe-js/src/interp/promise.ts
 var promiseConstructors = /* @__PURE__ */ new WeakSet();
 var intrinsicPromiseThenMethods = /* @__PURE__ */ new WeakSet();
 var intrinsicPromiseConstructors = /* @__PURE__ */ new WeakMap();
 var promisePrototypes2 = /* @__PURE__ */ new WeakMap();
+var pendingPromiseRejectors = /* @__PURE__ */ new WeakMap();
+var pendingPromiseFulfillers = /* @__PURE__ */ new WeakMap();
 function isSandboxPromiseConstructor(value) {
   return isSandboxClosure(value) && promiseConstructors.has(value);
 }
@@ -10268,6 +10652,8 @@ function createPendingPromiseCapability(budget, context, synchronousPrefix) {
     fulfill = resolve;
     reject = rejectPromise;
   }), { span: context?.span, synchronousPrefix });
+  pendingPromiseRejectors.set(promise, reject);
+  pendingPromiseFulfillers.set(promise, fulfill);
   const resolverState = { promise, settled: false };
   const continuation = { kind: "capability", state: resolverState };
   trackPromiseContinuation(promise, continuation);
@@ -10321,6 +10707,11 @@ function attachPendingPromiseReaction(source, capability, onFulfilled, onRejecte
     continuation.phase = "running";
     try {
       consumeSettledHostCall(source);
+      const asyncContinuation = isSandboxClosure(handler) ? asyncFunctionHandlers.get(handler) : void 0;
+      if (isSandboxClosure(handler) && asyncContinuation?.driver.generator?.state === "done") {
+        capability.fulfill(handler.call([value], context));
+        return;
+      }
       capability.fulfill(reactionCapability === void 0 ? runPromiseReaction(handler, value, status, budget, capability.promise, context) : runCapabilityReaction(handler, value, status, reactionCapability, budget, context));
     } catch (error) {
       capability.rejectNative(error);
@@ -10328,6 +10719,21 @@ function attachPendingPromiseReaction(source, capability, onFulfilled, onRejecte
   };
   source.promise.then((value) => react(onFulfilled, value, "fulfilled"), (reason) => react(onRejected, reason, "rejected"));
   trackPromiseContinuation(capability.promise, continuation);
+  const asyncHandler = isSandboxClosure(onRejected) ? asyncFunctionHandlers.get(onRejected) : void 0;
+  const generatorHandler = isSandboxClosure(onRejected) ? asyncGeneratorHandlers.get(onRejected) : void 0;
+  if (generatorHandler !== void 0) {
+    observeSandboxPromise(capability.promise, true);
+    void capability.promise.promise.catch((error) => rejectGeneratorQueue(generatorHandler.driver, error));
+  }
+  if (asyncHandler !== void 0) {
+    observeSandboxPromise(capability.promise, true);
+    void capability.promise.promise.catch((error) => {
+      asyncHandler.driver.phase = "done";
+      const reject = pendingPromiseRejectors.get(asyncHandler.driver.capability.promise);
+      if (reject === void 0) throw new TypeError("Missing async function rejection capability.");
+      reject(error);
+    });
+  }
 }
 function createPromiseGlobals(options) {
   promisePrototypes2.delete(options.budget);
@@ -11388,9 +11794,10 @@ var Scope = class _Scope {
     this.importMeta = importMeta;
     this.options = options;
     this.#restoredBindings = parent === void 0 ? new Map(Object.entries(restoredBindings ?? {})) : parent.#restoredBindings;
+    const mutable = mutableBuiltinBindings.get(bindings);
     for (const [name, value] of Object.entries(bindings)) {
       this.#bindings.set(name, {
-        kind: "const",
+        kind: mutable?.has(name) ? "var" : "const",
         value
       });
     }
@@ -11398,8 +11805,10 @@ var Scope = class _Scope {
   parent;
   importMeta;
   options;
+  resourceState;
   privateNames;
   #bindings = /* @__PURE__ */ new Map();
+  #replacedBindings = /* @__PURE__ */ new Set();
   #restoredBindings;
   #frameHydrated = false;
   child(bindings = {}, options = {}) {
@@ -11466,12 +11875,17 @@ var Scope = class _Scope {
   }
   retainedValues() {
     const values = this.parent?.retainedValues() ?? [];
+    if (this.resourceState !== void 0) values.push(this.resourceState);
     if (this.options.chargeData !== false) {
       if (this.importMeta !== void 0) values.push(this.importMeta);
       if (this.privateNames !== void 0) values.push(...this.privateNames.values());
       for (const binding of this.#bindings.values()) {
         if (binding.value !== uninitialized) values.push(binding.value);
       }
+    } else {
+      for (const binding of this.#replacedBindings) {
+        if (binding.value !== uninitialized) values.push(binding.value);
+      }
     }
     return values;
   }
@@ -11538,6 +11952,7 @@ var Scope = class _Scope {
       throw new TypeError(`Cannot assign to const binding '${name}'.`);
     }
     binding.value = value;
+    scope.trackReplacement(name, binding);
   }
   lookup(name) {
     const binding = this.#bindings.get(name);
@@ -11596,6 +12011,7 @@ var Scope = class _Scope {
       chargeData: this.options.chargeData !== false,
       bindings,
       cells,
+      ...this.resourceState === void 0 ? {} : { resourceState: this.resourceState },
       ...this.privateNames === void 0 ? {} : { privateNames: [...this.privateNames] },
       ...this.parent === void 0 ? { restoredBindings: [...this.#restoredBindings] } : {}
     };
@@ -11623,8 +12039,12 @@ var Scope = class _Scope {
     const restored = new Map(frame.restoredBindings ?? []);
     if (restored.size !== (frame.restoredBindings?.length ?? 0)) throw new TypeError("Duplicate restored binding.");
     this.importMeta = frame.importMeta;
+    this.resourceState = frame.resourceState;
     if (frame.privateNames !== void 0) this.privateNames = new Map(frame.privateNames);
-    for (const [name, binding] of bindings) this.#bindings.set(name, binding);
+    for (const [name, binding] of bindings) {
+      this.#bindings.set(name, binding);
+      this.trackReplacement(name, binding);
+    }
     if (this.parent === void 0)
       for (const [name, value] of restored) this.#restoredBindings.set(name, value);
     this.#frameHydrated = true;
@@ -11648,6 +12068,13 @@ var Scope = class _Scope {
     }
     return this.parent?.resolveScope(name);
   }
+  trackReplacement(name, binding) {
+    if (this.options.chargeData !== false || binding.kind === "const") return;
+    const value = binding.value;
+    if (typeof value === "object" && value !== null && getIntrinsicIdentity(value) === JSON.stringify([name]))
+      this.#replacedBindings.delete(binding);
+    else this.#replacedBindings.add(binding);
+  }
   requireInitializedBinding(name) {
     const scope = this.resolveScope(name);
     const binding = scope === void 0 ? void 0 : scope.#bindings.get(name);
@@ -11781,27 +12208,34 @@ function createGeneratorChannel(body) {
   let state = "unstarted";
   let signal = deferred();
   let resume;
-  const start = deferred();
+  const resumeJob = createResumableJobContext();
   const sent = [];
   let yieldNodeId;
-  const bodyPromise = start.promise.then(() => body(yieldValue));
-  void bodyPromise.then(
-    (value) => {
-      if (state === "done") {
-        return;
-      }
-      state = "done";
-      signal.resolve({ type: "complete", value });
-    },
-    (error) => {
-      if (state === "done") {
-        return;
-      }
-      state = "done";
-      signal.resolve({ type: "error", error });
+  function startBody() {
+    let bodyPromise;
+    try {
+      bodyPromise = body(yieldValue);
+    } catch (error) {
+      bodyPromise = Promise.reject(error);
     }
-  );
-  void bodyPromise.catch(() => void 0);
+    void bodyPromise.then(
+      (value) => {
+        if (state === "done") {
+          return;
+        }
+        state = "done";
+        signal.resolve({ type: "complete", value });
+      },
+      (error) => {
+        if (state === "done") {
+          return;
+        }
+        state = "done";
+        signal.resolve({ type: "error", error });
+      }
+    );
+    void bodyPromise.catch(() => void 0);
+  }
   async function yieldValue(value, nodeId) {
     resume = deferred();
     yieldNodeId = nodeId;
@@ -11809,7 +12243,7 @@ function createGeneratorChannel(body) {
     signal.resolve({ type: "yield", value });
     return resume.promise;
   }
-  async function deliver(completion) {
+  async function deliver(completion, record4) {
     const leaveRunning = enterRunningState(channelIdentity);
     try {
       if (state === "done") {
@@ -11831,11 +12265,11 @@ function createGeneratorChannel(body) {
           throw completion.value;
         }
         state = "running";
-        sent.push(completion);
-        start.resolve();
+        if (record4) sent.push(completion);
+        startBody();
       } else {
         state = "running";
-        sent.push(completion);
+        if (record4) sent.push(completion);
         signal = deferred();
         const pendingResume = resume;
         resume = void 0;
@@ -11851,13 +12285,14 @@ function createGeneratorChannel(body) {
       return { value: settled.value, done: true };
     } finally {
       leaveRunning();
+      resumeJob.release();
     }
   }
   const channelIdentity = {};
   return {
-    next: (value) => deliver({ type: "normal", value }),
-    return: (value) => deliver({ type: "return", value }),
-    throw: (error) => deliver({ type: "throw", value: error }),
+    next: (value, record4 = true) => resumeJob.run(() => deliver({ type: "normal", value }, record4)),
+    return: (value, record4 = true) => resumeJob.run(() => deliver({ type: "return", value }, record4)),
+    throw: (error, record4 = true) => resumeJob.run(() => deliver({ type: "throw", value: error }, record4)),
     snapshot: () => ({
       ...yieldNodeId === void 0 ? {} : { yieldNodeId },
       sent: sent.map((completion) => ({ ...completion }))
@@ -12313,18 +12748,56 @@ function createInterpretedClosure(node, context, evaluateNode2, homeObject, init
       };
       if (!node.async)
         return executeClosure(node, args, callContext?.thisValue, invocationContext, evaluateNode2);
-      return executeAsyncFunction(
-        (onSuspend) => executeClosure(
-          node,
-          args,
-          callContext?.thisValue,
-          { ...invocationContext, onSuspend },
-          evaluateNode2
-        ),
-        context.budget,
-        context.signal,
-        callContext
-      );
+      return startAsyncFunction(async (onSuspend) => {
+        const parent = invocationContext.compilation;
+        const operation = context.budget.acquireCompileOwner(false, parent?.owner);
+        const compilation = new CompileScope(operation.owner, parent);
+        const executionContext = { ...invocationContext, compilation, onSuspend };
+        let scope;
+        try {
+          scope = await createClosureScope(node, args, callContext?.thisValue, executionContext, evaluateNode2);
+        } catch (error) {
+          compilation.dispose();
+          operation.release();
+          throw error;
+        }
+        const channel = createGeneratorChannel(async (generatorYield) => {
+          try {
+            const result = await evaluateNode2(node.body, {
+              ...executionContext,
+              scope,
+              asyncFunction: true,
+              asyncGenerator: false,
+              asyncGeneratorFrame: void 0,
+              functionBody: node.body.type === "BlockStatement" ? node.body : void 0,
+              generatorBlockScopes: /* @__PURE__ */ new Map(),
+              generatorExpressionStates: /* @__PURE__ */ new Map(),
+              captureGeneratorScope: (current, blocks, completions, expressions) => {
+                origin.suspendedScope = current;
+                origin.blockScopes = blocks;
+                origin.finallyCompletions = completions;
+                origin.expressionStates = expressions;
+              },
+              generatorYield: (value2, nodeId) => {
+                generator.state = "suspended";
+                return generatorYield(value2, nodeId);
+              }
+            });
+            const value = "hasValue" in result && result.hasValue ? result.value : void 0;
+            reconcileCompiledValues(context.budget, [...scope.retainedValues(), value], compilation, parent, [value]);
+            if (result.kind === "error") throw result.error;
+            if (result.kind === "throw") throw result.value;
+            return value;
+          } finally {
+            compilation.dispose();
+            operation.release();
+          }
+        });
+        const generator = createSandboxGenerator(channel);
+        const origin = registerGeneratorOrigin(generator, node, scope, invocationContext);
+        origin.asyncFunction = true;
+        return generator;
+      }, context.budget, callContext, context.signal);
     }
   });
   registerClosureOrigin(closure, node, context);
@@ -12391,8 +12864,11 @@ function createGeneratorClosure(node, context, evaluateNode2, initializePrototyp
           const execute = async () => {
             const result = await evaluateNode2(node.body, {
               ...closureContext,
+              asyncFunction: false,
               functionBody: node.body,
               asyncGenerator: node.async,
+              asyncGeneratorFrame: node.async ? generator : void 0,
+              onSuspend: void 0,
               generatorBlockScopes: /* @__PURE__ */ new Map(),
               generatorExpressionStates: /* @__PURE__ */ new Map(),
               captureGeneratorScope: (suspendedScope, blocks, completions, expressions) => {
@@ -12414,11 +12890,12 @@ function createGeneratorClosure(node, context, evaluateNode2, initializePrototyp
               throw result.value;
             }
             const value = result.hasValue ? result.value : void 0;
-            return node.async ? awaitSandboxValue(value, context.signal, context.budget, createCoercionContext(context)) : value;
+            return value;
           };
-          return node.async ? runAsyncPrefix(execute) : execute();
+          return execute();
         });
         const generator = createSandboxGenerator(channel, { async: node.async });
+        if (node.async) bindAsyncGeneratorSignal(generator, context.signal, context.budget);
         if (prototype !== void 0) setSandboxPrototype(generator, prototype, context.budget);
         const origin = registerGeneratorOrigin(generator, node, scope, closureContext);
         return generator;
@@ -12441,11 +12918,17 @@ function isConstructResult(value) {
   return typeof value === "object" && value !== null;
 }
 async function evaluateAwaitExpression(node, context, evaluateNode2) {
+  if ((context.asyncFunction || context.asyncGeneratorFrame !== void 0) && context.generatorResume?.completed !== true && context.generatorResume?.yieldNodeId === node.nodeId) {
+    return { kind: "normal", hasValue: true, value: await suspendAsyncFunctionValue(void 0, node, context) };
+  }
   const replayState = context.captureReplayState?.();
   const argument = await evaluateNode2(node.argument, context);
   if (argument.kind !== "normal") {
     return argument;
   }
+  if (context.asyncFunction || context.asyncGeneratorFrame !== void 0) {
+    return { kind: "normal", hasValue: true, value: await suspendAsyncFunctionValue(argument.value, node, context, replayState, createCoercionContext(context)) };
+  }
   context.onSuspend?.();
   emitResumeBreakpoint(context, {
     kind: "await",
@@ -12465,6 +12948,51 @@ async function evaluateAwaitExpression(node, context, evaluateNode2) {
     leaveAwait();
   }
 }
+async function suspendAsyncFunctionValue(value, node, context, replayState = context.captureReplayState?.(), callContext, phase = "await") {
+  if (context.generatorYield === void 0 || node.nodeId === void 0) throw new TypeError("Missing async function suspension identity.");
+  let awaited;
+  if (isSandboxPromise(value)) {
+    const prepared = prepareAwaitedPromise(value, context.budget, callContext);
+    awaited = prepared instanceof Promise ? await prepared : prepared;
+  } else {
+    const wrapper = promiseReplayContext.exit(() => createPendingPromiseCapability(context.budget, callContext));
+    const prefix = wrapper.resolve.call([value], callContext);
+    if (prefix instanceof Promise) await prefix;
+    awaited = wrapper.promise;
+  }
+  if (context.signal?.aborted) {
+    observeSandboxPromise(awaited, true);
+    await awaitWithSignal(awaited.promise, context.signal);
+  }
+  context.captureGeneratorScope?.(context.scope, context.generatorBlockScopes, context.finallyCompletions, context.generatorExpressionStates);
+  context.onSuspend?.();
+  const otelSpan = getBoundOtelSpan(value);
+  emitResumeBreakpoint(context, {
+    kind: "await",
+    nodeId: node.nodeId,
+    span: node.span,
+    replayState,
+    ...otelSpan === void 0 ? {} : { otelSpan }
+  });
+  const leaveAwait = context.budget.enterAwait();
+  const generator = context.asyncGeneratorFrame;
+  const origin = generator === void 0 ? void 0 : getGeneratorOrigin(generator);
+  if (generator !== void 0) {
+    const driver = asyncGeneratorDrivers.get(generator);
+    if (driver === void 0 || origin === void 0) throw new TypeError("Missing async generator suspension owner.");
+    driver.suspension = "await";
+    origin.awaitPhase = phase;
+  }
+  try {
+    const completion = await context.generatorYield(awaited, node.nodeId);
+    if (context.generatorResume !== void 0) context.generatorResume.completed = true;
+    if (completion.type === "throw") throw completion.value;
+    return completion.value;
+  } finally {
+    if (origin !== void 0) origin.awaitPhase = void 0;
+    leaveAwait();
+  }
+}
 async function executeClosure(node, args, thisValue, context, evaluateNode2) {
   const parent = context.compilation;
   const operation = context.budget.acquireCompileOwner(false, parent?.owner);
@@ -12475,6 +13003,8 @@ async function executeClosure(node, args, thisValue, context, evaluateNode2) {
     const result = await evaluateNode2(node.body, {
       ...context,
       asyncGenerator: false,
+      asyncFunction: false,
+      asyncGeneratorFrame: void 0,
       functionBody: node.body.type === "BlockStatement" ? node.body : void 0,
       scope
     });
@@ -17486,10 +18016,56 @@ function captureAsyncResources(resources, encode) {
     method: encode(resource.method),
     receiver: encode(resource.receiver),
     args: resource.args.map(encode),
-    syncFallback: resource.syncFallback
+    syncFallback: resource.syncFallback,
+    ...resource.synchronous === void 0 ? {} : { synchronous: resource.synchronous }
   }));
 }
 function captureGuestHeapNode(value, encode) {
+  const generatorDriver = asyncGeneratorDrivers.get(value);
+  if (generatorDriver === value) {
+    if (generatorDriver.phase === "running") throw new SnapshotNotReadyError("Cannot snapshot an active async generator request.");
+    return {
+      kind: "async-generator-driver",
+      generator: encode(generatorDriver.generator),
+      phase: generatorDriver.phase,
+      suspension: generatorDriver.suspension,
+      awaitKind: generatorDriver.awaitKind,
+      generation: generatorDriver.generation,
+      requests: generatorDriver.requests.map((request) => ({
+        method: request.method,
+        value: encode(request.value),
+        capability: { promise: encode(request.capability.promise), resolve: encode(request.capability.resolve), reject: encode(request.capability.reject) }
+      }))
+    };
+  }
+  const generatorHandler = isSandboxClosure(value) ? asyncGeneratorHandlers.get(value) : void 0;
+  if (generatorHandler !== void 0) return {
+    kind: "async-generator-handler",
+    driver: encode(generatorHandler.driver),
+    owner: encode(generatorHandler.owner),
+    action: generatorHandler.action,
+    generation: generatorHandler.generation,
+    state: captureObjectState(value, encode)
+  };
+  const driver = asyncFunctionDrivers.get(value);
+  if (driver !== void 0) {
+    if (driver.phase === "running" || driver.generator === void 0) throw new SnapshotNotReadyError("Cannot snapshot an active async function.");
+    return {
+      kind: "async-function-driver",
+      generator: encode(driver.generator),
+      phase: driver.phase,
+      generation: driver.generation,
+      capability: { promise: encode(driver.capability.promise), resolve: encode(driver.capability.resolve), reject: encode(driver.capability.reject) }
+    };
+  }
+  const asyncHandler = isSandboxClosure(value) ? asyncFunctionHandlers.get(value) : void 0;
+  if (asyncHandler !== void 0) return {
+    kind: "async-function-handler",
+    driver: encode(asyncHandler.driver),
+    action: asyncHandler.action,
+    generation: asyncHandler.generation,
+    state: captureObjectState(value, encode)
+  };
   const asyncStack = asyncDisposableStackStates.get(value);
   if (asyncStack !== void 0) return {
     kind: "async-disposable-stack",
@@ -17609,6 +18185,8 @@ function captureGuestHeapNode(value, encode) {
     return { kind: "promise-resolver", promise: encode(resolver.promise), state: captureObjectState(value, encode) };
   }
   if (isSandboxPromise(value)) {
+    const generatorOwner = asyncGeneratorRequestOwners.get(value);
+    const ownerState = generatorOwner === void 0 ? {} : { generatorOwner: encode(generatorOwner) };
     const producerState = promiseProducers.has(value) ? { producers: [...promiseProducers.get(value)].map(encode) } : {};
     const settlement = promiseStates.get(value);
     if (settlement !== void 0 && settlement.status !== "pending")
@@ -17616,6 +18194,7 @@ function captureGuestHeapNode(value, encode) {
         kind: "guest-promise",
         status: settlement.status,
         value: encode(settlement.value),
+        ...ownerState,
         ...producerState,
         ...promiseReactionResults.has(value) ? { reactions: [...promiseReactionResults.get(value)].map(encode) } : {},
         state: captureObjectState(value, encode)
@@ -17623,6 +18202,8 @@ function captureGuestHeapNode(value, encode) {
     const continuation = promiseContinuations.get(value);
     if (unrepresentedPromiseContinuations.has(value))
       throw new TypeError("Cannot serialize host reference: unrepresented promise continuation.");
+    if (continuation?.kind === "reaction" && continuation.phase === "running")
+      throw new SnapshotNotReadyError("Cannot snapshot an active promise reaction.");
     if (continuation?.kind === "capability") {
       const thenable2 = thenableContinuations.get(value);
       if (continuation.state.settled && thenable2 !== void 0 && !thenable2.completed && thenable2.owner === value)
@@ -17630,6 +18211,7 @@ function captureGuestHeapNode(value, encode) {
           kind: "pending-promise",
           thenable: encode(thenable2),
           ...producerState,
+          ...ownerState,
           reactions: [...promiseReactionResults.get(value) ?? []].map(encode),
           state: captureObjectState(value, encode)
         };
@@ -17639,6 +18221,7 @@ function captureGuestHeapNode(value, encode) {
       return {
         kind: "pending-promise",
         ...continuation.state.settled ? { adoption: encode(adoption) } : {},
+        ...ownerState,
         ...producerState,
         reactions: [...promiseReactionResults.get(value) ?? []].map(encode),
         state: captureObjectState(value, encode)
@@ -17787,6 +18370,7 @@ function captureGuestHeapNode(value, encode) {
       functionBoundary: frame.functionBoundary,
       chargeData: frame.chargeData,
       bindings: frame.bindings,
+      ...frame.resourceState === void 0 ? {} : { resourceState: encode(frame.resourceState) },
       ...frame.privateNames === void 0 ? {} : { privateNames: frame.privateNames.map(([name, identity]) => [name, encode(identity)]) },
       cells: frame.cells.map((cell) => cell.initialized ? { ...cell, value: encode(cell.value) } : cell),
       ...frame.restoredBindings === void 0 ? {} : {
@@ -17803,6 +18387,9 @@ function captureGuestHeapNode(value, encode) {
       state: value.state,
       astNodeId: origin2.node.nodeId,
       async: value.async === true,
+      ...origin2.asyncFunction ? { asyncFunction: true } : {},
+      ...generatorDriver === void 0 ? {} : { driver: encode(generatorDriver) },
+      ...origin2.awaitPhase === void 0 ? {} : { awaitPhase: origin2.awaitPhase },
       objectState: captureObjectState(value, encode),
       scope: encode(origin2.scope),
       closureScope: encode(origin2.closureScope),
@@ -17826,9 +18413,13 @@ function captureGuestHeapNode(value, encode) {
         expressionStates: Object.fromEntries([...origin2.expressionStates].map(([id, expression]) => [
           String(id),
           expression.kind === "binary" ? { kind: "binary", left: encode(expression.left) } : expression.kind === "declaration" ? { ...expression } : expression.kind === "switch" ? { ...expression, value: encode(expression.value), scope: encode(expression.scope) } : expression.kind === "yield-delegate" ? {
-            ...expression,
+            kind: expression.kind,
+            async: expression.async,
             value: encode(expression.value),
             current: encode(expression.current),
+            ...expression.phase === void 0 ? {} : { phase: expression.phase },
+            ...expression.awaitState === void 0 ? {} : { awaitState: expression.awaitState },
+            ...expression.completion === void 0 ? {} : { completion: { ...expression.completion, value: encode(expression.completion.value) } },
             iterator: mapIteratorSnapshot("kind" in expression.iterator ? expression.iterator : expression.iterator.snapshot?.() ?? { kind: "unsupported" }, encode)
           } : expression.kind === "pattern-source" ? { kind: "pattern-source", value: encode(expression.value) } : expression.kind === "object-pattern" ? {
             kind: "object-pattern",
@@ -17849,10 +18440,15 @@ function captureGuestHeapNode(value, encode) {
             iterator: mapIteratorSnapshot("kind" in expression.iterator ? expression.iterator : expression.iterator.snapshot?.() ?? { kind: "unsupported" }, encode),
             ...Object.hasOwn(expression, "referenceObject") ? { referenceObject: encode(expression.referenceObject), referenceKey: encode(expression.referenceKey) } : {}
           } : expression.kind === "for-of-array" ? { ...expression, values: encode(expression.values), current: encode(expression.current), scope: encode(expression.scope) } : expression.kind === "for-of-iterator" ? {
-            ...expression,
+            kind: expression.kind,
+            phase: expression.phase,
+            async: expression.async,
+            index: expression.index,
+            ...expression.awaitState === void 0 ? {} : { awaitState: expression.awaitState },
             value: encode(expression.value),
             current: encode(expression.current),
             scope: encode(expression.scope),
+            ...expression.closeCompletion === void 0 ? {} : { closeCompletion: { ...expression.closeCompletion, value: encode(expression.closeCompletion.value) } },
             iterator: mapIteratorSnapshot("kind" in expression.iterator ? expression.iterator : expression.iterator.snapshot?.() ?? { kind: "unsupported" }, encode)
           } : expression.kind === "for-in" ? { ...expression, keys: [...expression.keys], object: encode(expression.object), scope: encode(expression.scope) } : expression.kind === "for" ? { kind: "for", phase: expression.phase, loopScope: encode(expression.loopScope), activeScope: encode(expression.activeScope) } : expression.kind === "identifier-assignment" ? { kind: "identifier-assignment", current: encode(expression.current) } : expression.kind === "member-assignment" ? {
             kind: "member-assignment",
@@ -18228,6 +18824,29 @@ function serializeSafeJSSnapshot(snapshot) {
   }
   return JSON.stringify(createDumpFile(snapshot), null, 2);
 }
+function requiresPromiseReplay(promise) {
+  const seen = /* @__PURE__ */ new Set();
+  const pending = [promise];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    const continuation = promiseContinuations.get(current);
+    if (promiseStates.get(current)?.status === "pending" && (unrepresentedPromiseContinuations.has(current) || continuation === void 0)) return true;
+    pending.push(...promiseProducers.get(current) ?? [], ...promiseReactionResults.get(current) ?? []);
+    if (continuation?.kind === "reaction") {
+      pending.push(continuation.source);
+      if (continuation.aggregate !== void 0) pending.push(continuation.aggregate);
+      if (continuation.capability !== void 0) pending.push(continuation.capability.promise);
+    } else if (continuation?.resolution !== void 0 && isSandboxPromise(continuation.resolution.value)) {
+      pending.push(continuation.resolution.value);
+    }
+    const adoption = promiseAdoptions.get(current);
+    const bridge = adoption === void 0 ? void 0 : promiseAdoptionBridges.get(adoption);
+    if (bridge !== void 0) pending.push(bridge.source);
+  }
+  return false;
+}
 function createDumpFile(snapshot) {
   const state = {
     trustedRunReplay: inMemoryRunSnapshots.has(snapshot),
@@ -18491,7 +19110,7 @@ function collectContainerStats(value, stats, ancestors, guestValues, trustedRunR
   ancestors.add(value);
   const guestEntries = [];
   const replayPromise = isSandboxPromise(value) ? value : isPromiseResolvingFunction(value) ? promiseResolvingFunctions.get(value)?.promise : void 0;
-  const replayMetadata = trustedRunReplay && replayPromise !== void 0 && promiseStates.get(replayPromise)?.status === "pending" && unrepresentedPromiseContinuations.has(replayPromise);
+  const replayMetadata = trustedRunReplay && replayPromise !== void 0 && requiresPromiseReplay(replayPromise);
   if (isSandboxDataView(value)) guestEntries.push(dataViewBuffer(value));
   if (isNumericTypedArray(value)) guestEntries.push(typedArrayStorage(value).buffer);
   const guest = isSandboxDataView(value) ? { kind: "dataview", state: captureDataViewState(value, (entry) => {
@@ -22605,6 +23224,8 @@ function getGeneratorMember(target, property, budget) {
   });
 }
 function callGeneratorMethod(target, method, value, budget, context, async) {
+  if (async && isSandboxGenerator(target) && target.async === true)
+    return enqueueAsyncGeneratorRequest(target, method, value, budget, context);
   const result = (async () => {
     if (!isSandboxGenerator(target) || target.async === true !== async)
       throw new TypeError(`${async ? "AsyncGenerator" : "Generator"}.${method} requires a matching generator receiver.`);
@@ -24023,6 +24644,7 @@ function createBuiltinBindings(options) {
   if (options.errorPrototypes !== false) createErrorPrototypes(options.budget, bindings);
   createGeneratorPrototypes(options.budget);
   registerBuiltinIdentities(options.budget, bindings);
+  mutableBuiltinBindings.set(bindings, new Set(Object.keys(bindings).filter((name) => name !== "Infinity" && name !== "NaN" && name !== "undefined")));
   return bindings;
 }
 
@@ -24085,7 +24707,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["thenable-state", "thenable-resolver", "construction-environment", "capability-executor", "promise-aggregate", "aggregate-entry", "aggregate-handler", "intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "async-disposable-stack", "async-cleanup", "async-cleanup-handler", "disposable-stack", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
+  if (!["async-generator-driver", "async-generator-handler", "async-function-driver", "async-function-handler", "thenable-state", "thenable-resolver", "construction-environment", "capability-executor", "promise-aggregate", "aggregate-entry", "aggregate-handler", "intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "async-disposable-stack", "async-cleanup", "async-cleanup-handler", "disposable-stack", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record3(value);
     fields(ref, ["kind", "id"]);
@@ -24096,10 +24718,15 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
   };
   const callable = (value) => {
     if (absent(value)) return;
-    const target = reference(value, ["async-cleanup-handler", "thenable-resolver", "aggregate-handler", "capability-executor", "intrinsic", "bound-function", "promise-resolver", "guest-function", "guest-class"]);
+    const target = reference(value, ["async-generator-handler", "async-function-handler", "async-cleanup-handler", "thenable-resolver", "aggregate-handler", "capability-executor", "intrinsic", "bound-function", "promise-resolver", "guest-function", "guest-class"]);
     if (target.kind === "intrinsic" && intrinsicCatalogue().get(String(target.id)) !== true)
       throw new TypeError("Guest accessor reference is not callable.");
   };
+  if ((node.kind === "pending-promise" || node.kind === "guest-promise") && Object.hasOwn(node, "generatorOwner")) {
+    const owner = reference(node.generatorOwner, ["async-generator-driver"]);
+    if (!array(owner.requests).some((value) => reference(record3(record3(value).capability).promise) === node))
+      throw new TypeError("Invalid async generator request ownership.");
+  }
   const privateIdentity = (value, expected) => {
     const identity = reference(value, ["object"]);
     fields(identity, ["kind", "entries"]);
@@ -24272,7 +24899,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       throw new TypeError("Invalid promise resolver action.");
     state(node.state);
   } else if (node.kind === "pending-promise" || node.kind === "promise-reaction") {
-    fields(node, node.kind === "pending-promise" ? ["kind", "reactions", "state"] : ["kind", "source", "onFulfilled", "onRejected", "reactions", "state"], node.kind === "pending-promise" ? ["adoption", "thenable", "producers"] : ["capability", "aggregate", "producers"]);
+    fields(node, node.kind === "pending-promise" ? ["kind", "reactions", "state"] : ["kind", "source", "onFulfilled", "onRejected", "reactions", "state"], node.kind === "pending-promise" ? ["adoption", "thenable", "producers", "generatorOwner"] : ["capability", "aggregate", "producers"]);
     if (node.kind === "pending-promise" && Object.hasOwn(node, "thenable")) {
       const continuation = reference(node.thenable, ["thenable-state"]);
       if (Object.hasOwn(node, "adoption") || continuation.completed !== false || reference(continuation.owner) !== node)
@@ -24299,7 +24926,10 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
           } else if (handler.kind === "async-cleanup-handler") {
             const cleanup = reference(handler.cleanup, ["async-cleanup"]);
             owner = reference(record3(cleanup.capability).promise);
-          }
+          } else if (handler.kind === "async-function-handler") {
+            const driver = reference(handler.driver, ["async-function-driver"]);
+            owner = reference(record3(driver.capability).promise);
+          } else if (handler.kind === "async-generator-handler") owner = reference(handler.owner);
           if (owner !== void 0 && owner !== aggregate) throw new TypeError("Invalid promise aggregate handler ownership.");
         }
       }
@@ -24328,7 +24958,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     }
     state(node.state);
   } else if (node.kind === "guest-promise") {
-    fields(node, ["kind", "status", "value", "state"], ["reactions", "producers"]);
+    fields(node, ["kind", "status", "value", "state"], ["reactions", "producers", "generatorOwner"]);
     if (Object.hasOwn(node, "reactions")) {
       if (!Array.isArray(node.reactions)) throw new TypeError("Invalid promise reactions.");
       const reactions = /* @__PURE__ */ new Set();
@@ -24402,7 +25032,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (resources.length > maxArrayLength) throw new TypeError("Too many async resources.");
     for (const rawResource of resources) {
       const resource = record3(rawResource);
-      fields(resource, ["method", "receiver", "args", "syncFallback"]);
+      fields(resource, ["method", "receiver", "args", "syncFallback"], ["synchronous"]);
+      if (resource.synchronous !== void 0 && (resource.synchronous !== true || resource.syncFallback || absent(resource.method))) throw new TypeError("Invalid synchronous resource.");
       const args = array(resource.args);
       if (typeof resource.syncFallback !== "boolean" || args.length > 1) throw new TypeError("Invalid async resource.");
       if (absent(resource.method)) {
@@ -24426,6 +25057,55 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
           throw new TypeError("Invalid async cleanup resolver ownership.");
       }
     }
+  } else if (node.kind === "async-generator-driver") {
+    fields(node, ["kind", "generator", "requests", "phase", "suspension", "awaitKind", "generation"]);
+    const generator = reference(node.generator, ["guest-generator"]);
+    if (generator.async !== true || generator.asyncFunction !== void 0 || reference(generator.driver) !== node || !["idle", "waiting"].includes(String(node.phase)) || !["await", "yield"].includes(String(node.suspension)) || !["body", "return"].includes(String(node.awaitKind))) throw new TypeError("Invalid async generator driver.");
+    integer(node.generation);
+    if (!Array.isArray(node.requests) || node.phase === "idle" !== (node.requests.length === 0)) throw new TypeError("Invalid async generator request queue.");
+    if (node.phase === "waiting" && (node.awaitKind === "body" ? generator.state !== "suspended" || generator.awaitPhase === void 0 || node.suspension !== "await" : generator.state !== "done")) throw new TypeError("Invalid async generator wait position.");
+    const owners = /* @__PURE__ */ new Set();
+    for (const value of node.requests) {
+      const request = record3(value);
+      fields(request, ["method", "value", "capability"]);
+      if (!["next", "return", "throw"].includes(String(request.method))) throw new TypeError("Invalid async generator request operation.");
+      const capability = record3(request.capability);
+      fields(capability, ["promise", "resolve", "reject"]);
+      const owner = reference(capability.promise, ["pending-promise", "guest-promise"]);
+      if (owners.has(owner)) throw new TypeError("Duplicate async generator request owner.");
+      if (reference(owner.generatorOwner, ["async-generator-driver"]) !== node) throw new TypeError("Invalid async generator request ownership.");
+      owners.add(owner);
+      for (const key of ["resolve", "reject"]) {
+        const resolver = reference(capability[key], ["promise-resolver"]);
+        if (reference(resolver.promise) !== owner || resolver.action !== void 0 && resolver.action !== (key === "resolve" ? "fulfilled" : "rejected"))
+          throw new TypeError("Invalid async generator resolver ownership.");
+      }
+    }
+  } else if (node.kind === "async-generator-handler") {
+    fields(node, ["kind", "driver", "owner", "action", "generation", "state"]);
+    const driver = reference(node.driver, ["async-generator-driver"]);
+    const owner = reference(node.owner, ["pending-promise", "guest-promise"]);
+    if (!["fulfilled", "rejected"].includes(String(node.action)) || integer(node.generation) > integer(driver.generation)) throw new TypeError("Invalid async generator handler.");
+    if (driver.phase === "waiting" && node.generation === driver.generation && reference(record3(record3(driver.requests[0]).capability).promise) !== owner) throw new TypeError("Invalid async generator active handler owner.");
+    state(node.state);
+  } else if (node.kind === "async-function-driver") {
+    fields(node, ["kind", "generator", "capability", "phase", "generation"]);
+    const generator = reference(node.generator, ["guest-generator"]);
+    if (generator.asyncFunction !== true || !["waiting", "done"].includes(String(node.phase))) throw new TypeError("Invalid async function frame.");
+    integer(node.generation);
+    const capability = record3(node.capability);
+    fields(capability, ["promise", "resolve", "reject"]);
+    const owner = reference(capability.promise, ["pending-promise", "guest-promise"]);
+    for (const key of ["resolve", "reject"]) {
+      const resolver = reference(capability[key], ["promise-resolver"]);
+      if (reference(resolver.promise) !== owner || resolver.action !== void 0 && resolver.action !== (key === "resolve" ? "fulfilled" : "rejected"))
+        throw new TypeError("Invalid async function resolver ownership.");
+    }
+  } else if (node.kind === "async-function-handler") {
+    fields(node, ["kind", "driver", "action", "generation", "state"]);
+    const driver = reference(node.driver, ["async-function-driver"]);
+    if (node.action !== "fulfilled" && node.action !== "rejected" || integer(node.generation) > integer(driver.generation)) throw new TypeError("Invalid async function handler.");
+    state(node.state);
   } else if (node.kind === "async-cleanup-handler") {
     fields(node, ["kind", "cleanup", "action", "generation", "state"]);
     const cleanup = reference(node.cleanup, ["async-cleanup"]);
@@ -24567,7 +25247,10 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     }
     state(node.state);
   } else if (node.kind === "guest-generator") {
-    fields(node, ["kind", "state", "astNodeId", "async", "scope", "closureScope", "sent"], ["suspendedScope", "yieldNodeId", "environment", "blockScopes", "finallyCompletions", "expressionStates", "objectState"]);
+    fields(node, ["kind", "state", "astNodeId", "async", "scope", "closureScope", "sent"], ["suspendedScope", "yieldNodeId", "environment", "blockScopes", "finallyCompletions", "expressionStates", "objectState", "asyncFunction", "driver", "awaitPhase"]);
+    if (node.asyncFunction !== void 0 && (node.asyncFunction !== true || node.async !== false)) throw new TypeError("Invalid async function suspension frame.");
+    if (node.driver !== void 0 && (node.async !== true || reference(reference(node.driver, ["async-generator-driver"]).generator) !== node)) throw new TypeError("Invalid async generator frame owner.");
+    if (node.awaitPhase !== void 0 && (node.driver === void 0 || node.state !== "suspended" || !["await", "yield", "return", "resume-return"].includes(String(node.awaitPhase)))) throw new TypeError("Invalid async generator await phase.");
     if (Object.hasOwn(node, "objectState")) state(node.objectState);
     if (!["start", "running", "suspended", "done"].includes(String(node.state)) || typeof node.async !== "boolean" || integer(node.astNodeId) < 1)
       throw new TypeError("Invalid generator state.");
@@ -24602,8 +25285,24 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
           if (Object.hasOwn(expression, "referenceKey") && typeof expression.referenceKey !== "string") reference(expression.referenceKey, ["symbol"]);
         } else if (expression.kind === "for-of-array" || expression.kind === "for-of-iterator" || expression.kind === "array-pattern" || expression.kind === "yield-delegate") {
           if (expression.kind === "yield-delegate") {
-            fields(expression, ["kind", "async", "value", "current", "iterator"]);
+            fields(expression, ["kind", "async", "value", "current", "iterator"], ["phase", "awaitState", "completion"]);
             if (typeof expression.async !== "boolean") throw new TypeError("Invalid delegated yield protocol.");
+            if (expression.phase !== void 0) {
+              if (!["await", "close"].includes(String(expression.phase)) || expression.async !== true || node.awaitPhase !== "await" || node.yieldNodeId !== Number(id))
+                throw new TypeError("Invalid delegated iterator wait position.");
+              const completion = record3(expression.completion);
+              fields(completion, ["type", "value"]);
+              if (!["normal", "return", "throw"].includes(String(completion.type)) || expression.phase === "close" && completion.type !== "throw")
+                throw new TypeError("Invalid delegated iterator completion.");
+              const awaiting = record3(expression.awaitState);
+              if (awaiting.kind === "result") fields(awaiting, ["kind"]);
+              else if (awaiting.kind === "value") {
+                fields(awaiting, ["kind", "done", "closeOnReject"]);
+                if (typeof awaiting.done !== "boolean" || typeof awaiting.closeOnReject !== "boolean" || awaiting.closeOnReject !== (expression.phase === "await" && completion.type !== "return" && !awaiting.done))
+                  throw new TypeError("Invalid delegated async-from-sync continuation.");
+              } else throw new TypeError("Invalid delegated iterator await kind.");
+            } else if (expression.awaitState !== void 0 || expression.completion !== void 0)
+              throw new TypeError("Unexpected delegated iterator continuation fields.");
           } else if (expression.kind === "array-pattern") {
             fields(expression, ["kind", "phase", "index", "done", "current", "iterator"], ["referenceObject", "referenceKey", "privateName"]);
             if (expression.privateName !== void 0 && (typeof expression.privateName !== "string" || !Object.hasOwn(expression, "referenceObject"))) throw new TypeError("Invalid private pattern reference.");
@@ -24617,8 +25316,26 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
               "index",
               "scope",
               ...expression.kind === "for-of-array" ? ["values"] : ["value", "iterator", "async"]
-            ]);
-            if (!["left", "body"].includes(String(expression.phase))) throw new TypeError("Invalid for-of phase.");
+            ], ["awaitState", "closeCompletion"]);
+            if (!["left", "body", "next", "close"].includes(String(expression.phase))) throw new TypeError("Invalid for-of phase.");
+            if (expression.phase === "next" || expression.phase === "close") {
+              if (expression.kind !== "for-of-iterator" || expression.async !== true) throw new TypeError("Invalid async iterator suspension.");
+              const awaiting = record3(expression.awaitState);
+              if (awaiting.kind === "result") fields(awaiting, ["kind"]);
+              else if (awaiting.kind === "value") {
+                fields(awaiting, ["kind", "done", "closeOnReject"]);
+                if (typeof awaiting.done !== "boolean" || typeof awaiting.closeOnReject !== "boolean" || awaiting.closeOnReject !== (expression.phase === "next" && !awaiting.done))
+                  throw new TypeError("Invalid async-from-sync continuation.");
+              } else throw new TypeError("Invalid iterator await kind.");
+            } else if (Object.hasOwn(expression, "awaitState")) throw new TypeError("Unexpected iterator await state.");
+            if (expression.phase === "close") {
+              const completion = record3(expression.closeCompletion);
+              fields(completion, ["kind", "hasValue", "value"], ["span", "stackFrames", "label"]);
+              if (!["normal", "return", "throw", "break", "continue"].includes(String(completion.kind)) || typeof completion.hasValue !== "boolean")
+                throw new TypeError("Invalid iterator close completion.");
+              if (completion.label !== void 0 && typeof completion.label !== "string") throw new TypeError("Invalid iterator close label.");
+              if (completion.stackFrames !== void 0 && array(completion.stackFrames).some((frame) => typeof frame !== "string")) throw new TypeError("Invalid iterator close stack.");
+            } else if (Object.hasOwn(expression, "closeCompletion")) throw new TypeError("Unexpected iterator close completion.");
             reference(expression.scope, ["scope-frame"]);
           }
           if (expression.kind !== "yield-delegate") integer(expression.index);
@@ -24633,6 +25350,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
               iterator = record3(iterator.inner);
               protocol = true;
             }
+            if ((expression.kind === "for-of-iterator" && (expression.phase === "next" || expression.phase === "close") || expression.kind === "yield-delegate" && expression.phase !== void 0) && record3(expression.awaitState).kind !== (depth === 1 ? "value" : "result"))
+              throw new TypeError("Iterator await state does not match its adapter.");
             if (iterator.kind === "guest") {
               fields(iterator, ["kind", "value", "next", "async"]);
               if (typeof iterator.async !== "boolean") throw new TypeError("Invalid iterator protocol.");
@@ -24673,7 +25392,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
           reference(expression.scope, ["scope-frame"]);
         } else if (expression.kind === "for") {
           fields(expression, ["kind", "phase", "loopScope", "activeScope"]);
-          if (!["init", "test", "body", "update"].includes(String(expression.phase))) throw new TypeError("Invalid for-loop phase.");
+          if (!["init", "test", "body", "update", "dispose"].includes(String(expression.phase))) throw new TypeError("Invalid for-loop phase.");
           reference(expression.loopScope, ["scope-frame"]);
           reference(expression.activeScope, ["scope-frame"]);
         } else if (expression.kind === "identifier-assignment") {
@@ -24736,7 +25455,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       if (Object.hasOwn(environment, "construction")) reference(environment.construction, ["construction-environment"]);
     }
   } else {
-    fields(node, ["kind", "parent", "importMeta", "functionBoundary", "chargeData", "bindings", "cells"], ["restoredBindings", "privateNames"]);
+    fields(node, ["kind", "parent", "importMeta", "functionBoundary", "chargeData", "bindings", "cells"], ["restoredBindings", "privateNames", "resourceState"]);
+    if (node.resourceState !== void 0) reference(node.resourceState, ["object"]);
     if (node.privateNames !== void 0) {
       const names2 = /* @__PURE__ */ new Set();
       for (const raw2 of array(node.privateNames)) {
@@ -24810,6 +25530,11 @@ function privateAssignmentName(value) {
   const property = node.property;
   return property.type === "PrivateIdentifier" ? String(property.name) : void 0;
 }
+function asyncResourceDeclaration(value) {
+  if (value === null || typeof value !== "object") return false;
+  const node = value;
+  return node.type === "VariableDeclaration" && node.disposal === "async";
+}
 function validateGuestFunctionAst(record4, origin) {
   if (record4.kind === "guest-class") {
     if (origin === null || typeof origin !== "object" || !["ClassDeclaration", "ClassExpression"].includes(String(origin.type)))
@@ -24833,7 +25558,8 @@ function validateGuestFunctionAst(record4, origin) {
     throw new TypeError("Unknown guest function AST identity");
   if (record4.kind !== "guest-generator") return;
   const functionNode = origin;
-  if (functionNode.generator !== true || functionNode.async === true !== record4.async)
+  const representedAsync = record4.asyncFunction === true || record4.async === true && record4.driver !== void 0;
+  if (record4.asyncFunction === true ? functionNode.async !== true || functionNode.generator === true || record4.async !== false : functionNode.generator !== true || functionNode.async === true !== record4.async)
     throw new TypeError("Invalid generator AST identity");
   let yieldBlocks;
   let yieldFinalizers;
@@ -24848,10 +25574,29 @@ function validateGuestFunctionAst(record4, origin) {
     if (["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"].includes(String(node.type))) continue;
     let blocks = frame.blocks;
     if (node.type === "BlockStatement" && typeof node.nodeId === "number") blocks = /* @__PURE__ */ new Set([...blocks, node.nodeId]);
-    if (node.type === "YieldExpression" && node.nodeId === record4.yieldNodeId) {
+    const cases = node.type === "SwitchStatement" ? node.cases : void 0;
+    const resourceBoundary = representedAsync && (node.type === "BlockStatement" && Array.isArray(node.body) && node.body.some(asyncResourceDeclaration) || node.type === "ForOfStatement" && asyncResourceDeclaration(node.left) || node.type === "ForStatement" && asyncResourceDeclaration(node.init) || cases !== void 0 && cases.some((entry) => entry.consequent.some(asyncResourceDeclaration)));
+    const iteratorBoundary = representedAsync && node.type === "ForOfStatement" && node.await === true && ["next", "close"].includes(record4.expressionStates?.[String(node.nodeId)]?.phase ?? "");
+    const delegateBoundary = representedAsync && node.type === "YieldExpression" && node.delegate === true && ["await", "close"].includes(record4.expressionStates?.[String(node.nodeId)]?.phase ?? "");
+    if ((node.type === "YieldExpression" || representedAsync && node.type === "AwaitExpression" || record4.awaitPhase === "return" && node.type === "ReturnStatement" || resourceBoundary || iteratorBoundary) && node.nodeId === record4.yieldNodeId) {
+      if (record4.awaitPhase !== void 0) {
+        const valid = record4.awaitPhase === "await" ? node.type === "AwaitExpression" || resourceBoundary || iteratorBoundary || delegateBoundary : record4.awaitPhase === "return" ? node.type === "ReturnStatement" : node.type === "YieldExpression" && (record4.awaitPhase === "resume-return" || node.delegate !== true);
+        if (!valid) throw new TypeError("Invalid async generator await source position.");
+      }
       yieldBlocks = blocks;
       yieldFinalizers = frame.finalizers;
       yieldExpressions = node.delegate === true && typeof node.nodeId === "number" ? new Map([...frame.expressions, [node.nodeId, { kind: "yield-delegate", async: record4.async === true }]]) : frame.expressions;
+      if (resourceBoundary && typeof node.nodeId === "number") {
+        if (node.type === "ForOfStatement") yieldExpressions = new Map([...frame.expressions, [node.nodeId, { kind: "for-of", phase: "body", async: node.await === true }]]);
+        if (node.type === "ForStatement") yieldExpressions = new Map([...frame.expressions, [node.nodeId, { kind: "for", phase: "dispose" }]]);
+        if (cases !== void 0) {
+          const progress = record4.expressionStates?.[String(node.nodeId)];
+          if (progress === void 0 || progress.phase !== "body" || progress.index < 0 || progress.index >= cases.length || progress.statementIndex < 0 || progress.statementIndex >= cases[progress.index].consequent.length) throw new TypeError("Invalid switch disposal position.");
+          yieldExpressions = new Map([...frame.expressions, [node.nodeId, { kind: "switch", phase: "body", index: progress.index, statementIndex: progress.statementIndex }]]);
+        }
+      }
+      if (iteratorBoundary && typeof node.nodeId === "number")
+        yieldExpressions = new Map([...frame.expressions, [node.nodeId, { kind: "for-of", phase: record4.expressionStates[String(node.nodeId)].phase, async: true }]]);
     }
     for (const [key, value] of Object.entries(node)) {
       if (node.type === "SwitchStatement" && key === "cases" && typeof node.nodeId === "number" && Array.isArray(value)) {
@@ -26132,6 +26877,91 @@ function bigIntOperation(operator, left, right, budget) {
   }
 }
 
+// packages/safe-js/src/interp/resource-management.ts
+function resourceSuspension(context, node) {
+  return context.asyncFunction || context.asyncGeneratorFrame !== void 0 ? {
+    awaitResource: (value) => suspendAsyncFunctionValue(value, node, context),
+    resumeResource: context.generatorResume?.completed !== true && context.generatorResume?.yieldNodeId === node.nodeId
+  } : {};
+}
+async function registerScopeResource(scope, value, hint, budget, context) {
+  if (hint === "sync" && (value === null || value === void 0)) return;
+  const state = scope.resourceState ??= { resources: [] };
+  if (value === null || value === void 0) {
+    state.resources.push({ method: void 0, receiver: void 0, args: [], syncFallback: false });
+    createDataCheckpoint(budget, context)(state, 0, true);
+    return;
+  }
+  if (typeof value !== "object") throw new TypeError("Disposable resource must be an object.");
+  const read = async (key) => {
+    if (context?.getProperty !== void 0) return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+  };
+  let method = await read(hint === "async" ? wellKnownSymbols.asyncDispose : wellKnownSymbols.dispose);
+  let syncFallback = false;
+  if (hint === "async" && (method === void 0 || method === null)) {
+    method = await read(wellKnownSymbols.dispose);
+    syncFallback = true;
+  }
+  if (!isSandboxClosure(method)) throw new TypeError("Disposer must be callable.");
+  state.resources.push({ method, receiver: value, args: [], syncFallback, ...hint === "sync" ? { synchronous: true } : {} });
+  createDataCheckpoint(budget, context)(state, 0, true);
+}
+async function evaluateResourceScope(scope, budget, context, body) {
+  let completion;
+  try {
+    completion = scope.resourceState?.completion ?? await body();
+  } catch (error) {
+    if (scope.resourceState === void 0 || isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
+    completion = createThrowCompletion(error, budget, context?.stack ?? []);
+  }
+  const state = scope.resourceState;
+  if (state === void 0 || state.resources.length === 0 && state.cleanup === void 0) return completion;
+  if (completion.kind === "error") return completion;
+  state.completion = { ...completion, ...completion.stackFrames === void 0 ? { stackFrames: void 0 } : { stackFrames: [...completion.stackFrames] } };
+  const release = retainValues(budget, () => [state]);
+  try {
+    if (state.cleanup === void 0) {
+      const capability = createPendingPromiseCapability(budget, context);
+      const cleanup2 = {
+        resources: state.resources,
+        capability: { promise: capability.promise, resolve: capability.resolve, reject: capability.reject },
+        phase: "running",
+        failed: completion.kind === "throw",
+        failure: completion.kind === "throw" ? completion.value : void 0,
+        needsAwait: false,
+        hasAwaited: false,
+        generation: 0
+      };
+      state.resources = [];
+      state.cleanup = cleanup2;
+      asyncCleanupStates.set(cleanup2, cleanup2);
+      await advanceAsyncCleanup(cleanup2, budget, context);
+    }
+    const cleanup = state.cleanup;
+    try {
+      if (context?.awaitResource !== void 0) {
+        if (cleanup.phase !== "done" || context.resumeResource) await context.awaitResource(cleanup.capability.promise);
+        else observeSandboxPromise(cleanup.capability.promise, true);
+      } else {
+        const settled = awaitSandboxValue(cleanup.capability.promise, context?.signal, budget, context);
+        if (cleanup.phase === "done") await settled;
+        else {
+          context?.onSuspend?.();
+          await suspendJob(settled);
+        }
+      }
+    } catch (error) {
+      if (cleanup.phase !== "done" || isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
+    }
+    return cleanup.failed ? { kind: "throw", hasValue: true, value: cleanup.failure } : completion;
+  } finally {
+    if (state.cleanup?.phase === "done") scope.resourceState = void 0;
+    release();
+  }
+}
+
 // packages/safe-js/src/interp/resume-target.ts
 function containsResumeTarget(node, targetNodeIds) {
   if (targetNodeIds === void 0 ? node.type === "YieldExpression" : node.nodeId !== void 0 && targetNodeIds.has(node.nodeId)) {
@@ -26292,9 +27122,10 @@ async function interpret(node, options = {}) {
       asyncGenerator: options.asyncGenerator,
       resumeTarget: { nodeId: options.snapshot?.resumeNodeId }
     };
+    const execute = () => node.type === "VariableDeclaration" && node.disposal !== void 0 ? evaluateResourceScope(scope, budget, { ...createCoercionContext(context), onSuspend: context.onSuspend, signal: context.signal }, () => evaluateNode(node, context)) : evaluateNode(node, context);
     const evaluation = await withCancellationSignal(
       options.signal,
-      () => options.nested ? runAsyncPrefix(() => evaluateNode(node, context)) : jobs.run(() => evaluateNode(node, context))
+      () => options.nested ? runAsyncPrefix(execute) : jobs.run(execute)
     );
     if (!options.nested) await jobs.drain();
     const snapshot = scope.snapshot();
@@ -27119,6 +27950,7 @@ async function evaluateVariableDeclaration(node, context) {
     };
     const release = retainValues(context.budget, () => [value.value]);
     try {
+      if (node.disposal !== void 0) await registerScopeResource(context.scope, value.value, node.disposal, context.budget, createCoercionContext(context));
       const binding = await bindPattern(
         declarator.id,
         value.value,
@@ -27208,24 +28040,26 @@ async function evaluateBlockStatement(node, context) {
   const blockContext = createBlockContext(node, context);
   const resumeIndex = findResumeStatementIndex(node, blockContext);
   const generatorResumeIndex = findGeneratorResumeStatementIndex(node, blockContext);
-  for (let index = 0; index < node.body.length; index += 1) {
-    const statement = node.body[index];
-    if (generatorResumeIndex !== void 0 && index < generatorResumeIndex) {
-      continue;
-    }
-    if (resumeIndex !== void 0 && index < resumeIndex && statement.type !== "VariableDeclaration") {
-      continue;
-    }
-    const result = await evaluateNode(statement, blockContext);
-    if (result.kind !== "normal") {
-      return result;
+  return evaluateResourceScope(blockContext.scope, context.budget, { ...createCoercionContext(blockContext), ...resourceSuspension(blockContext, node), onSuspend: blockContext.onSuspend, signal: blockContext.signal }, async () => {
+    for (let index = 0; index < node.body.length; index += 1) {
+      const statement = node.body[index];
+      if (generatorResumeIndex !== void 0 && index < generatorResumeIndex) {
+        continue;
+      }
+      if (resumeIndex !== void 0 && index < resumeIndex && statement.type !== "VariableDeclaration") {
+        continue;
+      }
+      const result = await evaluateNode(statement, blockContext);
+      if (result.kind !== "normal") {
+        return result;
+      }
     }
-  }
-  return {
-    kind: "normal",
-    hasValue: false,
-    value: void 0
-  };
+    return {
+      kind: "normal",
+      hasValue: false,
+      value: void 0
+    };
+  });
 }
 function findGeneratorResumeStatementIndex(node, context) {
   if (context.generatorResume === void 0) {
@@ -27334,44 +28168,46 @@ async function evaluateSwitchStatement(node, context) {
   );
   const release = retainValues(context.budget, () => [progress.value]);
   try {
-    const defaultIndex = node.cases.findIndex((entry) => entry.test === void 0);
-    let startIndex = saved?.phase === "body" ? saved.index : void 0;
-    for (let index = progress.index; startIndex === void 0 && index < node.cases.length; index += 1) {
-      const switchCase = node.cases[index];
-      if (switchCase.test === void 0) {
-        continue;
-      }
-      progress.index = index;
-      const test = await evaluateNode(switchCase.test, switchContext);
-      if (test.kind !== "normal") {
-        return test;
+    return await evaluateResourceScope(progress.scope, context.budget, { ...createCoercionContext(switchContext), ...resourceSuspension(switchContext, node), onSuspend: switchContext.onSuspend, signal: switchContext.signal }, async () => {
+      const defaultIndex = node.cases.findIndex((entry) => entry.test === void 0);
+      let startIndex = saved?.phase === "body" ? saved.index : void 0;
+      for (let index = progress.index; startIndex === void 0 && index < node.cases.length; index += 1) {
+        const switchCase = node.cases[index];
+        if (switchCase.test === void 0) {
+          continue;
+        }
+        progress.index = index;
+        const test = await evaluateNode(switchCase.test, switchContext);
+        if (test.kind !== "normal") {
+          return test;
+        }
+        if (discriminant.value === test.value) {
+          startIndex = index;
+          break;
+        }
       }
-      if (discriminant.value === test.value) {
-        startIndex = index;
-        break;
+      startIndex ??= defaultIndex < 0 ? void 0 : defaultIndex;
+      if (startIndex === void 0) {
+        return normalEmptyResult();
       }
-    }
-    startIndex ??= defaultIndex < 0 ? void 0 : defaultIndex;
-    if (startIndex === void 0) {
-      return normalEmptyResult();
-    }
-    for (let caseIndex = startIndex; caseIndex < node.cases.length; caseIndex += 1) {
-      progress.phase = "body";
-      progress.index = caseIndex;
-      const statements = node.cases[caseIndex].consequent;
-      for (let statementIndex = saved?.phase === "body" && caseIndex === saved.index ? saved.statementIndex : 0; statementIndex < statements.length; statementIndex++) {
-        progress.statementIndex = statementIndex;
-        const statement = statements[statementIndex];
-        const result = await evaluateNode(statement, switchContext);
-        if (result.kind === "break" && result.label === void 0) {
-          return normalEmptyResult();
-        }
-        if (result.kind !== "normal") {
-          return result;
+      for (let caseIndex = startIndex; caseIndex < node.cases.length; caseIndex += 1) {
+        progress.phase = "body";
+        progress.index = caseIndex;
+        const statements = node.cases[caseIndex].consequent;
+        for (let statementIndex = saved?.phase === "body" && caseIndex === saved.index ? saved.statementIndex : 0; statementIndex < statements.length; statementIndex++) {
+          progress.statementIndex = statementIndex;
+          const statement = statements[statementIndex];
+          const result = await evaluateNode(statement, switchContext);
+          if (result.kind === "break" && result.label === void 0) {
+            return normalEmptyResult();
+          }
+          if (result.kind !== "normal") {
+            return result;
+          }
         }
       }
-    }
-    return normalEmptyResult();
+      return normalEmptyResult();
+    });
   } finally {
     release();
   }
@@ -27440,7 +28276,7 @@ async function evaluateForOfStatement(node, context) {
     }
     const iterationContext = createLoopIterationContext(phaseContext("body"), scope);
     emitLoopIterationBreakpoint(node, iterationContext);
-    const result = await evaluateNode(node.body, iterationContext);
+    const result = await evaluateResourceScope(scope, context.budget, { ...createCoercionContext(iterationContext), ...resourceSuspension(iterationContext, node), onSuspend: iterationContext.onSuspend, signal: iterationContext.signal }, () => evaluateNode(node.body, iterationContext));
     if (isMatchingBreak(result, loopLabels(node))) {
       context.activeLoopIterations.delete(node.nodeId ?? -1);
       return {
@@ -27467,12 +28303,43 @@ async function evaluateForOfStatement(node, context) {
 async function evaluateForOfIterator(node, value, context, restoredEntry) {
   const saved = context.generatorResume === void 0 || node.nodeId === void 0 ? void 0 : context.restoredGeneratorExpressionStates?.get(node.nodeId);
   if (saved !== void 0 && saved.kind !== "for-of-iterator") throw new TypeError("Invalid iterator continuation.");
-  let resumeCurrent = saved !== void 0;
+  let resumeCurrent = saved !== void 0 && saved.phase !== "next";
+  let resumeNext = saved?.phase === "next";
+  let index = saved?.index ?? consumeRestoredLoopIterationIndex(node, context);
   const iterator = saved === void 0 ? await acquireSandboxIterator(value, context.budget, createCoercionContext(context), node.await, context.signal) : "kind" in saved.iterator ? await restoreSandboxIterator(saved.iterator, context.budget, createCoercionContext(context), context.signal) : saved.iterator;
   if (iterator === void 0) {
     throw new TypeError(`${String(value)} is not a supported iterable`);
   }
   const nextIteration = async () => {
+    if ((context.asyncFunction || context.asyncGeneratorFrame !== void 0) && node.await && iterator.resumeAwait !== void 0 && node.nodeId !== void 0) {
+      iterator.awaitValue = (awaited, awaitState) => suspendAsyncFunctionValue(awaited, node, {
+        ...context,
+        generatorExpressionStates: new Map([
+          ...context.generatorExpressionStates ?? [],
+          [node.nodeId, {
+            kind: "for-of-iterator",
+            phase: "next",
+            awaitState,
+            async: true,
+            value,
+            current: void 0,
+            index,
+            scope: context.scope,
+            iterator
+          }]
+        ])
+      }, void 0, createCoercionContext(context));
+      try {
+        if (resumeNext) {
+          resumeNext = false;
+          if (saved?.awaitState === void 0) throw new TypeError("Missing iterator await continuation.");
+          return await iterator.resumeAwait(saved.awaitState, () => iterator.awaitValue(void 0, saved.awaitState));
+        }
+        return await iterator.next();
+      } finally {
+        delete iterator.awaitValue;
+      }
+    }
     const pending = Promise.resolve(iterator.next());
     if (!node.await) return pending;
     context.onSuspend?.();
@@ -27484,9 +28351,50 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
     }
   };
   const releaseIterator = retainValues(context.budget, () => [value, iterator.retainedValue]);
+  const closeLoopIterator = async (completion) => {
+    const preserveThrow = completion.kind === "throw";
+    if (!context.asyncFunction && context.asyncGeneratorFrame === void 0 || !node.await || iterator.resumeAwait === void 0 || node.nodeId === void 0 || completion.kind === "error") {
+      await closeIterator(iterator, preserveThrow);
+      return;
+    }
+    const { node: ignoredNode, stackFrames, ...metadata } = completion;
+    const closeCompletion = { ...metadata, ...stackFrames === void 0 ? {} : { stackFrames: [...stackFrames] } };
+    iterator.awaitValue = (awaited, awaitState) => suspendAsyncFunctionValue(awaited, node, {
+      ...context,
+      generatorExpressionStates: new Map([
+        ...context.generatorExpressionStates ?? [],
+        [node.nodeId, {
+          kind: "for-of-iterator",
+          phase: "close",
+          awaitState,
+          closeCompletion,
+          async: true,
+          value,
+          current: void 0,
+          index,
+          scope: context.scope,
+          iterator
+        }]
+      ])
+    }, void 0, createCoercionContext(context));
+    try {
+      if (saved?.phase === "close" && context.generatorResume?.completed !== true) {
+        if (saved.awaitState === void 0) throw new TypeError("Missing iterator close continuation.");
+        await iterator.resumeAwait(saved.awaitState, () => iterator.awaitValue(void 0, saved.awaitState));
+      } else await closeIterator(iterator, preserveThrow);
+    } catch (error) {
+      if (!preserveThrow || isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
+    } finally {
+      delete iterator.awaitValue;
+    }
+  };
   try {
+    if (saved?.phase === "close") {
+      if (saved.closeCompletion === void 0) throw new TypeError("Missing iterator close completion.");
+      await closeLoopIterator(saved.closeCompletion);
+      return saved.closeCompletion;
+    }
     const nodeId = node.nodeId ?? -1;
-    let index = saved?.index ?? consumeRestoredLoopIterationIndex(node, context);
     for (let skipped = 0; saved === void 0 && skipped < index; skipped += 1) {
       const skippedIteration = await nextIteration();
       if (typeof skippedIteration !== "object" || skippedIteration === null) {
@@ -27533,19 +28441,19 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
         binding = resuming && saved.phase === "body" ? { ok: true } : await bindIterationVariable(node.left, nextValue, scope, phaseContext("left"));
       } catch (error) {
         if (isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
-        await closeIterator(iterator, true);
+        await closeLoopIterator(createThrowCompletion(error, context.budget, context.callStack));
         throw error;
       }
       if (!binding.ok) {
-        await closeIterator(iterator, binding.result.kind === "throw");
+        await closeLoopIterator(binding.result);
         return binding.result;
       }
       const iterationContext = createLoopIterationContext(phaseContext("body"), scope);
       emitLoopIterationBreakpoint(node, iterationContext);
-      const result = await evaluateNode(node.body, iterationContext);
+      const result = await evaluateResourceScope(scope, context.budget, { ...createCoercionContext(iterationContext), ...resourceSuspension(iterationContext, node), onSuspend: iterationContext.onSuspend, signal: iterationContext.signal }, () => evaluateNode(node.body, iterationContext));
       if (isMatchingBreak(result, loopLabels(node))) {
         context.activeLoopIterations.delete(nodeId);
-        await closeIterator(iterator);
+        await closeLoopIterator(normalEmptyResult());
         return normalEmptyResult();
       }
       if (isMatchingContinue(result, loopLabels(node))) {
@@ -27554,7 +28462,7 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
       }
       if (result.kind !== "normal") {
         context.activeLoopIterations.delete(nodeId);
-        await closeIterator(iterator, result.kind === "throw");
+        await closeLoopIterator(result);
         return result;
       }
       index += 1;
@@ -27692,55 +28600,57 @@ async function evaluateForStatement(node, context) {
       ])
     }
   });
-  if (node.init !== void 0 && (resumePhase === void 0 || resumePhase === "init")) {
-    const init = await evaluateNode(node.init, phaseContext("init", loopScope));
-    if (init.kind !== "normal") {
-      return init;
-    }
-  }
-  while (true) {
-    context.budget.visitNode();
-    context.stats.nodeVisits += 1;
-    if (node.test !== void 0 && resumePhase !== "body" && resumePhase !== "update") {
-      const test = await evaluateNode(node.test, phaseContext("test", loopScope));
-      if (test.kind !== "normal") {
-        return test;
-      }
-      if (!isTruthy(test.value)) {
-        return {
-          kind: "normal",
-          hasValue: false,
-          value: void 0
-        };
+  return evaluateResourceScope(loopScope, context.budget, { ...createCoercionContext(loopContext), ...resourceSuspension(phaseContext("dispose", loopScope), node), onSuspend: loopContext.onSuspend, signal: loopContext.signal }, async () => {
+    if (node.init !== void 0 && (resumePhase === void 0 || resumePhase === "init")) {
+      const init = await evaluateNode(node.init, phaseContext("init", loopScope));
+      if (init.kind !== "normal") {
+        return init;
       }
     }
-    const iterationScope = resumePhase === "body" || resumePhase === "update" ? restored.activeScope : loopBindingNames.length === 0 ? loopScope : loopScope.iterationChild(loopBindingNames);
-    if (resumePhase !== "update") {
-      const iterationContext = createLoopIterationContext(phaseContext("body", iterationScope), iterationScope);
-      emitLoopIterationBreakpoint(node, iterationContext);
-      const result = await evaluateNode(node.body, iterationContext);
-      if (isMatchingBreak(result, loopLabels(node))) {
-        return {
-          kind: "normal",
-          hasValue: false,
-          value: void 0
-        };
+    while (true) {
+      context.budget.visitNode();
+      context.stats.nodeVisits += 1;
+      if (node.test !== void 0 && resumePhase !== "body" && resumePhase !== "update") {
+        const test = await evaluateNode(node.test, phaseContext("test", loopScope));
+        if (test.kind !== "normal") {
+          return test;
+        }
+        if (!isTruthy(test.value)) {
+          return {
+            kind: "normal",
+            hasValue: false,
+            value: void 0
+          };
+        }
       }
-      if (result.kind !== "normal" && !isMatchingContinue(result, loopLabels(node))) {
-        return result;
+      const iterationScope = resumePhase === "body" || resumePhase === "update" ? restored.activeScope : loopBindingNames.length === 0 ? loopScope : loopScope.iterationChild(loopBindingNames);
+      if (resumePhase !== "update") {
+        const iterationContext = createLoopIterationContext(phaseContext("body", iterationScope), iterationScope);
+        emitLoopIterationBreakpoint(node, iterationContext);
+        const result = await evaluateNode(node.body, iterationContext);
+        if (isMatchingBreak(result, loopLabels(node))) {
+          return {
+            kind: "normal",
+            hasValue: false,
+            value: void 0
+          };
+        }
+        if (result.kind !== "normal" && !isMatchingContinue(result, loopLabels(node))) {
+          return result;
+        }
       }
-    }
-    const updateScope = resumePhase === "update" ? restored.activeScope : loopBindingNames.length === 0 ? iterationScope : iterationScope.iterationChild(loopBindingNames);
-    const updateContext = phaseContext("update", updateScope);
-    if (node.update !== void 0) {
-      const update = await evaluateNode(node.update, updateContext);
-      if (update.kind !== "normal") {
-        return update;
+      const updateScope = resumePhase === "update" ? restored.activeScope : loopBindingNames.length === 0 ? iterationScope : iterationScope.iterationChild(loopBindingNames);
+      const updateContext = phaseContext("update", updateScope);
+      if (node.update !== void 0) {
+        const update = await evaluateNode(node.update, updateContext);
+        if (update.kind !== "normal") {
+          return update;
+        }
       }
+      loopScope.copyInitializedBindingsFrom(updateScope, loopBindingNames);
+      resumePhase = void 0;
     }
-    loopScope.copyInitializedBindingsFrom(updateScope, loopBindingNames);
-    resumePhase = void 0;
-  }
+  });
 }
 async function evaluateWhileStatement(node, context) {
   let resumeBody = context.generatorResume !== void 0 && context.generatorResume.completed !== true && containsResumeTarget(node.body, /* @__PURE__ */ new Set([context.generatorResume.yieldNodeId]));
@@ -27865,6 +28775,7 @@ async function bindIterationVariable(left, value, scope, context) {
       [left.nodeId, { kind: "declaration", index: 0 }]
     ]) };
   }
+  if (left.disposal !== void 0) await registerScopeResource(scope, value, left.disposal, context.budget, createCoercionContext({ ...context, scope }));
   return bindPattern(declarator.id, value, { kind: left.kind }, scope, createPatternContext(context, scope));
 }
 async function evaluateExpressionStatement(node, context) {
@@ -27896,14 +28807,14 @@ async function evaluateReturnStatement(node, context) {
       value: void 0
     };
   }
-  const argument = await evaluateNode(node.argument, context);
+  const argument = context.asyncGeneratorFrame !== void 0 && context.generatorResume?.completed !== true && context.generatorResume?.yieldNodeId === node.nodeId ? { kind: "normal", hasValue: true, value: void 0 } : await evaluateNode(node.argument, context);
   if (argument.kind !== "normal") {
     return argument;
   }
   return {
     kind: "return",
     hasValue: argument.hasValue,
-    value: context.asyncGenerator ? await suspendJob(awaitSandboxValue(argument.value, context.signal, context.budget, createCoercionContext(context))) : argument.value
+    value: context.asyncGeneratorFrame !== void 0 ? await suspendAsyncFunctionValue(argument.value, node, context, void 0, createCoercionContext(context), "return") : context.asyncGenerator ? await suspendJob(awaitSandboxValue(argument.value, context.signal, context.budget, createCoercionContext(context))) : argument.value
   };
 }
 async function evaluateYieldExpression(node, context) {
@@ -27927,7 +28838,25 @@ async function evaluateYieldExpression(node, context) {
   return generatorCompletionResult(completion);
 }
 async function yieldGeneratorValue(value, node, context) {
-  if (context.asyncGenerator && !node.delegate) value = await suspendJob(awaitSandboxValue(value, context.signal, context.budget, createCoercionContext(context)));
+  const frame = context.asyncGeneratorFrame;
+  const origin = frame === void 0 ? void 0 : getGeneratorOrigin(frame);
+  const resuming = context.generatorResume?.completed !== true && context.generatorResume?.yieldNodeId === node.nodeId;
+  if (frame !== void 0 && resuming && origin?.awaitPhase === "resume-return") {
+    try {
+      return { type: "return", value: await suspendAsyncFunctionValue(void 0, node, context, void 0, createCoercionContext(context), "resume-return") };
+    } catch (error) {
+      return { type: "throw", value: error };
+    }
+  }
+  if (frame !== void 0 && !node.delegate && (!resuming || origin?.awaitPhase === "yield"))
+    value = await suspendAsyncFunctionValue(value, node, context, void 0, createCoercionContext(context), "yield");
+  else if (frame === void 0 && context.asyncGenerator && !node.delegate)
+    value = await suspendJob(awaitSandboxValue(value, context.signal, context.budget, createCoercionContext(context)));
+  if (frame !== void 0) {
+    const driver = asyncGeneratorDrivers.get(frame);
+    if (driver === void 0) throw new TypeError("Missing async generator yield owner.");
+    driver.suspension = "yield";
+  }
   context.captureGeneratorScope?.(context.scope, context.generatorBlockScopes, context.finallyCompletions, context.generatorExpressionStates);
   const completionPromise = context.generatorYield(allocateProducedSandboxValue(value, context.budget), node.nodeId);
   emitResumeBreakpoint(context, {
@@ -27935,10 +28864,10 @@ async function yieldGeneratorValue(value, node, context) {
     nodeId: node.nodeId,
     span: node.span
   });
-  const completion = await (context.asyncGenerator ? suspendJob(completionPromise) : completionPromise);
+  const completion = await (context.asyncGenerator && frame === void 0 ? suspendJob(completionPromise) : completionPromise);
   if (context.asyncGenerator && completion.type === "return") {
     try {
-      return { type: "return", value: await suspendJob(awaitSandboxValue(completion.value, context.signal, context.budget, createCoercionContext(context))) };
+      return { type: "return", value: frame === void 0 ? await suspendJob(awaitSandboxValue(completion.value, context.signal, context.budget, createCoercionContext(context))) : await suspendAsyncFunctionValue(completion.value, node, context, void 0, createCoercionContext(context), "resume-return") };
     } catch (error) {
       return { type: "throw", value: error };
     }
@@ -27968,41 +28897,69 @@ async function evaluateYieldDelegate(node, context) {
     async: context.asyncGenerator === true,
     value: argument.value,
     current: saved?.current,
-    iterator
+    iterator,
+    ...saved?.phase === void 0 ? {} : { phase: saved.phase, awaitState: saved.awaitState, completion: saved.completion }
   };
   if (node.nodeId !== void 0) context = {
     ...context,
     generatorExpressionStates: new Map([...context.generatorExpressionStates ?? [], [node.nodeId, state]])
   };
+  if (context.asyncGeneratorFrame !== void 0 && iterator.resumeAwait !== void 0)
+    iterator.awaitValue = (value, awaitState) => {
+      state.awaitState = awaitState;
+      return suspendAsyncFunctionValue(value, node, context, void 0, createCoercionContext(context));
+    };
   const releaseIterator = retainValues(context.budget, () => [
     argument.value,
     iterator.retainedValue,
     state.current
   ]);
   try {
-    let completion = {
+    let completion = saved?.completion ?? {
       type: "normal",
       value: void 0
     };
     const replay = saved === void 0 ? context.generatorResume?.sent ?? [] : [];
     let replayIndex = 0;
-    if (saved !== void 0) {
+    let resumeOperation = saved?.phase !== void 0;
+    if (saved !== void 0 && !resumeOperation) {
       completion = await yieldGeneratorValue(saved.current, node, context);
       if (context.generatorResume !== void 0) context.generatorResume.completed = true;
       context.generatorResume = void 0;
     }
     while (true) {
       const method = completion.type === "normal" ? "next" : completion.type;
-      const iteratorMethod = iterator.getOperation === void 0 ? iterator[method] : await iterator.getOperation(method);
-      if (iteratorMethod === void 0) {
-        if (completion.type === "throw") {
-          await closeIterator(iterator);
-          throw new TypeError("Delegated iterator does not provide a throw method.");
+      let result;
+      if (resumeOperation) {
+        resumeOperation = false;
+        if (iterator.resumeAwait === void 0 || iterator.awaitValue === void 0 || saved?.awaitState === void 0)
+          throw new TypeError("Missing delegated iterator await continuation.");
+        result = await iterator.resumeAwait(saved.awaitState, () => iterator.awaitValue(void 0, saved.awaitState));
+        if (saved.phase === "close") throw new TypeError("Delegated iterator does not provide a throw method.");
+        context.generatorResume = void 0;
+      } else {
+        const iteratorMethod = iterator.getOperation === void 0 ? iterator[method] : await iterator.getOperation(method);
+        if (iteratorMethod === void 0) {
+          if (completion.type === "throw") {
+            if (iterator.awaitValue !== void 0) {
+              state.phase = "close";
+              state.completion = completion;
+            }
+            await closeIterator(iterator, false, context.asyncGeneratorFrame === void 0 ? suspendJob : async (pending) => await suspendAsyncFunctionValue(createSandboxPromise(pending), node, context, void 0, createCoercionContext(context)));
+            throw new TypeError("Delegated iterator does not provide a throw method.");
+          }
+          return generatorCompletionResult(completion);
         }
-        return generatorCompletionResult(completion);
+        if (iterator.awaitValue !== void 0) {
+          state.phase = "await";
+          state.completion = completion;
+        }
+        const pendingResult = Promise.resolve(iteratorMethod(completion.value));
+        result = context.asyncGeneratorFrame !== void 0 && iterator.awaitValue === void 0 ? await suspendAsyncFunctionValue(createSandboxPromise(pendingResult), node, context, void 0, createCoercionContext(context)) : await (context.asyncGenerator && iterator.awaitValue === void 0 ? suspendJob(pendingResult) : pendingResult);
       }
-      const pendingResult = Promise.resolve(iteratorMethod(completion.value));
-      const result = await (context.asyncGenerator ? suspendJob(pendingResult) : pendingResult);
+      delete state.phase;
+      delete state.awaitState;
+      delete state.completion;
       if (typeof result !== "object" && typeof result !== "function" || result === null) {
         throw new TypeError("Iterator result must be an object.");
       }
@@ -28028,6 +28985,7 @@ async function evaluateYieldDelegate(node, context) {
       context.generatorResume = void 0;
     }
   } finally {
+    delete iterator.awaitValue;
     releaseIterator();
   }
 }
@@ -30287,21 +31245,23 @@ async function evaluateBlockCompletion(node, context, evaluateNode2) {
     }
   };
   if (restoredScope === void 0) predeclareBlockBindings2(node, blockContext.scope);
-  let result = {
-    kind: "normal",
-    hasValue: false,
-    value: void 0
-  };
-  const resume = context.generatorResume;
-  const resumeIndex = resume === void 0 || resume.completed === true ? -1 : node.body.findIndex((statement) => containsResumeTarget(statement, /* @__PURE__ */ new Set([resume.yieldNodeId])));
-  for (let index = Math.max(0, resumeIndex); index < node.body.length; index++) {
-    const statement = node.body[index];
-    result = await evaluateNode2(statement, blockContext);
-    if (result.kind !== "normal") {
-      return result;
+  return evaluateResourceScope(scope, context.budget, { ...resourceSuspension(blockContext, node), stack: context.callStack, thisValue: void 0, getProperty: context.getProperty, onSuspend: context.onSuspend, signal: context.signal }, async () => {
+    let result = {
+      kind: "normal",
+      hasValue: false,
+      value: void 0
+    };
+    const resume = context.generatorResume;
+    const resumeIndex = resume === void 0 || resume.completed === true ? -1 : node.body.findIndex((statement) => containsResumeTarget(statement, /* @__PURE__ */ new Set([resume.yieldNodeId])));
+    for (let index = Math.max(0, resumeIndex); index < node.body.length; index++) {
+      const statement = node.body[index];
+      result = await evaluateNode2(statement, blockContext);
+      if (result.kind !== "normal") {
+        return result;
+      }
     }
-  }
-  return result;
+    return result;
+  });
 }
 function predeclareBlockBindings2(node, scope) {
   const names = /* @__PURE__ */ new Set();
@@ -30524,6 +31484,12 @@ async function advanceAsyncCleanup(cleanup, budget, context) {
   try {
     while ((current = cleanup.resources.pop()) !== void 0) {
       budget.visitNode();
+      if (current.synchronous && cleanup.needsAwait && !cleanup.hasAwaited) {
+        cleanup.resources.push(current);
+        cleanup.needsAwait = false;
+        await wait(void 0, false);
+        return;
+      }
       if (current.method === void 0) {
         cleanup.needsAwait = true;
         continue;
@@ -30534,13 +31500,14 @@ async function advanceAsyncCleanup(cleanup, budget, context) {
       } catch (error) {
         if (isFatalSandboxError(error)) throw error;
         const value = createThrowCompletion(error, budget, context?.stack ?? []).value;
-        if (current.syncFallback) {
+        if (current.syncFallback && !current.synchronous) {
           await wait(value, true);
           return;
         }
         recordCleanupFailure(cleanup, value, budget, context);
         continue;
       }
+      if (current.synchronous) continue;
       await wait(current.syncFallback ? void 0 : result, false);
       return;
     }
@@ -31164,6 +32131,7 @@ function measureSandboxData(values, options = {}) {
       return;
     }
     if (isSandboxGenerator(value)) {
+      visit(asyncGeneratorDrivers.get(value), depth + 1);
       const descriptors2 = Object.getOwnPropertyDescriptors(getGeneratorProperties(value));
       for (const key of Reflect.ownKeys(descriptors2)) {
         const descriptor = descriptors2[key];
@@ -31178,6 +32146,7 @@ function measureSandboxData(values, options = {}) {
       return;
     }
     if (isSandboxPromise(value)) {
+      visit(asyncGeneratorRequestOwners.get(value), depth + 1);
       const settlement = promiseStates.get(value);
       if (settlement !== void 0 && settlement.status !== "pending") visit(settlement.value, depth + 1);
       const continuation = promiseContinuations.get(value);
@@ -46216,4 +47185,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-V3XJABDF.js.map
+//# sourceMappingURL=chunk-KHHM7HUO.js.map