fix: improve Promise.race OOM fix placement and cleanup

Move early returns for kPromiseResolveAfterResolved and
kPromiseRejectAfterResolved before Number::New and CHECK(!callback),
avoiding unnecessary work. Remove dead NODE_DEFINE_CONSTANT exports
and fix comment placement in the JS switch statement. Bump test
--max-old-space-size from 20 to 64 for safety on instrumented builds.

Author: Felipeness

lib/internal/process/promises.js

@@ -159,16 +159,15 @@ function promiseRejectHandler(type, promise, reason) {
   if (unhandledRejectionsMode === undefined) {
     unhandledRejectionsMode = getUnhandledRejectionsMode();
   }
+  // kPromiseRejectAfterResolved and kPromiseResolveAfterResolved are
+  // filtered out in C++ (src/node_task_queue.cc) and never reach JS.
   switch (type) {
     case kPromiseRejectWithNoHandler: // 0
       unhandledRejection(promise, reason);
       break;
     case kPromiseHandlerAddedAfterReject: // 1
       handledRejection(promise);
       break;
-    // kPromiseRejectAfterResolved and kPromiseResolveAfterResolved are
-    // handled in C++ (src/node_task_queue.cc) by returning early, so they
-    // never reach this JS callback. No case branches needed.
   }
 }
 

src/node_task_queue.cc

@@ -55,6 +55,13 @@ void PromiseRejectCallback(PromiseRejectMessage message) {
 
   if (env == nullptr || !env->can_call_into_js()) return;
 
+  // multipleResolves was removed in v25 (PR #58707).  Skip all work for
+  // these events to avoid OOM in tight Promise.race() loops (#51452).
+  if (event == kPromiseResolveAfterResolved ||
+      event == kPromiseRejectAfterResolved) {
+    return;
+  }
+
   Local<Function> callback = env->promise_reject_callback();
   // The promise is rejected before JS land calls SetPromiseRejectCallback
   // to initializes the promise reject callback during bootstrap.
@@ -77,15 +84,6 @@ void PromiseRejectCallback(PromiseRejectMessage message) {
                   "rejections",
                   "unhandled", unhandledRejections,
                   "handledAfter", rejectionsHandledAfter);
-  } else if (event == kPromiseResolveAfterResolved) {
-    // Intentional no-op. The multipleResolves event was EOL'd in v25
-    // (PR #58707), and the JS handler does nothing for these events.
-    // Skipping the JS callback avoids accumulating C++-to-JS boundary
-    // references in tight Promise.race()/Promise.any() loops, which
-    // previously caused OOM (see #51452).
-    return;
-  } else if (event == kPromiseRejectAfterResolved) {
-    return;
   } else {
     return;
   }
@@ -178,8 +176,6 @@ static void Initialize(Local<Object> target,
   Local<Object> events = Object::New(isolate);
   NODE_DEFINE_CONSTANT(events, kPromiseRejectWithNoHandler);
   NODE_DEFINE_CONSTANT(events, kPromiseHandlerAddedAfterReject);
-  NODE_DEFINE_CONSTANT(events, kPromiseResolveAfterResolved);
-  NODE_DEFINE_CONSTANT(events, kPromiseRejectAfterResolved);
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(isolate, "promiseRejectEvents"),

test/parallel/test-promise-race-memory-leak.js

@@ -1,12 +1,12 @@
-// Flags: --max-old-space-size=20
+// Flags: --max-old-space-size=64
 'use strict';
 
 // Regression test for https://github.com/nodejs/node/issues/51452
 // When Promise.race() settles, V8 fires kPromiseResolveAfterResolved /
 // kPromiseRejectAfterResolved for each "losing" promise. Before this fix,
 // the C++ PromiseRejectCallback crossed into JS for these no-op events,
 // accumulating references and causing OOM in tight async loops.
-// With --max-old-space-size=20, this test would crash before completing
+// With --max-old-space-size=64, this test would crash before completing
 // if the leak is present.
 
 const common = require('../common');