process: execArgv fix, getActiveResourcesInfo with sockets/servers/fs, _getActiveHandles/_getActiveRequests (+9 tests, process 85%→94%)

src/js/builtins/ProcessObjectInternals.ts

@@ -872,3 +872,15 @@ export function buildAllowedNodeEnvironmentFlags() {
   Object.freeze(NodeEnvironmentFlagsSet.prototype);
   return Object.freeze(new NodeEnvironmentFlagsSet());
 }
+
+export function getActiveResourcesInfo() {
+  return require("internal/active_handles").getActiveResourcesInfo();
+}
+
+export function getActiveHandles() {
+  return require("internal/active_handles").getActiveHandles();
+}
+
+export function getActiveRequests() {
+  return require("internal/active_handles").getActiveRequests();
+}

src/js/internal/active_handles.ts

@@ -0,0 +1,130 @@
+// Handle registry for process._getActiveHandles()/_getActiveRequests()/getActiveResourcesInfo().
+// Node ref: https://github.com/nodejs/node/blob/main/lib/internal/process/per_thread.js
+// and https://github.com/nodejs/node/blob/main/src/env.cc (handle_wrap_queue).
+
+const getActiveTimeoutCount = $newRustFunction("runtime/timer/Timer.rs", "internal_bindings.getActiveTimeoutCount", 0);
+const getActiveImmediateCount = $newRustFunction(
+  "runtime/timer/Timer.rs",
+  "internal_bindings.getActiveImmediateCount",
+  0,
+);
+const getPendingFsRequestCount = $newRustFunction("node_fs_binding.rs", "getPendingRequestCount", 0);
+
+const kPrev = Symbol("kActiveHandlePrev");
+const kNext = Symbol("kActiveHandleNext");
+const kKind = Symbol("kActiveHandleKind");
+// The handle's own unref-marker key (net.ts's kUserUnrefed symbol for
+// sockets, "_unref" for servers): truthy after unref(), so unref'd handles
+// drop out of both APIs and ref() re-includes them, as in node.
+const kUnrefFlag = Symbol("kActiveHandleUnrefFlag");
+
+const head: any = {};
+head[kPrev] = head;
+head[kNext] = head;
+
+// Named to match Node's wraps so constructor-name filtering on _getActiveRequests() works.
+// fs entries are count-derived (no live wrap); dns entries register the live wrap at dispatch.
+class FSReqCallback {}
+class GetAddrInfoReqWrap {}
+class GetNameInfoReqWrap {}
+// wrap -> kind string. The kind is captured here, at registration, because the
+// wraps are exposed via _getActiveRequests(): reading wrap.constructor.name at
+// inspection time would run user tampering (a replaced constructor, a getter).
+const pendingRequestWraps = new Map();
+
+function noteRequestStart(wrap) {
+  pendingRequestWraps.$set(wrap, wrap.constructor.name);
+  return wrap;
+}
+
+function noteRequestEnd(wrap) {
+  pendingRequestWraps.$delete(wrap);
+}
+
+function registerHandle(handle, kind, unrefFlag) {
+  handle[kUnrefFlag] = unrefFlag;
+  if (handle[kKind] != null) {
+    // Already linked (e.g. kReinitializeHandle swapping the native handle).
+    handle[kKind] = kind;
+    return;
+  }
+  handle[kKind] = kind;
+  handle[kPrev] = head[kPrev];
+  handle[kNext] = head;
+  head[kPrev][kNext] = handle;
+  head[kPrev] = handle;
+}
+
+function unregisterHandle(handle) {
+  if (handle == null || handle[kKind] == null) return;
+  handle[kKind] = null;
+  handle[kPrev][kNext] = handle[kNext];
+  handle[kNext][kPrev] = handle[kPrev];
+  handle[kPrev] = null;
+  handle[kNext] = null;
+}
+
+// Walks the list, unlinking any handle whose native handle is gone — a missed
+// unregister self-heals instead of pinning the dead socket forever.
+function forEachActive(out, pushKind) {
+  for (let h = head[kNext]; h !== head; ) {
+    const next = h[kNext];
+    if (h._handle == null) {
+      unregisterHandle(h);
+    } else if (!h[h[kUnrefFlag]]) {
+      out.push(pushKind ? h[kKind] : h);
+    }
+    h = next;
+  }
+  return out;
+}
+
+function getActiveHandles() {
+  return forEachActive([], false);
+}
+
+function getActiveResourcesInfo() {
+  // Node orders requests before handles before timers. Every async fs request
+  // is 'FSReqCallback': Bun's fs callback API wraps the promise API, so node's
+  // FSReqCallback/FSReqPromise split does not exist here.
+  const resources: string[] = [];
+  for (let i = 0, n = getPendingFsRequestCount(); i < n; i++) {
+    resources.push("FSReqCallback");
+  }
+  pendingRequestWraps.$forEach(kind => {
+    resources.push(kind);
+  });
+  forEachActive(resources, true);
+  for (let i = 0, n = getActiveTimeoutCount(); i < n; i++) {
+    resources.push("Timeout");
+  }
+  for (let i = 0, n = getActiveImmediateCount(); i < n; i++) {
+    resources.push("Immediate");
+  }
+  return resources;
+}
+
+function getActiveRequests() {
+  // fs requests have no user-visible wrap (native promise), so each fs entry is a
+  // fresh FSReqCallback instance; dns entries are the live wraps registered at dispatch.
+  const requests: unknown[] = [];
+  for (let i = 0, n = getPendingFsRequestCount(); i < n; i++) {
+    requests.push(new FSReqCallback());
+  }
+  pendingRequestWraps.$forEach((_kind, wrap) => {
+    requests.push(wrap);
+  });
+  return requests;
+}
+
+export default {
+  registerHandle,
+  unregisterHandle,
+  noteRequestStart,
+  noteRequestEnd,
+  GetAddrInfoReqWrap,
+  GetNameInfoReqWrap,
+  getActiveHandles,
+  getActiveRequests,
+  getActiveResourcesInfo,
+};

