fix(ext/node): fire uncaughtExceptionMonitor with correct origin for sync top-level throws (#34048)

## Summary

`process.on('uncaughtExceptionMonitor', handler)` was firing with
`origin === 'unhandledRejection'` instead of `'uncaughtException'` for
synchronous top-level throws in CommonJS entry modules.

Root cause: in Deno, a synchronous top-level throw in a CJS entry
surfaces as a module-evaluation rejection (the entry CJS module is
loaded through an ESM wrapper generated by `node_resolver::analyze`).
Without intervention, the rejection is routed through Deno's
unhandled-rejection path, so the monitor/uncaughtException listeners see
the wrong origin.

## Fix

- `ext/node/polyfills/01_require.js`: catch the sync entry-module throw
in `Module._load` and invoke `process._fatalException` up-front so the
monitor and `uncaughtException` listeners see `origin ===
'uncaughtException'`, matching Node.js semantics. The error is marked in
a WeakSet so the unhandled-rejection fallback in `process.ts` won't
re-fire when the rejection arrives.
- `ext/node/polyfills/process.ts`:
- Track `uncaughtExceptionMonitor` listener count so the monitor still
fires when no `uncaughtException`/`unhandledRejection` listener is
registered.
- Only `preventDefault()` on the unhandled-rejection event when a
registered handler actually consumed the error (so unhandled cases still
terminate).

## Tests

New spec test at `tests/specs/node/uncaught_exception_monitor/`:
- `entry.cjs`: verifies monitor fires with `origin ===
'uncaughtException'` for a sync top-level throw.
- `rejection.cjs`: verifies monitor fires with `origin ===
'unhandledRejection'` for an actual unhandled promise rejection.

## Test plan

- [x] `cargo test -p deno --test integration_tests
specs::node::uncaught_exception_monitor`
- [x] Verified `node:test` and other existing process-event tests still
pass.

Closes denoland/orchid#54

This replaces #34040 (that PR had unrelated commits merged in from main;
this branch contains only the two fix commits).

Author: divybot

ext/node/polyfills/01_require.js

