async_hooks,events,http,http2,perf_hooks: port Node.js async compatibility tests and fix the gaps they surface — ALS run/disable + withScope/defaultValue, http client ALS across reused agent sockets, http2 ALS context, AsyncResource.bind, EventEmitterAsyncResource, timerify (+22 tests)

src/js/internal/async_context_frame.ts

@@ -1,16 +1,39 @@
-// Minimal port of node's lib/internal/async_context_frame.js surface for
-// --expose-internals consumers (vendored node tests).
+// Port of node's lib/internal/async_context_frame.js surface for
+// --expose-internals consumers (vendored node tests) and for Bun's own
+// built-ins that need to swap the active async-context frame around a
+// callback — the JS-side equivalent of the native
+// AsyncContextFrame::call / withAsyncContextIfNeeded.
 //
 // Bun tracks async context natively in the engine (AsyncLocalStorage rides
-// JSC's async context), so context propagation is always enabled. Frame
-// objects, however, are never materialized — current() has nothing to
-// expose and returns undefined. This diverges from node, where enabled
-// implies current() is non-null inside a frame; tests relying on that
-// coupling (rather than on enabled/falsiness checks) will not pass.
+// JSC's async context), so context propagation is always enabled and the
+// "frame" is the raw internal-field value (an even-length [ALS, value, ...]
+// array or undefined) — see the comment at the top of node/async_hooks.ts.
 const AsyncContextFrame = {
   enabled: true,
   current() {
-    return undefined;
+    return $getInternalField($asyncContext, 0);
+  },
+  /** Install `frame` as the active async-context frame; returns the previous one. */
+  exchange(frame) {
+    const prev = $getInternalField($asyncContext, 0);
+    $putInternalField($asyncContext, 0, frame);
+    return prev;
+  },
+  /**
+   * Call `fn` with `frame` installed as the active async-context frame,
+   * restoring the previous frame afterwards. Fast-paths when `frame` is
+   * already active (which includes the "no ALS in use anywhere" case where
+   * both are undefined).
+   */
+  run(frame, fn, thisArg?, ...args) {
+    const prev = $getInternalField($asyncContext, 0);
+    if (frame === prev) return fn.$apply(thisArg, args);
+    $putInternalField($asyncContext, 0, frame);
+    try {
+      return fn.$apply(thisArg, args);
+    } finally {
+      $putInternalField($asyncContext, 0, prev);
+    }
   },
 };
 

src/js/internal/shared.ts

@@ -163,12 +163,55 @@ const observerCounts = new Map();
 const kObservers = new Set();
 
 /** Entry types routed through this JS-side registry instead of the native observer. */
-const kNodeEntryTypes = new Set(["net", "dns", "http"]);
+const kNodeEntryTypes = new Set(["net", "dns", "http", "function"]);
 
 function hasObserver(type) {
   return (observerCounts.get(type) ?? 0) > 0;
 }
 