src/js/node/_http_server.ts

@@ -91,6 +91,17 @@ const {
   closeAllHttp1Connections,
 } = require("internal/http1_server_fallback");
 const kConnectionsCheckingInterval = Symbol("http.server.connectionsCheckingInterval");
+
+// Bun's http.Server rides Bun.serve (no net.Server), so register with the handle
+// registry directly as "TCPServerWrap"/"PipeWrap"; `_unref` mirrors net.Server.
+// Node ref: https://github.com/nodejs/node/blob/main/lib/_http_server.js
+let activeHandles;
+function registerServerHandle(server, kind) {
+  (activeHandles ??= require("internal/active_handles")).registerHandle(server, kind, "_unref");
+}
+function unregisterServerHandle(server) {
+  if (activeHandles) activeHandles.unregisterHandle(server);
+}
 const kTrackedConnections = Symbol("http.server.trackedConnections");
 const kHttpAllowHalfOpen = Symbol("http.server.httpAllowHalfOpen");
 
@@ -323,6 +334,7 @@ function Server(options, callback): void {
 
   this.listening = false;
   this._unref = false;
+  this._handle = null;
   this.timeout = 0;
   this.maxRequestsPerSocket = 0;
   this.maxHeadersCount = null;
@@ -500,6 +512,8 @@ Server.prototype.closeAllConnections = function () {
   this[serverSymbol] = undefined;
   clearInterval(this[kConnectionsCheckingInterval]);
   this.listening = false;
+  this._handle = null;
+  unregisterServerHandle(this);
 
   server.stop(true);
 };
@@ -534,6 +548,8 @@ Server.prototype.close = function (optionalCallback?) {
   this[serverSymbol] = undefined;
   if (typeof optionalCallback === "function") setCloseCallback(this, optionalCallback);
   this.listening = false;
+  this._handle = null;
+  unregisterServerHandle(this);
   server.closeIdleConnections();
   server.stop();
   return this;
@@ -1126,6 +1142,10 @@ Server.prototype[kRealListen] = function (tls, port, host, socketPath, reusePort
     });
 
     getBunServerAllClosedPromise(this[serverSymbol]).$then(emitCloseNTServer.bind(this));
+    // node's http.Server carries `_handle` (the listen wrap) while listening
+    // and nulls it on close; the registry's liveness walk keys off it too.
+    this._handle = this[serverSymbol];
+    registerServerHandle(this, socketPath ? "PipeWrap" : "TCPServerWrap");
     isHTTPS = this[serverSymbol].protocol === "https";
     applyServerCustomOptions(this);
 

src/js/node/dns.ts

@@ -1,5 +1,6 @@
 // Hardcoded module "node:dns"
 const dns = Bun.dns;
+let activeHandles;
 const utilPromisifyCustomSymbol = Symbol.for("nodejs.util.promisify.custom");
 const { isIP } = require("internal/net/isIP");
 const {
@@ -314,9 +315,14 @@ function lookup(hostname, options, callback) {
     return;
   }
 
-  dns
-    .lookup(hostname, options)
+  // Node parks a GetAddrInfoReqWrap per in-flight lookup (lib/dns.js); register
+  // only after dns.lookup() returns since it can throw synchronously.
+  const promise = dns.lookup(hostname, options);
+  activeHandles ??= require("internal/active_handles");
+  const reqWrap = activeHandles.noteRequestStart(new activeHandles.GetAddrInfoReqWrap());
+  promise
     .then(res => {
+      activeHandles.noteRequestEnd(reqWrap);
       throwIfEmpty(res);
 
       if (options.order == "ipv4first") {
@@ -333,6 +339,7 @@ function lookup(hostname, options, callback) {
       }
     })
     .catch(err => {
+      activeHandles.noteRequestEnd(reqWrap);
       if (err.code?.startsWith("DNS_")) err.code = err.code.slice(4);
       // Node.js getaddrinfo errors (DNSException) carry the looked-up
       // hostname both as a property and at the end of the message.
@@ -357,11 +364,18 @@ function lookupService(address, port, callback) {
   validateString(address);
   validatePort(port, "port");
 
-  dns.lookupService(address, +port).then(
+  // Same shape as lookup(): Bun.dns.lookupService throws synchronously for a
+  // non-IP address, so the promise is captured before the wrap registers.
+  const promise = dns.lookupService(address, +port);
+  activeHandles ??= require("internal/active_handles");
+  const reqWrap = activeHandles.noteRequestStart(new activeHandles.GetNameInfoReqWrap());
+  promise.then(
     results => {
+      activeHandles.noteRequestEnd(reqWrap);
       callback(null, ...results);
     },
     error => {
+      activeHandles.noteRequestEnd(reqWrap);
       callback(withTranslatedError(error));
     },
   );