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,11 @@ function reset(): string {
   return "";
 }
 
+// Bun.write returns a promise; the banner writes are best-effort and a
+// rejected stderr write (racing writers on a piped stderr, seen on Windows)
+// must not become a fatal unhandled rejection.
+function kIgnoreWriteError(): void {}
+
 function notify(options): void {
   Bun.connect({
     ...options,

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/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,9 @@ function lookup(hostname, options, callback) {
   validateLookupOptions(options);
 
   if (!hostname) {
-    invalidHostname(hostname);
-    if (options.all) {
-      callback(null, []);
-    } else {
-      callback(null, null, 4);
-    }
-    return;
+    // Node v26.3.0 throws synchronously without invoking the callback
+    // (lib/dns.js lookup); the old warn-and-succeed branch predates that.
+    throw $ERR_INVALID_ARG_VALUE("hostname", hostname, "must be a non-empty string");
   }
 
   const family = isIP(hostname);
@@ -749,15 +732,9 @@ const promises = {
     validateLookupOptions(options);
 
     if (!hostname) {
-      invalidHostname(hostname);
-      return Promise.$resolve(
-        options.all
-          ? []
-          : {
-              address: null,
-              family: 4,
-            },
-      );
+      // Node v26.3.0's promises lookup is an async function, so the same
+      // ERR_INVALID_ARG_VALUE surfaces as a rejection here.
+      return Promise.$reject($ERR_INVALID_ARG_VALUE("hostname", hostname, "must be a non-empty string"));
     }
 
     const family = isIP(hostname);

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,8 @@ 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.
+  // Node's TLSWrap completion runs via MakeCallback so a listener throw is an uncaughtException;
+  // mirror that here instead of falling through to Bun.connect's handshake-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 +343,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 +986,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 +1690,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 +1720,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()) {

src/js/thirdparty/ws.js

@@ -371,98 +371,71 @@ class BunWebSocket extends EventEmitter {
     }
   }
 
-  #onOrOnce(event, listener, once) {
+  #armAndOn(event, listener) {
     if (event === "redirect") {
       emitWarning(event, "ws.WebSocket '" + event + "' event is not implemented in bun");
     }
     if (event === "upgrade" || event === "unexpected-response") {
       this.#ensureHandshakeListener();
-      return once ? super.once(event, listener) : super.on(event, listener);
+      return super.on(event, listener);
     }
     const mask = 1 << eventIds[event];
-    const hasPersistentListener = mask && (this.#eventId & mask) === mask;
-    // Add a native listener if:
-    // 1. For `on()`: no native listener exists yet (will be persistent)
-    // 2. For `once()`: no persistent `on()` listener exists (otherwise the persistent one forwards events)
-    //    If only `once()` listeners exist, each needs its own native listener since they auto-remove
-    if (mask && !hasPersistentListener) {
-      // Only set the eventId bit for persistent `on` listeners, not for `once`
-      if (!once) {
-        this.#eventId |= mask;
-      }
+    // Add a persistent native bridge if one isn't already forwarding this
+    // event. once() reaches here via super.once() -> this.on(), so there is
+    // no once-only bridge shape any more.
+    if (mask && (this.#eventId & mask) !== mask) {
+      this.#eventId |= mask;
       if (event === "open") {
-        this.#ws.addEventListener(
-          "open",
-          () => {
-            this.emit("open");
-          },
-          once,
-        );
+        this.#ws.addEventListener("open", () => {
+          this.emit("open");
+        });
       } else if (event === "close") {
-        this.#ws.addEventListener(
-          "close",
-          ({ code, reason, wasClean }) => {
-            this.emit("close", code, reason, wasClean);
-          },
-          once,
-        );
+        this.#ws.addEventListener("close", ({ code, reason, wasClean }) => {
+          this.emit("close", code, reason, wasClean);
+        });
       } else if (event === "message") {
-        this.#ws.addEventListener(
-          "message",
-          ({ data }) => {
-            const isBinary = typeof data !== "string";
-            if (isBinary) {
-              this.emit("message", this.#fragments ? [data] : data, isBinary);
-            } else {
-              let encoded = encoder.encode(data);
-              if (this.#binaryType !== "arraybuffer") {
-                encoded = Buffer.from(encoded.buffer, encoded.byteOffset, encoded.byteLength);
-              }
-              this.emit("message", this.#fragments ? [encoded] : encoded, isBinary);
+        this.#ws.addEventListener("message", ({ data }) => {
+          const isBinary = typeof data !== "string";
+          if (isBinary) {
+            this.emit("message", this.#fragments ? [data] : data, isBinary);
+          } else {
+            let encoded = encoder.encode(data);
+            if (this.#binaryType !== "arraybuffer") {
+              encoded = Buffer.from(encoded.buffer, encoded.byteOffset, encoded.byteLength);
             }
-          },
-          once,
-        );
+            this.emit("message", this.#fragments ? [encoded] : encoded, isBinary);
+          }
+        });
       } else if (event === "error") {
-        this.#ws.addEventListener(
-          "error",
-          err => {
-            if (this.#unexpectedResponseEmitted) return;
-            this.emit("error", err);
-          },
-          once,
-        );
+        this.#ws.addEventListener("error", err => {
+          if (this.#unexpectedResponseEmitted) return;
+          this.emit("error", err);
+        });
       } else if (event === "ping") {
-        this.#ws.addEventListener(
-          "ping",
-          ({ data }) => {
-            this.emit("ping", data);
-          },
-          once,
-        );
+        this.#ws.addEventListener("ping", ({ data }) => {
+          this.emit("ping", data);
+        });
       } else if (event === "pong") {
-        this.#ws.addEventListener(
-          "pong",
-          ({ data }) => {
-            this.emit("pong", data);
-          },
-          once,
-        );
+        this.#ws.addEventListener("pong", ({ data }) => {
+          this.emit("pong", data);
+        });
       }
     }
-    return once ? super.once(event, listener) : super.on(event, listener);
+    return super.on(event, listener);
   }
 
   on(event, listener) {
-    return this.#onOrOnce(event, listener, undefined);
+    return this.#armAndOn(event, listener);
   }
 
   once(event, listener) {
-    return this.#onOrOnce(event, listener, onceObject);
+    // super.once() calls this.on() which arms the native bridge; arming a second bridge here would
+    // re-emit after the once wrapper removed itself and throw "Unhandled error".
+    return super.once(event, listener);
   }
 
   addListener(event, listener) {
-    return this.#onOrOnce(event, listener, undefined);
+    return this.#armAndOn(event, listener);
   }
 
   prependListener(event, listener) {
@@ -484,7 +457,7 @@ class BunWebSocket extends EventEmitter {
     if (eventIds[event] === undefined) return;
     const mask = 1 << eventIds[event];
     if ((this.#eventId & mask) === mask) return;
-    this.#onOrOnce(event, noopBridgeListener, undefined);
+    this.#armAndOn(event, noopBridgeListener);
     super.off(event, noopBridgeListener);
   }