@volter/tabnode 0.5.28 → 0.5.29

package/dist/assets/{runtime-worker-C6ulimZ4.js → runtime-worker-Dv_vTkXr.js}

@@ -6521,99 +6521,85 @@ forGuestRealm(() => {
   const realm = globalThis;
   if (!realm.__browserRuntimeHeldWork) takeFromHost(globalThis, "__browserRuntimeHeldWork", ownHeldWork);
 });
-class AsyncResource {
-  constructor(_type2, _options3) {
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runInAsyncScope(fn2, thisArg, ...args) {
-    return fn2.apply(thisArg, args);
-  }
-  emitDestroy() {
-    return this;
-  }
-  asyncId() {
-    return 0;
-  }
-  triggerAsyncId() {
-    return 0;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static bind(fn2, _type2) {
-    return fn2;
+const ROOT_FRAME = /* @__PURE__ */ new Map();
+let currentFrame = ROOT_FRAME;
+const nativeQueueMicrotask = globalThis.queueMicrotask.bind(globalThis);
+let resetQueued = false;
+const resetFrame = () => {
+  resetQueued = false;
+  currentFrame = ROOT_FRAME;
+};
+const resumeFrame = (frame) => {
+  if (frame === currentFrame) return;
+  currentFrame = frame;
+  if (!resetQueued) {
+    resetQueued = true;
+    nativeQueueMicrotask(resetFrame);
+  }
+};
+const withFrame = (frame, callback) => {
+  const previous = currentFrame;
+  currentFrame = frame;
+  try {
+    return callback();
+  } finally {
+    currentFrame = previous;
   }
-}
-const __substrateAsyncLocalStorages = /* @__PURE__ */ new Set();
+};
 class AsyncLocalStorage {
-  constructor() {
-    __publicField(this, "store");
-    __substrateAsyncLocalStorages.add(this);
-  }
   static snapshot() {
-    const captured = /* @__PURE__ */ new Map();
-    for (const storage of __substrateAsyncLocalStorages) captured.set(storage, storage.store);
-    return (callback, ...args) => {
-      const previous = /* @__PURE__ */ new Map();
-      for (const [storage, store] of captured) {
-        previous.set(storage, storage.store);
-        storage.store = store;
-      }
-      try {
-        return callback(...args);
-      } finally {
-        for (const [storage, store] of previous) storage.store = store;
-      }
-    };
+    const captured = currentFrame;
+    return (callback, ...args) => withFrame(captured, () => callback(...args));
   }
   static bind(callback) {
     const snapshot = AsyncLocalStorage.snapshot();
     return (...args) => snapshot(callback, ...args);
   }
   disable() {
+    if (!currentFrame.has(this)) return;
+    const next2 = new Map(currentFrame);
+    next2.delete(this);
+    currentFrame = next2;
   }
   getStore() {
-    return this.store;
+    return currentFrame.get(this);
   }
-  /**
-   * A store entered for an async callback used to be left the moment the
-   * callback returned its promise, so the first `await` inside a Server Action
-   * lost Next's request store and `cookies()` was "outside a request scope". A
-   * tab has no async_hooks and no AsyncContext, and an `await` of a native
-   * promise bypasses any `then` a patch could install, so the continuations
-   * cannot be followed. What can be done honestly is keep the store current
-   * until the callback's promise settles: exact for one run at a time, and
-   * last-entered-wins where two async runs overlap.
-   */
   run(store, callback, ...args) {
-    const prev = this.store;
-    this.store = store;
-    let result;
-    try {
-      result = callback(...args);
-    } catch (error) {
-      this.store = prev;
-      throw error;
-    }
-    if (result && typeof result.then === "function") {
-      const restore = () => {
-        if (this.store === store) this.store = prev;
-      };
-      result.then(restore, restore);
-      return result;
-    }
-    this.store = prev;
-    return result;
+    const next2 = new Map(currentFrame);
+    next2.set(this, store);
+    return withFrame(next2, () => callback(...args));
   }
   exit(callback) {
-    const prev = this.store;
-    this.store = void 0;
-    try {
-      return callback();
-    } finally {
-      this.store = prev;
-    }
+    const next2 = new Map(currentFrame);
+    next2.delete(this);
+    return withFrame(next2, callback);
   }
   enterWith(store) {
-    this.store = store;
+    const next2 = new Map(currentFrame);
+    next2.set(this, store);
+    currentFrame = next2;
+  }
+}
+class AsyncResource {
+  constructor(_type2, _options3) {
+    __publicField(this, "frame", currentFrame);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  runInAsyncScope(fn2, thisArg, ...args) {
+    return withFrame(this.frame, () => fn2.apply(thisArg, args));
+  }
+  emitDestroy() {
+    return this;
+  }
+  asyncId() {
+    return 0;
+  }
+  triggerAsyncId() {
+    return 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static bind(fn2, _type2) {
+    return AsyncLocalStorage.bind(fn2);
   }
 }
 forGuestRealm(() => {
@@ -6640,6 +6626,14 @@ forGuestRealm(() => {
   };
   takeFromHost(Promise.prototype, "then", carriedThen);
   takeFromHost(globalThis, "__substrateCarried", carried);
+  takeFromHost(globalThis, "__substrateContext", () => currentFrame);
+  takeFromHost(globalThis, "__substrateResume", (frame, value) => {
+    resumeFrame(frame);
+    return value;
+  });
+  takeFromHost(globalThis, "__substrateRestore", (frame) => {
+    resumeFrame(frame);
+  });
 });
 function createHook(_callbacks) {
   return {
@@ -78526,6 +78520,72 @@ function collectDirectEval(node, replacements) {
   replacements.push([source.start, source.start, "__substrateEvalSource("]);
   replacements.push([source.end, source.end, ")"]);
 }
+const ASYNC_FRAME = "__substrateAsyncFrame";
+const FOLLOW_MARK = "/*substrate*/";
+const FOLLOW_TAKE = `const ${ASYNC_FRAME}=__substrateContext();`;
+const FOLLOW_RESTORE = `__substrateRestore(${ASYNC_FRAME});`;
+const FOLLOW_RESUME_FRAMED = `__substrateResume(${ASYNC_FRAME},`;
+const FOLLOW_RESUME_TAKEN = "__substrateResume(__substrateContext(),";
+function __substrateFollowAwaits(code2) {
+  if (!/\bawait\b/.test(code2)) return code2;
+  let ast;
+  try {
+    ast = parse3(code2, { ecmaVersion: "latest", sourceType: "script", allowReturnOutsideFunction: true, allowHashBang: true, allowAwaitOutsideFunction: true });
+  } catch {
+    return code2;
+  }
+  const edits = [];
+  const insert = (at3, text) => {
+    edits.push([at3, at3, text]);
+  };
+  const isFunction = (node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+  const visit = (node, framed, parent) => {
+    if (isFunction(node)) {
+      framed = node.async && node.body.type === "BlockStatement";
+      if (framed) {
+        const directives = node.body.body.filter((statement) => statement.directive !== void 0);
+        const at3 = directives.length ? directives[directives.length - 1].end : node.body.start + 1;
+        insert(at3, FOLLOW_TAKE);
+      }
+    } else if (node.type === "AwaitExpression") {
+      insert(node.start, framed ? FOLLOW_RESUME_FRAMED : FOLLOW_RESUME_TAKEN);
+      insert(node.end, `${FOLLOW_MARK})`);
+    } else if (framed && node.type === "CatchClause") {
+      insert(node.body.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === "TryStatement" && node.finalizer) {
+      insert(node.finalizer.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === "ForOfStatement" && node.await) {
+      const whole = (parent == null ? void 0 : parent.type) === "LabeledStatement" ? parent : node;
+      insert(whole.start, `{${FOLLOW_MARK}`);
+      insert(whole.end, `;${FOLLOW_RESTORE}${FOLLOW_MARK}}`);
+      if (node.body.type === "BlockStatement") insert(node.body.start + 1, FOLLOW_RESTORE);
+      else {
+        insert(node.body.start, `{${FOLLOW_MARK}${FOLLOW_RESTORE}`);
+        insert(node.body.end, `${FOLLOW_MARK}}`);
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+      const child = node[key];
+      if (!child || typeof child !== "object") continue;
+      if (Array.isArray(child)) {
+        for (const item of child) if (item && typeof item.type === "string") visit(item, framed, node);
+      } else if (typeof child.type === "string") visit(child, framed, node);
+    }
+  };
+  visit(ast, false, void 0);
+  return edits.length ? applyReplacements(code2, edits) : code2;
+}
+function __substrateUnfollowAwaits(source) {
+  if (!source.includes("__substrate")) return source;
+  return source.replaceAll(`;${FOLLOW_RESTORE}${FOLLOW_MARK}}`, "").replaceAll(`{${FOLLOW_MARK}${FOLLOW_RESTORE}`, "").replaceAll(`{${FOLLOW_MARK}`, "").replaceAll(`${FOLLOW_MARK}}`, "").replaceAll(`${FOLLOW_MARK})`, "").replaceAll(FOLLOW_TAKE, "").replaceAll(FOLLOW_RESTORE, "").replaceAll(FOLLOW_RESUME_FRAMED, "").replaceAll(FOLLOW_RESUME_TAKEN, "");
+}
+forGuestRealm(() => {
+  const native = Function.prototype.toString;
+  takeFromHost(Function.prototype, "toString", function toString2() {
+    return __substrateUnfollowAwaits(native.call(this));
+  });
+});
 function applyReplacements(code2, replacements) {
   replacements.sort((a, b) => b[0] - a[0] || b[1] - a[1]);
   let out = code2;
@@ -78549,10 +78609,10 @@ function __substratePrepareBody(rawCode, resolvedPath, format2, process2) {
   } else {
     code2 = __substrateRewriteDynamicImportsInScript(code2);
   }
-  return code2;
+  return __substrateFollowAwaits(code2);
 }
 const PREPARED_MODULES_DIR = "/.tabnode/prepared";
-const PREPARED_MODULES_FORMAT = "tabnode-prepared-1";
+const PREPARED_MODULES_FORMAT = "tabnode-prepared-2";
 function preparedModuleKey(rawCode, resolvedPath) {
   var _a3;
   const extension = (_a3 = /\.(js|cjs|mjs)$/u.exec(resolvedPath)) == null ? void 0 : _a3[1];

package/dist/index.mjs

@@ -6202,99 +6202,85 @@ const bufferBinding = {
   setBufferPrototype,
   createFromString
 };
-class AsyncResource {
-  constructor(_type2, _options2) {
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runInAsyncScope(fn, thisArg, ...args) {
-    return fn.apply(thisArg, args);
-  }
-  emitDestroy() {
-    return this;
-  }
-  asyncId() {
-    return 0;
-  }
-  triggerAsyncId() {
-    return 0;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static bind(fn, _type2) {
-    return fn;
+const ROOT_FRAME = /* @__PURE__ */ new Map();
+let currentFrame = ROOT_FRAME;
+const nativeQueueMicrotask = globalThis.queueMicrotask.bind(globalThis);
+let resetQueued = false;
+const resetFrame = () => {
+  resetQueued = false;
+  currentFrame = ROOT_FRAME;
+};
+const resumeFrame = (frame) => {
+  if (frame === currentFrame) return;
+  currentFrame = frame;
+  if (!resetQueued) {
+    resetQueued = true;
+    nativeQueueMicrotask(resetFrame);
+  }
+};
+const withFrame = (frame, callback) => {
+  const previous = currentFrame;
+  currentFrame = frame;
+  try {
+    return callback();
+  } finally {
+    currentFrame = previous;
   }
-}
-const __substrateAsyncLocalStorages = /* @__PURE__ */ new Set();
+};
 class AsyncLocalStorage {
-  constructor() {
-    __publicField(this, "store");
-    __substrateAsyncLocalStorages.add(this);
-  }
   static snapshot() {
-    const captured = /* @__PURE__ */ new Map();
-    for (const storage of __substrateAsyncLocalStorages) captured.set(storage, storage.store);
-    return (callback, ...args) => {
-      const previous = /* @__PURE__ */ new Map();
-      for (const [storage, store] of captured) {
-        previous.set(storage, storage.store);
-        storage.store = store;
-      }
-      try {
-        return callback(...args);
-      } finally {
-        for (const [storage, store] of previous) storage.store = store;
-      }
-    };
+    const captured = currentFrame;
+    return (callback, ...args) => withFrame(captured, () => callback(...args));
   }
   static bind(callback) {
     const snapshot = AsyncLocalStorage.snapshot();
     return (...args) => snapshot(callback, ...args);
   }
   disable() {
+    if (!currentFrame.has(this)) return;
+    const next = new Map(currentFrame);
+    next.delete(this);
+    currentFrame = next;
   }
   getStore() {
-    return this.store;
+    return currentFrame.get(this);
   }
-  /**
-   * A store entered for an async callback used to be left the moment the
-   * callback returned its promise, so the first `await` inside a Server Action
-   * lost Next's request store and `cookies()` was "outside a request scope". A
-   * tab has no async_hooks and no AsyncContext, and an `await` of a native
-   * promise bypasses any `then` a patch could install, so the continuations
-   * cannot be followed. What can be done honestly is keep the store current
-   * until the callback's promise settles: exact for one run at a time, and
-   * last-entered-wins where two async runs overlap.
-   */
   run(store, callback, ...args) {
-    const prev = this.store;
-    this.store = store;
-    let result;
-    try {
-      result = callback(...args);
-    } catch (error) {
-      this.store = prev;
-      throw error;
-    }
-    if (result && typeof result.then === "function") {
-      const restore = () => {
-        if (this.store === store) this.store = prev;
-      };
-      result.then(restore, restore);
-      return result;
-    }
-    this.store = prev;
-    return result;
+    const next = new Map(currentFrame);
+    next.set(this, store);
+    return withFrame(next, () => callback(...args));
   }
   exit(callback) {
-    const prev = this.store;
-    this.store = void 0;
-    try {
-      return callback();
-    } finally {
-      this.store = prev;
-    }
+    const next = new Map(currentFrame);
+    next.delete(this);
+    return withFrame(next, callback);
   }
   enterWith(store) {
-    this.store = store;
+    const next = new Map(currentFrame);
+    next.set(this, store);
+    currentFrame = next;
+  }
+}
+class AsyncResource {
+  constructor(_type2, _options2) {
+    __publicField(this, "frame", currentFrame);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  runInAsyncScope(fn, thisArg, ...args) {
+    return withFrame(this.frame, () => fn.apply(thisArg, args));
+  }
+  emitDestroy() {
+    return this;
+  }
+  asyncId() {
+    return 0;
+  }
+  triggerAsyncId() {
+    return 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static bind(fn, _type2) {
+    return AsyncLocalStorage.bind(fn);
   }
 }
 forGuestRealm(() => {
@@ -6321,6 +6307,14 @@ forGuestRealm(() => {
   };
   takeFromHost(Promise.prototype, "then", carriedThen);
   takeFromHost(globalThis, "__substrateCarried", carried);
+  takeFromHost(globalThis, "__substrateContext", () => currentFrame);
+  takeFromHost(globalThis, "__substrateResume", (frame, value) => {
+    resumeFrame(frame);
+    return value;
+  });
+  takeFromHost(globalThis, "__substrateRestore", (frame) => {
+    resumeFrame(frame);
+  });
 });
 function createHook(_callbacks) {
   return {
@@ -38184,6 +38178,72 @@ function collectDirectEval(node, replacements) {
   replacements.push([source.start, source.start, "__substrateEvalSource("]);
   replacements.push([source.end, source.end, ")"]);
 }
+const ASYNC_FRAME = "__substrateAsyncFrame";
+const FOLLOW_MARK = "/*substrate*/";
+const FOLLOW_TAKE = `const ${ASYNC_FRAME}=__substrateContext();`;
+const FOLLOW_RESTORE = `__substrateRestore(${ASYNC_FRAME});`;
+const FOLLOW_RESUME_FRAMED = `__substrateResume(${ASYNC_FRAME},`;
+const FOLLOW_RESUME_TAKEN = "__substrateResume(__substrateContext(),";
+function __substrateFollowAwaits(code2) {
+  if (!/\bawait\b/.test(code2)) return code2;
+  let ast;
+  try {
+    ast = parse3(code2, { ecmaVersion: "latest", sourceType: "script", allowReturnOutsideFunction: true, allowHashBang: true, allowAwaitOutsideFunction: true });
+  } catch {
+    return code2;
+  }
+  const edits = [];
+  const insert = (at2, text) => {
+    edits.push([at2, at2, text]);
+  };
+  const isFunction = (node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+  const visit = (node, framed, parent) => {
+    if (isFunction(node)) {
+      framed = node.async && node.body.type === "BlockStatement";
+      if (framed) {
+        const directives = node.body.body.filter((statement) => statement.directive !== void 0);
+        const at2 = directives.length ? directives[directives.length - 1].end : node.body.start + 1;
+        insert(at2, FOLLOW_TAKE);
+      }
+    } else if (node.type === "AwaitExpression") {
+      insert(node.start, framed ? FOLLOW_RESUME_FRAMED : FOLLOW_RESUME_TAKEN);
+      insert(node.end, `${FOLLOW_MARK})`);
+    } else if (framed && node.type === "CatchClause") {
+      insert(node.body.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === "TryStatement" && node.finalizer) {
+      insert(node.finalizer.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === "ForOfStatement" && node.await) {
+      const whole = (parent == null ? void 0 : parent.type) === "LabeledStatement" ? parent : node;
+      insert(whole.start, `{${FOLLOW_MARK}`);
+      insert(whole.end, `;${FOLLOW_RESTORE}${FOLLOW_MARK}}`);
+      if (node.body.type === "BlockStatement") insert(node.body.start + 1, FOLLOW_RESTORE);
+      else {
+        insert(node.body.start, `{${FOLLOW_MARK}${FOLLOW_RESTORE}`);
+        insert(node.body.end, `${FOLLOW_MARK}}`);
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") continue;
+      const child = node[key];
+      if (!child || typeof child !== "object") continue;
+      if (Array.isArray(child)) {
+        for (const item of child) if (item && typeof item.type === "string") visit(item, framed, node);
+      } else if (typeof child.type === "string") visit(child, framed, node);
+    }
+  };
+  visit(ast, false, void 0);
+  return edits.length ? applyReplacements(code2, edits) : code2;
+}
+function __substrateUnfollowAwaits(source) {
+  if (!source.includes("__substrate")) return source;
+  return source.replaceAll(`;${FOLLOW_RESTORE}${FOLLOW_MARK}}`, "").replaceAll(`{${FOLLOW_MARK}${FOLLOW_RESTORE}`, "").replaceAll(`{${FOLLOW_MARK}`, "").replaceAll(`${FOLLOW_MARK}}`, "").replaceAll(`${FOLLOW_MARK})`, "").replaceAll(FOLLOW_TAKE, "").replaceAll(FOLLOW_RESTORE, "").replaceAll(FOLLOW_RESUME_FRAMED, "").replaceAll(FOLLOW_RESUME_TAKEN, "");
+}
+forGuestRealm(() => {
+  const native = Function.prototype.toString;
+  takeFromHost(Function.prototype, "toString", function toString2() {
+    return __substrateUnfollowAwaits(native.call(this));
+  });
+});
 function applyReplacements(code2, replacements) {
   replacements.sort((a, b) => b[0] - a[0] || b[1] - a[1]);
   let out = code2;
@@ -38207,10 +38267,10 @@ function __substratePrepareBody(rawCode, resolvedPath, format2, process2) {
   } else {
     code2 = __substrateRewriteDynamicImportsInScript(code2);
   }
-  return code2;
+  return __substrateFollowAwaits(code2);
 }
 const PREPARED_MODULES_DIR = "/.tabnode/prepared";
-const PREPARED_MODULES_FORMAT = "tabnode-prepared-1";
+const PREPARED_MODULES_FORMAT = "tabnode-prepared-2";
 function preparedModuleKey(rawCode, resolvedPath) {
   var _a2;
   const extension = (_a2 = /\.(js|cjs|mjs)$/u.exec(resolvedPath)) == null ? void 0 : _a2[1];
@@ -40169,7 +40229,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-C6ulimZ4.js",
+        "/assets/runtime-worker-Dv_vTkXr.js",
         import.meta.url
       ),
       { type: "module" }

package/dist/shims/async_hooks.d.ts

@@ -1,35 +1,26 @@
 /**
- * async_hooks shim - Async tracking is not available in browser
+ * async_hooks shim: AsyncLocalStorage and AsyncResource carry context the way
+ * Node's do; the hooks themselves are not available in a browser.
  */
-export declare class AsyncResource {
-    constructor(_type: string, _options?: object);
-    runInAsyncScope<T>(fn: (...args: any[]) => T, thisArg?: unknown, ...args: any[]): T;
-    emitDestroy(): this;
-    asyncId(): number;
-    triggerAsyncId(): number;
-    static bind<T extends (...args: any[]) => any>(fn: T, _type?: string): T;
-}
 export declare class AsyncLocalStorage<T> {
-    private store;
-    constructor();
     static snapshot(): (callback: (...args: unknown[]) => unknown, ...args: unknown[]) => unknown;
     static bind(callback: (...args: unknown[]) => unknown): (...args: unknown[]) => unknown;
     disable(): void;
     getStore(): T | undefined;
-    /**
-     * A store entered for an async callback used to be left the moment the
-     * callback returned its promise, so the first `await` inside a Server Action
-     * lost Next's request store and `cookies()` was "outside a request scope". A
-     * tab has no async_hooks and no AsyncContext, and an `await` of a native
-     * promise bypasses any `then` a patch could install, so the continuations
-     * cannot be followed. What can be done honestly is keep the store current
-     * until the callback's promise settles: exact for one run at a time, and
-     * last-entered-wins where two async runs overlap.
-     */
     run<R>(store: T, callback: (...args: unknown[]) => R, ...args: unknown[]): R;
     exit<R>(callback: () => R): R;
     enterWith(store: T): void;
 }
+/** Runs its callbacks in the context it was made in, as Node's does. */
+export declare class AsyncResource {
+    private readonly frame;
+    constructor(_type: string, _options?: object);
+    runInAsyncScope<T>(fn: (...args: any[]) => T, thisArg?: unknown, ...args: any[]): T;
+    emitDestroy(): this;
+    asyncId(): number;
+    triggerAsyncId(): number;
+    static bind<T extends (...args: any[]) => any>(fn: T, _type?: string): T;
+}
 export interface AsyncHook {
     enable(): this;
     disable(): this;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.28",
+  "version": "0.5.29",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",

package/src/runtime.ts

@@ -436,6 +436,97 @@ function collectDirectEval(node: any, replacements: Array<[number, number, strin
   replacements.push([source.end, source.end, ")"]);
 }
 
+/**
+ * Node's AsyncLocalStorage context follows an `await`; in a tab nothing can
+ * observe one (see shims/async_hooks), so the body follows it itself. An async
+ * function takes its frame on entry and puts it back wherever it resumes:
+ * after each `await`, at the start of a `catch` or `finally` (a rejected
+ * `await` resumes there), and in and after a `for await`. An async arrow with
+ * an expression body takes the frame at each `await`, which is the same
+ * frame. Playwright names each API call from a zone it keeps in one; a zone
+ * left over from another call made its errors lose `locator.click:`. Only
+ * insertions, and no line breaks, so a stack frame keeps its line.
+ */
+const ASYNC_FRAME = '__substrateAsyncFrame';
+// Every fragment the pass inserts is one of these strings or ends in the
+// marker, so a function's source can be given back as it was written (below).
+const FOLLOW_MARK = '/*substrate*/';
+const FOLLOW_TAKE = `const ${ASYNC_FRAME}=__substrateContext();`;
+const FOLLOW_RESTORE = `__substrateRestore(${ASYNC_FRAME});`;
+const FOLLOW_RESUME_FRAMED = `__substrateResume(${ASYNC_FRAME},`;
+const FOLLOW_RESUME_TAKEN = '__substrateResume(__substrateContext(),';
+function __substrateFollowAwaits(code: string): string {
+  if (!/\bawait\b/.test(code)) return code;
+  let ast;
+  try {
+    ast = acorn.parse(code, { ecmaVersion: "latest", sourceType: "script", allowReturnOutsideFunction: true, allowHashBang: true, allowAwaitOutsideFunction: true });
+  } catch {
+    return code;
+  }
+  const edits: Array<[number, number, string]> = [];
+  const insert = (at: number, text: string): void => { edits.push([at, at, text]); };
+  const isFunction = (node: any): boolean => node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
+  // `framed`: the nearest function is async and holds the frame in ASYNC_FRAME.
+  const visit = (node: any, framed: boolean, parent: any): void => {
+    if (isFunction(node)) {
+      framed = node.async && node.body.type === 'BlockStatement';
+      if (framed) {
+        const directives = node.body.body.filter((statement: any) => statement.directive !== undefined);
+        const at = directives.length ? directives[directives.length - 1].end : node.body.start + 1;
+        insert(at, FOLLOW_TAKE);
+      }
+    } else if (node.type === 'AwaitExpression') {
+      insert(node.start, framed ? FOLLOW_RESUME_FRAMED : FOLLOW_RESUME_TAKEN);
+      insert(node.end, `${FOLLOW_MARK})`);
+    } else if (framed && node.type === 'CatchClause') {
+      insert(node.body.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === 'TryStatement' && node.finalizer) {
+      insert(node.finalizer.start + 1, FOLLOW_RESTORE);
+    } else if (framed && node.type === 'ForOfStatement' && node.await) {
+      // The loop's own wrap first: where its end is the body's, an insertion
+      // made later lands before it, so the body's brace closes inside.
+      const whole = parent?.type === 'LabeledStatement' ? parent : node;
+      insert(whole.start, `{${FOLLOW_MARK}`);
+      insert(whole.end, `;${FOLLOW_RESTORE}${FOLLOW_MARK}}`);
+      if (node.body.type === 'BlockStatement') insert(node.body.start + 1, FOLLOW_RESTORE);
+      else { insert(node.body.start, `{${FOLLOW_MARK}${FOLLOW_RESTORE}`); insert(node.body.end, `${FOLLOW_MARK}}`); }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === 'type' || key === 'start' || key === 'end' || key === 'loc' || key === 'range') continue;
+      const child = node[key];
+      if (!child || typeof child !== 'object') continue;
+      if (Array.isArray(child)) {
+        for (const item of child) if (item && typeof item.type === 'string') visit(item, framed, node);
+      } else if (typeof child.type === 'string') visit(child, framed, node);
+    }
+  };
+  visit(ast, false, undefined);
+  return edits.length ? applyReplacements(code, edits) : code;
+}
+
+/**
+ * A function's source as it was written. Playwright sends the source of the
+ * function a test evaluates to the browser, where the pass's calls do not
+ * exist; the pass only inserts, so removing its fragments gives the text back.
+ */
+function __substrateUnfollowAwaits(source: string): string {
+  if (!source.includes('__substrate')) return source;
+  return source
+    .replaceAll(`;${FOLLOW_RESTORE}${FOLLOW_MARK}}`, '')
+    .replaceAll(`{${FOLLOW_MARK}${FOLLOW_RESTORE}`, '')
+    .replaceAll(`{${FOLLOW_MARK}`, '')
+    .replaceAll(`${FOLLOW_MARK}}`, '')
+    .replaceAll(`${FOLLOW_MARK})`, '')
+    .replaceAll(FOLLOW_TAKE, '')
+    .replaceAll(FOLLOW_RESTORE, '')
+    .replaceAll(FOLLOW_RESUME_FRAMED, '')
+    .replaceAll(FOLLOW_RESUME_TAKEN, '');
+}
+forGuestRealm(() => {
+  const native = Function.prototype.toString;
+  takeFromHost(Function.prototype, 'toString', function toString(this: unknown): string { return __substrateUnfollowAwaits(native.call(this)); });
+});
+
 /** Applies insertions and replacements from the end, so earlier offsets hold. */
 function applyReplacements(code: string, replacements: Array<[number, number, string]>): string {
   replacements.sort((a, b) => b[0] - a[0] || b[1] - a[1]);
@@ -448,7 +539,7 @@ Object.defineProperty(globalThis, "__substrateEvalSource", {
   configurable: true,
   value: (source: unknown): unknown => typeof source === "string" ? __substrateRewriteDynamicImportsInScript(source) : source,
 });
-/** A file's source made a body: shebang stripped, types stripped, ESM lowered, dynamic imports rewritten. */
+/** A file's source made a body: shebang stripped, types stripped, ESM lowered, dynamic imports rewritten, awaits followed. */
 function __substratePrepareBody(rawCode: string, resolvedPath: string, format: string | undefined, process: unknown): string {
   let code = rawCode;
 
@@ -487,7 +578,7 @@ function __substratePrepareBody(rawCode: string, resolvedPath: string, format: s
     code = __substrateRewriteDynamicImportsInScript(code);
   }
 
-  return code;
+  return __substrateFollowAwaits(code);
 }
 
 /**
@@ -499,7 +590,7 @@ function __substratePrepareBody(rawCode: string, resolvedPath: string, format: s
  * place of the passes when the file it read hashes to one.
  */
 export const PREPARED_MODULES_DIR = '/.tabnode/prepared';
-const PREPARED_MODULES_FORMAT = 'tabnode-prepared-1';
+const PREPARED_MODULES_FORMAT = 'tabnode-prepared-2';
 /** The name a prepared body goes under: the hash of the file as read, and how it is compiled. Undefined for a file no body is prepared for. */
 export function preparedModuleKey(rawCode: string, resolvedPath: string): string | undefined {
   const extension = /\.(js|cjs|mjs)$/u.exec(resolvedPath)?.[1];

package/src/shims/async_hooks.ts

@@ -1,109 +1,105 @@
 /**
- * async_hooks shim - Async tracking is not available in browser
+ * async_hooks shim: AsyncLocalStorage and AsyncResource carry context the way
+ * Node's do; the hooks themselves are not available in a browser.
  */
 
 import { forGuestRealm, takeFromHost } from '../host-globals';
 
-export class AsyncResource {
-  constructor(_type: string, _options?: object) {}
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  runInAsyncScope<T>(fn: (...args: any[]) => T, thisArg?: unknown, ...args: any[]): T {
-    return fn.apply(thisArg, args);
-  }
-
-  emitDestroy(): this { return this; }
-  asyncId(): number { return 0; }
-  triggerAsyncId(): number { return 0; }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static bind<T extends (...args: any[]) => any>(fn: T, _type?: string): T {
-    return fn;
-  }
-}
-
 /**
- * `AsyncLocalStorage.snapshot()` captures every storage's current store and
- * answers a function that runs a call inside that capture, which Next's
- * request-store constructors use to carry a request's context into the work
- * they schedule. These storages are store slots with no such capture; every
- * storage registers itself, and a snapshot is the slots as they are, restored
- * around the call and put back after.
+ * The context a continuation runs in: every storage's store, as one frame.
+ * `run` makes a new frame for its callback and puts the old one back when the
+ * callback returns, as Node's does; a frame is never changed after it is
+ * made, so a snapshot is the frame itself.
+ *
+ * A tab has no async hooks and no AsyncContext, and an `await` of a native
+ * promise bypasses any `then` a patch installs. The engine follows it at the
+ * source instead: each module body it compiles captures its async function's
+ * frame on entry and restores it where the function resumes (after each
+ * `await`, in a `catch` or `finally`, around a `for await`), through
+ * `__substrateResume` and `__substrateRestore` below. A continuation's frame
+ * holds only for the turn it runs in; the next turn starts from the root, as
+ * a macrotask of Node's does. Code the engine did not compile (its own) runs
+ * in whichever frame is current when it is called.
  */
-const __substrateAsyncLocalStorages = new Set<AsyncLocalStorage<unknown>>();
-
-export class AsyncLocalStorage<T> {
-  private store: T | undefined;
-
-  constructor() {
-    __substrateAsyncLocalStorages.add(this as AsyncLocalStorage<unknown>);
+type ContextFrame = ReadonlyMap<AsyncLocalStorage<unknown>, unknown>;
+const ROOT_FRAME: ContextFrame = new Map();
+let currentFrame: ContextFrame = ROOT_FRAME;
+const nativeQueueMicrotask = globalThis.queueMicrotask.bind(globalThis);
+let resetQueued = false;
+const resetFrame = (): void => { resetQueued = false; currentFrame = ROOT_FRAME; };
+/** A resumed continuation's frame, current until the turn it runs in ends. */
+const resumeFrame = (frame: ContextFrame): void => {
+  if (frame === currentFrame) return;
+  currentFrame = frame;
+  if (!resetQueued) { resetQueued = true; nativeQueueMicrotask(resetFrame); }
+};
+const withFrame = <R>(frame: ContextFrame, callback: () => R): R => {
+  const previous = currentFrame;
+  currentFrame = frame;
+  try {
+    return callback();
+  } finally {
+    currentFrame = previous;
   }
+};
 
+export class AsyncLocalStorage<T> {
   static snapshot() {
-    const captured = new Map<AsyncLocalStorage<unknown>, unknown>();
-    for (const storage of __substrateAsyncLocalStorages) captured.set(storage, storage.store);
-    return (callback: (...args: unknown[]) => unknown, ...args: unknown[]) => {
-      const previous = new Map<AsyncLocalStorage<unknown>, unknown>();
-      for (const [storage, store] of captured) { previous.set(storage, storage.store); storage.store = store; }
-      try {
-        return callback(...args);
-      } finally {
-        for (const [storage, store] of previous) storage.store = store;
-      }
-    };
+    const captured = currentFrame;
+    return (callback: (...args: unknown[]) => unknown, ...args: unknown[]) => withFrame(captured, () => callback(...args));
   }
   static bind(callback: (...args: unknown[]) => unknown) {
     const snapshot = AsyncLocalStorage.snapshot();
     return (...args: unknown[]) => snapshot(callback, ...args);
   }
 
-  disable(): void {}
+  disable(): void {
+    if (!currentFrame.has(this as AsyncLocalStorage<unknown>)) return;
+    const next = new Map(currentFrame);
+    next.delete(this as AsyncLocalStorage<unknown>);
+    currentFrame = next;
+  }
 
   getStore(): T | undefined {
-    return this.store;
+    return currentFrame.get(this as AsyncLocalStorage<unknown>) as T | undefined;
   }
 
-  /**
-   * A store entered for an async callback used to be left the moment the
-   * callback returned its promise, so the first `await` inside a Server Action
-   * lost Next's request store and `cookies()` was "outside a request scope". A
-   * tab has no async_hooks and no AsyncContext, and an `await` of a native
-   * promise bypasses any `then` a patch could install, so the continuations
-   * cannot be followed. What can be done honestly is keep the store current
-   * until the callback's promise settles: exact for one run at a time, and
-   * last-entered-wins where two async runs overlap.
-   */
   run<R>(store: T, callback: (...args: unknown[]) => R, ...args: unknown[]): R {
-    const prev = this.store;
-    this.store = store;
-    let result;
-    try {
-      result = callback(...args);
-    } catch (error) {
-      this.store = prev;
-      throw error;
-    }
-    if (result && typeof (result as { then?: unknown }).then === 'function') {
-      const restore = () => { if (this.store === store) this.store = prev; };
-      (result as unknown as Promise<unknown>).then(restore, restore);
-      return result;
-    }
-    this.store = prev;
-    return result;
+    const next = new Map(currentFrame);
+    next.set(this as AsyncLocalStorage<unknown>, store);
+    return withFrame(next, () => callback(...args));
   }
 
   exit<R>(callback: () => R): R {
-    const prev = this.store;
-    this.store = undefined;
-    try {
-      return callback();
-    } finally {
-      this.store = prev;
-    }
+    const next = new Map(currentFrame);
+    next.delete(this as AsyncLocalStorage<unknown>);
+    return withFrame(next, callback);
   }
 
   enterWith(store: T): void {
-    this.store = store;
+    const next = new Map(currentFrame);
+    next.set(this as AsyncLocalStorage<unknown>, store);
+    currentFrame = next;
+  }
+}
+
+/** Runs its callbacks in the context it was made in, as Node's does. */
+export class AsyncResource {
+  private readonly frame = currentFrame;
+  constructor(_type: string, _options?: object) {}
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  runInAsyncScope<T>(fn: (...args: any[]) => T, thisArg?: unknown, ...args: any[]): T {
+    return withFrame(this.frame, () => fn.apply(thisArg, args));
+  }
+
+  emitDestroy(): this { return this; }
+  asyncId(): number { return 0; }
+  triggerAsyncId(): number { return 0; }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static bind<T extends (...args: any[]) => any>(fn: T, _type?: string): T {
+    return AsyncLocalStorage.bind(fn) as T;
   }
 }
 
@@ -112,10 +108,10 @@ export class AsyncLocalStorage<T> {
  * schedules: a timer, an immediate, a microtask, a nextTick, a promise
  * callback. A tab has no async hooks, so each of those is wrapped once to
  * capture the stores current when it was scheduled and restore them when it
- * runs. A native `await` is the one continuation this cannot follow, which
- * `run` covers by holding its store until the callback settles. React's
- * server renderer schedules its work on immediates and promises, and read
- * Next's request store through them.
+ * runs. A native `await` is the one continuation this cannot follow: the
+ * compiled module body follows it, through the three globals installed here.
+ * React's server renderer schedules its work on immediates and promises, and
+ * read Next's request store through them.
  *
  * The wrapping is a guest's, not the realm's. It used to run at load, so
  * importing the engine into a Node process replaced that process's own
@@ -145,6 +141,10 @@ forGuestRealm(() => {
   ): Promise<TFulfilled | TRejected> { return then.call(this, carried(onFulfilled), carried(onRejected)) as Promise<TFulfilled | TRejected>; };
   takeFromHost(Promise.prototype, 'then', carriedThen);
   takeFromHost(globalThis, '__substrateCarried', carried);
+  // An async function's frame, taken on entry; put back where it resumes.
+  takeFromHost(globalThis, '__substrateContext', () => currentFrame);
+  takeFromHost(globalThis, '__substrateResume', <V>(frame: ContextFrame, value: V): V => { resumeFrame(frame); return value; });
+  takeFromHost(globalThis, '__substrateRestore', (frame: ContextFrame): void => { resumeFrame(frame); });
 });
 
 export interface AsyncHook {