+/**
+ * Hand a finished entry to every registered observer. Used by callers that
+ * construct the entry themselves (e.g. perf_hooks timerify) instead of the
+ * startPerf/stopPerf pair.
+ */
+function enqueueNodeEntry(entry) {
+  for (const observer of kObservers) {
+    observer.bufferEntry(entry);
+  }
+}
+
+// Node's PerformanceNodeEntry — the shape used by every JS-side entry type
+// ('function', 'net', 'dns', 'http'). Lives here (not in perf_hooks.ts) so
+// stopPerf can construct it without a circular require. The prototype chain
+// is linked to PerformanceEntry by perf_hooks.ts at load time using its
+// captured global (every construction is gated behind hasObserver(), which
+// is only true after perf_hooks has loaded).
+class PerformanceNodeEntry {
+  name;
+  entryType;
+  startTime;
+  duration;
+  detail;
+
+  constructor(name, entryType, startTime, duration, detail) {
+    this.name = name;
+    this.entryType = entryType;
+    this.startTime = startTime;
+    this.duration = duration;
+    this.detail = detail;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      entryType: this.entryType,
+      startTime: this.startTime,
+      duration: this.duration,
+      detail: this.detail,
+    };
+  }
+}
+
 function startPerf(target, key, context) {
   context.startTime = performance.now();
   target[key] = context;
@@ -181,19 +224,11 @@ function stopPerf(target, key, context) {
   }
   target[key] = undefined;
   const startTime = ctx.startTime;
-  const entry = {
-    name: ctx.name,
-    entryType: ctx.type,
-    startTime,
-    duration: performance.now() - startTime,
-    // Node.js merges the detail recorded at startPerf() with the detail
-    // passed to stopPerf() (e.g. http entries carry both req and res).
-    detail:
-      ctx.detail !== undefined || context?.detail !== undefined ? { ...ctx.detail, ...context?.detail } : undefined,
-  };
-  for (const observer of kObservers) {
-    observer.bufferEntry(entry);
-  }
+  // Node.js merges the detail recorded at startPerf() with the detail
+  // passed to stopPerf() (e.g. http entries carry both req and res).
+  const detail =
+    ctx.detail !== undefined || context?.detail !== undefined ? { ...ctx.detail, ...context?.detail } : undefined;
+  enqueueNodeEntry(new PerformanceNodeEntry(ctx.name, ctx.type, startTime, performance.now() - startTime, detail));
 }
 
 /**
@@ -286,8 +321,10 @@ export default {
   hasObserver,
   startPerf,
   stopPerf,
+  enqueueNodeEntry,
   kNodeEntryTypes,
   NodeEntryObserver,
+  PerformanceNodeEntry,
 
   kHandle: Symbol("kHandle"),
   kAutoDestroyed: Symbol("kAutoDestroyed"),

src/js/node/_http_client.ts

@@ -83,6 +83,19 @@ class HTTPClientAsyncResource {
   }
 }
 
+// Node's parser AsyncWrap + _http_agent asyncResetHandle() make every socket
+// callback re-enter the current request's async scope; Bun bridges this in
+// JS by snapshotting the frame at tickOnSocket and running each socket
+// listener (data/end/error/close/drain/timeout) inside it.
+const kClientAsyncContext = Symbol("kClientAsyncContext");
+const runInFrame = require("internal/async_context_frame").run;
+
+function closeRequest(req) {
+  if (req[kClientAsyncContext] !== undefined) req[kClientAsyncContext] = undefined;
+  req._closed = true;
+  req.emit("close");
+}
+
 function isURLInstance(input) {
   return input != null && typeof input === "object" && input instanceof URL;
 }
@@ -515,6 +528,10 @@ function emitAbortNT(req) {
 }
 
 function ondrain() {
+  return runInFrame(this._httpMessage?.[kClientAsyncContext], ondrainInner, this);
+}
+
+function ondrainInner() {
   const msg = this._httpMessage;
   if (msg && !msg.finished && msg[kNeedDrain]) {
     msg[kNeedDrain] = false;
@@ -523,6 +540,10 @@ function ondrain() {
 }
 
 function socketCloseListener() {
+  return runInFrame(this._httpMessage?.[kClientAsyncContext], socketCloseListenerInner, this);
+}
+
+function socketCloseListenerInner() {
   const socket = this;
   const req = socket._httpMessage;
   $debug("HTTP socket close");
@@ -541,8 +562,7 @@ function socketCloseListener() {
     if (!res.complete) {
       res.destroy(new ConnResetException("aborted"));
     }
-    req._closed = true;
-    req.emit("close");
+    closeRequest(req);
     if (!res.aborted && res.readable) {
       res.push(null);
     }
@@ -554,8 +574,7 @@ function socketCloseListener() {
       req.socket._hadError = true;
       emitErrorEvent(req, new ConnResetException("socket hang up"));
     }
-    req._closed = true;
-    req.emit("close");
+    closeRequest(req);
   }
 
   // Too bad.  That output wasn't getting written.
@@ -571,6 +590,10 @@ function socketCloseListener() {
 }
 
 function socketErrorListener(err) {
+  return runInFrame(this._httpMessage?.[kClientAsyncContext], socketErrorListenerInner, this, err);
+}
+
+function socketErrorListenerInner(err) {
   const socket = this;
   const req = socket._httpMessage;
   $debug("SOCKET ERROR:", err);
@@ -595,6 +618,10 @@ function socketErrorListener(err) {
 }
 
 function socketOnEnd() {
+  return runInFrame(this._httpMessage?.[kClientAsyncContext], socketOnEndInner, this);
+}
+
+function socketOnEndInner() {
   const socket = this;
   const req = this._httpMessage;
   const parser = this.parser;
@@ -613,6 +640,10 @@ function socketOnEnd() {
 }
 
 function socketOnData(d) {
+  return runInFrame(this._httpMessage?.[kClientAsyncContext], socketOnDataInner, this, d);
+}
+
+function socketOnDataInner(d) {
   const socket = this;
 
   // HTTPParser.execute() is not reentrant. User code can synchronously push
@@ -689,10 +720,12 @@ function processClientData(socket, d, parser) {
         socket._httpMessage = null;
         socket.readableFlowing = null;
 
+        // Clear before the emit: a throwing upgrade/connect handler would skip
+        // closeRequest() and leave the retained request pinning the store.
+        req[kClientAsyncContext] = undefined;
         req.emit(eventName, res, socket, bodyHead);
         req.destroyed = true;
-        req._closed = true;
-        req.emit("close");
+        closeRequest(req);
       } else {
         // Requested Upgrade or used CONNECT method, but have no handler.
         socket.destroy();
@@ -901,6 +934,10 @@ function responseOnEnd() {
 }
 
 function responseOnTimeout() {
+  return runInFrame(this._httpMessage?.[kClientAsyncContext], responseOnTimeoutInner, this);
+}
+
+function responseOnTimeoutInner() {
   const req = this._httpMessage;
   if (!req) return;
   const res = req.res;
@@ -921,8 +958,7 @@ function requestOnFinish() {
 }
 
 function emitFreeNT(req) {
-  req._closed = true;
-  req.emit("close");
+  closeRequest(req);
   const socket = req.socket;
   if (socket) {
     socket.emit("free");
@@ -932,6 +968,7 @@ function emitFreeNT(req) {
 function tickOnSocket(req, socket) {
   const parser = parsers.alloc();
   req.socket = socket;
+  req[kClientAsyncContext] = $getInternalField($asyncContext, 0);
   const lenientFlags = calculateLenientFlags(req.httpValidation, req.insecureHTTPParser);
   parser.initialize(
     HTTPParser.RESPONSE,
@@ -967,6 +1004,10 @@ function tickOnSocket(req, socket) {
 }
 
 function emitRequestTimeout() {
+  return runInFrame(this._httpMessage?.[kClientAsyncContext], emitRequestTimeoutInner, this);
+}
+
+function emitRequestTimeoutInner() {
   const req = this._httpMessage;
   if (req) {
     req.emit("timeout");
@@ -1000,6 +1041,10 @@ ClientRequest.prototype.onSocket = function onSocket(socket, err) {
   // to be set so we set it here too.
   if (socket && !err) {
     socket._httpMessage = this;
+    // Capture the frame here, not just in tickOnSocket: onSocket runs in the
+    // request's context, and an error in the window before onSocketNT would
+    // otherwise run socketErrorListener with no frame and clear the context.
+    this[kClientAsyncContext] = $getInternalField($asyncContext, 0);
     socket.on("error", socketErrorListener);
   }
   process.nextTick(onSocketNT, this, socket, err);
@@ -1017,8 +1062,7 @@ function destroyRequestOnSocketNT(req, socket, err) {
   // The request is dead with no parser: close the trace span on the paths
   // that skip emitErrorEvent above (proxy tunnel; error already emitted).
   traceClientResponseEnd(req);
-  req._closed = true;
-  req.emit("close");
+  closeRequest(req);
 }
 
 function onSocketNT(req, socket, err) {