domain: route fs callback throws to uncaughtException, unblocking 4 tests (domain 88%→96%)

src/js/internal/debugger.ts

@@ -232,17 +232,27 @@ export default function (
     if (debugUrl) {
       const { protocol, href, host, pathname } = debugUrl;
       if (!protocol.includes("unix")) {
-        Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
-        Bun.write(Bun.stderr, `Listening:\n  ${dim(href)}\n`);
+        Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n").catch(
+          kIgnoreWriteError,
+        );
+        Bun.write(Bun.stderr, `Listening:\n  ${dim(href)}\n`).catch(kIgnoreWriteError);
         if (protocol.includes("ws")) {
-          Bun.write(Bun.stderr, `Inspect in browser:\n  ${link(`https://debug.bun.sh/#${host}${pathname}`)}\n`);
+          Bun.write(Bun.stderr, `Inspect in browser:\n  ${link(`https://debug.bun.sh/#${host}${pathname}`)}\n`).catch(
+            kIgnoreWriteError,
+          );
         }
-        Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
+        Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n").catch(
+          kIgnoreWriteError,
+        );
       }
     } else {
-      Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
-      Bun.write(Bun.stderr, `Listening on ${dim(url)}\n`);
-      Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n");
+      Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n").catch(
+        kIgnoreWriteError,
+      );
+      Bun.write(Bun.stderr, `Listening on ${dim(url)}\n`).catch(kIgnoreWriteError);
+      Bun.write(Bun.stderr, dim("--------------------- Bun Inspector ---------------------") + reset() + "\n").catch(
+        kIgnoreWriteError,
+      );
     }
   }
 
@@ -882,6 +892,8 @@ function reset(): string {
   return "";
 }
 