@@ -1663,32 +1663,65 @@ Module._load = function (request, parent, isMain) {
 
   let threw = true;
   try {
-    module.load(filename);
-    threw = false;
-  } finally {
-    if (threw) {
-      delete Module._cache[filename];
-      if (parent !== undefined) {
-        delete relativeResolveCache[relResolveCacheIdentifier];
-        const children = parent?.children;
-        if (ArrayIsArray(children)) {
-          const index = ArrayPrototypeIndexOf(children, module);
-          if (index !== -1) {
-            ArrayPrototypeSplice(children, index, 1);
+    try {
+      module.load(filename);
+      threw = false;
+    } finally {
+      if (threw) {
+        delete Module._cache[filename];
+        if (parent !== undefined) {
+          delete relativeResolveCache[relResolveCacheIdentifier];
+          const children = parent?.children;
+          if (ArrayIsArray(children)) {
+            const index = ArrayPrototypeIndexOf(children, module);
+            if (index !== -1) {
+              ArrayPrototypeSplice(children, index, 1);
+            }
           }
         }
+      } else if (
+        module.exports &&
+        // Skip Proxy module.exports so the cleanup pass after a circular
+        // require doesn't invoke user-visible getPrototypeOf traps. Matches
+        // Node's lib/internal/modules/cjs/loader.js behavior.
+        !core.isProxy(module.exports) &&
+        ObjectGetPrototypeOf(module.exports) ===
+          CircularRequirePrototypeWarningProxy
+      ) {
+        ObjectSetPrototypeOf(module.exports, ObjectPrototype);
       }
-    } else if (
-      module.exports &&
-      // Skip Proxy module.exports so the cleanup pass after a circular
-      // require doesn't invoke user-visible getPrototypeOf traps. Matches
-      // Node's lib/internal/modules/cjs/loader.js behavior.
-      !core.isProxy(module.exports) &&
-      ObjectGetPrototypeOf(module.exports) ===
-        CircularRequirePrototypeWarningProxy
+    }
+  } catch (err) {
+    // For a top-level CommonJS throw in the entry module, fire
+    // 'uncaughtExceptionMonitor' and 'uncaughtException' synchronously with
+    // origin === 'uncaughtException', matching Node.js semantics.
+    //
+    // Without this, the throw bubbles up to the ESM wrapper that loads the
+    // main CJS module (generated by node_resolver::analyze), becomes a
+    // module evaluation rejection, and is routed through Deno's unhandled-
+    // rejection path -- which emits with origin === 'unhandledRejection'.
+    if (
+      isMain &&
+      parent === null &&
+      typeof process !== "undefined" &&
+      typeof process._fatalException === "function"
     ) {
-      ObjectSetPrototypeOf(module.exports, ObjectPrototype);
+      if (process._fatalException(err)) {
+        // Handled by a registered 'uncaughtException' listener or an
+        // 'uncaughtException' capture callback. Treat the load as complete
+        // so the ESM wrapper module evaluation succeeds and the runtime can
+        // continue running pending callbacks.
+        return module.exports;
+      }
+      // Not handled. Mark the error so the unhandled-rejection fallback in
+      // process.ts skips a redundant second emit of monitor/uncaughtException
+      // when the re-thrown error surfaces as a module-evaluation rejection.
+      if (err !== null && typeof err === "object") {
+        const set = internals._dispatchedFatalErrors;
+        if (set !== undefined) set.add(err);
+      }
     }
+    throw err;
   }
 
   return module.exports;

ext/node/polyfills/process.ts

@@ -539,16 +539,27 @@ export { getegid, geteuid, getgid, getuid, setegid, seteuid, setgid, setuid };
 
 const ALLOWED_FLAGS = buildAllowedFlags();
 
+// Tracks error values for which the synchronous Module._load entry-module
+// path in 01_require.js has already invoked process._fatalException. When
+// the same error is later re-thrown and surfaces as a module-evaluation
+// rejection (via the ESM wrapper that loads the main CJS module), the
+// unhandled-rejection fallback below uses this set to skip emitting
+// 'uncaughtExceptionMonitor' / 'uncaughtException' a second time.
 // deno-lint-ignore no-explicit-any
-function uncaughtExceptionHandler(err: any, origin: string) {
+const _dispatchedFatalErrors = new WeakSet<any>();
+internals._dispatchedFatalErrors = _dispatchedFatalErrors;
+
+// deno-lint-ignore no-explicit-any
+function uncaughtExceptionHandler(err: any, origin: string): boolean {
   // The origin parameter can be 'unhandledRejection' or 'uncaughtException'
   // depending on how the uncaught exception was created. In Node.js,
   // exceptions thrown from the top level of a CommonJS module are reported as
   // 'uncaughtException', while exceptions thrown from the top level of an ESM
   // module are reported as 'unhandledRejection'. Deno does not have a true
-  // CommonJS implementation, so all exceptions thrown from the top level are
-  // reported as 'uncaughtException'.
-  process._fatalException(err, origin === "unhandledRejection");
+  // CommonJS implementation; sync throws in the entry CJS module are
+  // dispatched up-front via Module._load (see ext/node/polyfills/01_require.js)
+  // so this path only fires for real unhandled promise rejections.
+  return process._fatalException(err, origin === "unhandledRejection");
 }
 
 export let execPath: string = "";
@@ -1297,6 +1308,7 @@ export const removeAllListeners = process.removeAllListeners;
 let unhandledRejectionListenerCount = 0;
 let rejectionHandledListenerCount = 0;
 let uncaughtExceptionListenerCount = 0;
+let uncaughtExceptionMonitorListenerCount = 0;
 let beforeExitListenerCount = 0;
 let exitListenerCount = 0;
 
@@ -1311,6 +1323,9 @@ process.on("newListener", (event: string) => {
     case "uncaughtException":
       uncaughtExceptionListenerCount++;
       break;
+    case "uncaughtExceptionMonitor":
+      uncaughtExceptionMonitorListenerCount++;
+      break;
     case "beforeExit":
       beforeExitListenerCount++;
       break;
@@ -1334,6 +1349,9 @@ process.on("removeListener", (event: string) => {
     case "uncaughtException":
       uncaughtExceptionListenerCount--;
       break;
+    case "uncaughtExceptionMonitor":
+      uncaughtExceptionMonitorListenerCount--;
+      break;
     case "beforeExit":
       beforeExitListenerCount--;
       break;
@@ -1388,6 +1406,7 @@ function synchronizeListeners() {
   if (
     unhandledRejectionListenerCount > 0 ||
     uncaughtExceptionListenerCount > 0 ||
+    uncaughtExceptionMonitorListenerCount > 0 ||
     _uncaughtExceptionCaptureFn !== null
   ) {
     internals.nodeProcessUnhandledRejectionCallback = (event) => {
@@ -1396,9 +1415,20 @@ function synchronizeListeners() {
         // an unhandled rejection occurs and there are no unhandledRejection
         // listeners.
 
-        event.preventDefault();
-
         let reason = event.reason;
+
+        // The synchronous Module._load path in 01_require.js already invoked
+        // process._fatalException for this error. Re-firing here would
+        // double-emit 'uncaughtExceptionMonitor' (and 'uncaughtException')
+        // for the same value. Skip and let Deno's default unhandled-rejection
+        // handling print the error and terminate the runtime.
+        if (
+          reason !== null && typeof reason === "object" &&
+          _dispatchedFatalErrors.has(reason)
+        ) {
+          return;
+        }
+
         // If the rejection reason is not an Error, wrap it in an
         // ERR_UNHANDLED_REJECTION error, matching Node.js behavior.
         if (!(reason instanceof Error)) {
@@ -1419,7 +1449,12 @@ function synchronizeListeners() {
           reason = err;
         }
 
-        uncaughtExceptionHandler(reason, "unhandledRejection");
+        // Only preventDefault if a registered handler (uncaughtException
+        // listener or capture callback) actually consumed the error.
+        // Otherwise we want the runtime to terminate normally.
+        if (uncaughtExceptionHandler(reason, "unhandledRejection")) {
+          event.preventDefault();
+        }
         return;
       }
 
@@ -1441,7 +1476,9 @@ function synchronizeListeners() {
   }
 
   if (
-    uncaughtExceptionListenerCount > 0 || _uncaughtExceptionCaptureFn !== null
+    uncaughtExceptionListenerCount > 0 ||
+    uncaughtExceptionMonitorListenerCount > 0 ||
+    _uncaughtExceptionCaptureFn !== null
   ) {
     globalThis.addEventListener("error", processOnError);
   } else {

tests/specs/node/uncaught_exception_monitor/__test__.jsonc

@@ -0,0 +1,13 @@
+{
+  "tempDir": true,
+  "tests": {
+    "sync_top_level_cjs_throw": {
+      "args": "run --allow-read entry.cjs",
+      "output": "entry.out"
+    },
+    "monitor_origin_for_unhandled_rejection": {
+      "args": "run --allow-read rejection.cjs",
+      "output": "rejection.out"
+    }
+  }
+}

tests/specs/node/uncaught_exception_monitor/entry.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+// Verify that a synchronous top-level throw in a CommonJS entry module fires
+// 'uncaughtExceptionMonitor' (and 'uncaughtException') with origin
+// 'uncaughtException', matching Node.js semantics. Without the
+// Module._load entry-catch in 01_require.js, the throw would surface as a
+// module-evaluation rejection and reach the listener with origin
+// 'unhandledRejection'.
+
+const theErr = new Error("boom");
+
+process.on("uncaughtExceptionMonitor", (err, origin) => {
+  console.log(
+    "monitor",
+    origin,
+    err === theErr ? "same-error" : "different-error",
+  );
+});
+
+process.on("uncaughtException", (err, origin) => {
+  console.log(
+    "uncaught",
+    origin,
+    err === theErr ? "same-error" : "different-error",
+  );
+
+  process.nextTick(() => {
+    process.setUncaughtExceptionCaptureCallback((capturedErr) => {
+      console.log(
+        "capture",
+        capturedErr === theErr ? "same-error" : "different-error",
+      );
+    });
+    throw theErr;
+  });
+});
+
+throw theErr;

tests/specs/node/uncaught_exception_monitor/entry.out

@@ -0,0 +1,4 @@
+monitor uncaughtException same-error
+uncaught uncaughtException same-error
+monitor uncaughtException same-error
+capture same-error

tests/specs/node/uncaught_exception_monitor/rejection.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+// Verify that a real unhandled promise rejection (not a top-level CJS throw)
+// still fires 'uncaughtExceptionMonitor' with origin 'unhandledRejection'.
+
+const theErr = new Error("rejected");
+
+process.on("uncaughtExceptionMonitor", (err, origin) => {
+  console.log(
+    "monitor",
+    origin,
+    err === theErr ? "same-error" : "different-error",
+  );
+});
+
+process.on("uncaughtException", (err, origin) => {
+  console.log(
+    "uncaught",
+    origin,
+    err === theErr ? "same-error" : "different-error",
+  );
+  process.exit(0);
+});
+
+// Cause an unhandled promise rejection from an async context (not a
+// top-level sync throw). With no 'unhandledRejection' listener, this falls
+// back through the polyfill to 'uncaughtException' with origin
+// 'unhandledRejection'.
+setImmediate(() => {
+  Promise.reject(theErr);
+});

tests/specs/node/uncaught_exception_monitor/rejection.out

@@ -0,0 +1,2 @@
+monitor unhandledRejection same-error
+uncaught unhandledRejection same-error