+function kIgnoreWriteError(): void {}
+
 function notify(options): void {
   Bun.connect({
     ...options,

src/js/internal/fs/watch.ts

@@ -1,6 +1,7 @@
 // fs.watch is lazily loaded so the FSWatcher class is only set up when it is used.
 const EventEmitter = require("node:events");
 const { basename } = require("node:path");
+const { guardCallback } = require("internal/shared");
 
 // The native `node:fs` binding, shared via `internal/fs/binding`.
 const fs = require("internal/fs/binding");
@@ -158,7 +159,7 @@ class FSWatcher extends EventEmitter {
     this.#ignoreMatcher = createIgnoreMatcher(options?.ignore);
     this.#listener = listener;
     try {
-      this.#watcher = fs.watch(path, options || {}, this.#onEvent.bind(this));
+      this.#watcher = fs.watch(path, options || {}, guardCallback(this.#onEvent.bind(this)));
     } catch (e: any) {
       e.path = path;
       e.filename = path;
@@ -184,6 +185,12 @@ class FSWatcher extends EventEmitter {
         this.emit("close", filenameOrError);
       });
       return;
+    } else if (eventType === "abort") {
+      // node emits only "close" on abort; the "error" delivery is bun's own,
+      // so with no listener it stays silent instead of ERR_UNHANDLED_ERROR.
+      // A present listener's throw still reaches guardCallback, like "error".
+      if (this.listenerCount("error") > 0) this.emit("error", filenameOrError);
+      return;
     } else if (eventType === "error") {
       // Next.js/watchpack ends up watching paths it does not have access to,
       // which surfaces here as EACCES errors. Rewriting the code to EPERM

src/js/internal/fs/watchfile.ts

@@ -2,6 +2,7 @@
 // machinery is not set up until it is actually used.
 const EventEmitter = require("node:events");
 const { getValidatedPath, throwIfNullBytesInFileName } = require("internal/validators");
+const { guardCallback } = require("internal/shared");
 
 // The native `node:fs` binding, shared via `internal/fs/binding`.
 const fs = require("internal/fs/binding");
@@ -22,7 +23,7 @@ class StatWatcher extends EventEmitter {
 
   constructor(path, options) {
     super();
-    this._handle = fs.watchFile(path, options, this.#onChange.bind(this));
+    this._handle = fs.watchFile(path, options, guardCallback(this.#onChange.bind(this)));
   }
 
   #onChange(curr, prev) {

src/js/internal/webstreams_adapters.ts

@@ -130,7 +130,9 @@ class ReadableFromWeb extends Readable {
     try {
       callback(error);
     } catch (error) {
-      globalThis.reportError(error);
+      process.nextTick(() => {
+        throw error;
+      });
     }
   }
 }

src/js/node/child_process.ts

@@ -1,7 +1,7 @@
 // Hardcoded module "node:child_process"
 const EventEmitter = require("node:events");
 const OsModule = require("node:os");
-const { kHandle } = require("internal/shared");
+const { kHandle, reportUncaughtException } = require("internal/shared");
 const {
   validateBoolean,
   validateFunction,
@@ -1500,7 +1500,11 @@ class ChildProcess extends EventEmitter {
   }
 
   #emitIpcMessage(message, _, handle) {
-    this.emit("message", message, handle);
+    try {
+      this.emit("message", message, handle);
+    } catch (err) {
+      reportUncaughtException(err);
+    }
   }
 
   #send(message, handle, options, callback) {

src/js/node/dgram.ts

@@ -44,7 +44,13 @@ const { kStateSymbol, guessHandleType } = require("internal/dgram");
 const kOwnerSymbol = Symbol("owner symbol");
 const async_id_symbol = Symbol("async_id_symbol");
 
-const { throwNotImplemented, ErrnoException, ExceptionWithHostPort } = require("internal/shared");
+const {
+  throwNotImplemented,
+  ErrnoException,
+  ExceptionWithHostPort,
+  guardCallback,
+  reportUncaughtException,
+} = require("internal/shared");
 const {
   validateString,
   validateNumber,
@@ -706,24 +712,30 @@ function startBunSocket(self, state, createOptions) {
     Bun.udpSocket({
       ...createOptions,
       socket: {
+        // Five args from native, past guardCallback's arity fast path, so the
+        // per-packet handler reroutes its throw inline.
         data: (_socket, data, port, address, flags) => {
-          // Per-packet, from the received sockaddr's family: bind({ fd }) can
-          // adopt a descriptor of the other family than `type`.
-          const family = flags?.ipv6 ? "IPv6" : "IPv4";
-          if (state.receiveBlockList?.check(address, flags?.ipv6 ? "ipv6" : "ipv4")) {
-            return;
+          try {
+            // Per-packet, from the received sockaddr's family: bind({ fd }) can
+            // adopt a descriptor of the other family than `type`.
+            const family = flags?.ipv6 ? "IPv6" : "IPv4";
+            if (state.receiveBlockList?.check(address, flags?.ipv6 ? "ipv6" : "ipv4")) {
+              return;
+            }
+            self.emit("message", data, {
+              port: port,
+              address: address,
+              size: data.length,
+              family,
+            });
+          } catch (err) {
+            reportUncaughtException(err);
           }
-          self.emit("message", data, {
-            port: port,
-            address: address,
-            size: data.length,
-            family,
-          });
         },
-        drain: () => {
+        drain: guardCallback(() => {
           handleDrain.$call(state.handle);
-        },
-        error: error => {
+        }),
+        error: guardCallback(error => {
           if (error?.syscall === "recv") {
             // Drop errqueue-origin ICMP errors on unconnected sockets like
             // Node (which never enables IP_RECVERR); always emit real
@@ -739,7 +751,7 @@ function startBunSocket(self, state, createOptions) {
             return;
           }
           self.emit("error", error);
-        },
+        }),
       },
     }).$then(
       socket => {

src/js/node/diagnostics_channel.ts

@@ -83,7 +83,9 @@ function wrapStoreRun(store, data, next, transform = defaultTransform) {
     try {
       context = transform(data);
     } catch (err) {
-      process.nextTick(() => reportError(err));
+      process.nextTick(() => {
+        throw err;
+      });
       return next();
     }
 
@@ -144,7 +146,9 @@ class ActiveChannel {
         const onMessage = this._subscribers[i];
         onMessage(data, this.name);
       } catch (err) {
-        process.nextTick(() => reportError(err));
+        process.nextTick(() => {
+          throw err;
+        });
       }
     }
   }

src/js/node/dns.ts

@@ -234,19 +234,6 @@ function validateLocalAddresses(first, second) {
   }
 }
 
-function invalidHostname(hostname) {
-  if (invalidHostname.warned) {
-    return;
-  }
-
-  invalidHostname.warned = true;
-  process.emitWarning(
-    `The provided hostname "${String(hostname)}" is not a valid hostname, and is supported in the dns module solely for compatibility.`,
-    "DeprecationWarning",
-    "DEP0118",
-  );
-}
-
 function translateLookupOptions(options) {
   if (!options || typeof options !== "object") {
     options = { family: options };
@@ -300,13 +287,7 @@ function lookup(hostname, options, callback) {
   validateLookupOptions(options);
 
   if (!hostname) {
-    invalidHostname(hostname);
-    if (options.all) {
-      callback(null, []);
-    } else {
-      callback(null, null, 4);
-    }
-    return;
+    throw $ERR_INVALID_ARG_VALUE("hostname", hostname, "must be a non-empty string");
   }
 
   const family = isIP(hostname);
@@ -749,15 +730,7 @@ const promises = {
     validateLookupOptions(options);
 
     if (!hostname) {
-      invalidHostname(hostname);
-      return Promise.$resolve(
-        options.all
-          ? []
-          : {
-              address: null,
-              family: 4,
-            },
-      );
+      return Promise.$reject($ERR_INVALID_ARG_VALUE("hostname", hostname, "must be a non-empty string"));
     }
 
     const family = isIP(hostname);

src/js/node/fs.promises.ts

@@ -10,6 +10,7 @@ const {
   validateAbortSignal,
   validateEncoding,
 } = require("internal/validators");
+const { guardCallback } = require("internal/shared");
 
 const constants = $processBindingConstants.fs;
 
@@ -97,17 +98,27 @@ function watch(
     };
   }
 
-  const watcher = fs.watch(filename, options || {}, (eventType: string, filename: string | Buffer | undefined) => {
-    if (eventType !== "close" && eventType !== "error" && filename != null && ignoreMatcher?.(filename)) {
-      return;
-    }
-    queue.push({ __proto__: null, eventType, filename });
-    if (nextEventResolve) {
-      const resolve = nextEventResolve;
-      nextEventResolve = null;
-      resolve();
-    }
-  });
+  const watcher = fs.watch(
+    filename,
+    options || {},
+    guardCallback((eventType: string, filename: string | Buffer | undefined) => {
+      if (
+        eventType !== "close" &&
+        eventType !== "error" &&
+        eventType !== "abort" &&
+        filename != null &&
+        ignoreMatcher?.(filename)
+      ) {
+        return;
+      }
+      queue.push({ __proto__: null, eventType, filename });
+      if (nextEventResolve) {
+        const resolve = nextEventResolve;
+        nextEventResolve = null;
+        resolve();
+      }
+    }),
+  );
 
   function onAbort() {
     watcher.close();

src/js/node/net.ts

@@ -35,6 +35,7 @@ const {
   hasObserver,
   startPerf,
   stopPerf,
+  reportUncaughtException,
 } = require("internal/shared");
 import type { Socket, SocketHandler, SocketListener } from "bun";
 import type { Server as NetServer, Socket as NetSocket, ServerOpts } from "node:net";
@@ -299,9 +300,6 @@ function onClientHandshakeComplete(self, socket, verifyError) {
   self._secureEstablished = true;
   self[kVerifyError] = verifyError ?? null;
   self.alpnProtocol = socket.alpnProtocol;
-  // Node has no try/catch around these emits; a listener throw reaches
-  // InternalCallbackScope as uncaughtException. reportError mirrors that
-  // without changing Bun.connect's handshake-throw-to-error-handler contract.
   // https://github.com/nodejs/node/blob/v26.3.0/lib/internal/tls/wrap.js#L1107
   try {
     // https://github.com/nodejs/node/blob/v26.3.0/lib/internal/tls/wrap.js#L1662-L1673
@@ -343,7 +341,7 @@ function onClientHandshakeComplete(self, socket, verifyError) {
     // https://github.com/nodejs/node/blob/v26.3.0/lib/internal/tls/wrap.js#L1810
     self.emit("secure", self);
   } catch (err) {
-    reportError(err);
+    reportUncaughtException(err);
   }
 }
 function onConnectEnd() {
@@ -986,7 +984,7 @@ const ServerHandlers: SocketHandler<NetSocket> = {
       // https://github.com/nodejs/node/blob/v26.3.0/lib/internal/tls/wrap.js#L1810
       if (!server) self.emit("secure", self);
     } catch (err) {
-      reportError(err);
+      reportUncaughtException(err);
     }
   },
   error(socket, error) {
@@ -1690,7 +1688,7 @@ function Socket(options?) {
             // The native data dispatch would otherwise route a throw to the
             // socket error handler; hand it to the uncaught-exception path
             // synchronously the way node's bare call does.
-            reportError(e);
+            reportUncaughtException(e);
           }
           if (self.destroyed) return;
           if (ret === false || self.isPaused()) {
@@ -1720,7 +1718,7 @@ function Socket(options?) {
         } catch (e) {
           // Same as above: report then fall through so the next slice is
           // delivered, matching node's per-onStreamRead behavior.
-          reportError(e);
+          reportUncaughtException(e);
         }
         if (self.destroyed) return;
         if (ret === false || self.isPaused()) {