From 9afb22615fd9ad8536c87598c7ff7fb2879d198e Mon Sep 17 00:00:00 2001
From: Kevin Gibbons <bakkot@gmail.com>
Date: Mon, 20 Apr 2026 08:41:06 -0700
Subject: [PATCH 1/2] process: move multipleResolves event to EOL

Co-authored-by: James M Snell <jasnell@gmail.com>
---
 doc/api/deprecations.md                       |  6 +-
 doc/api/process.md                            | 90 -------------------
 lib/internal/process/promises.js              | 23 +----
 test/parallel/test-events-once.js             |  1 -
 test/parallel/test-promise-swallowed-event.js | 58 ------------
 .../test-timers-immediate-promisified.js      |  2 -
 .../test-timers-interval-promisified.js       |  2 -
 .../test-timers-timeout-promisified.js        |  2 -
 test/parallel/test-warn-multipleResolves.mjs  | 14 ---
 9 files changed, 7 insertions(+), 191 deletions(-)
 delete mode 100644 test/parallel/test-promise-swallowed-event.js
 delete mode 100644 test/parallel/test-warn-multipleResolves.mjs

diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 5243fa0fb2b621..6ae949043ff6bf 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -3099,10 +3099,10 @@ changes:
     description: Documentation-only deprecation.
 -->
 
-Type: Runtime.
+Type: End-of-Life.
 
-This event was deprecated because it did not work with V8 promise combinators
-which diminished its usefulness.
+This event was deprecated and removed because it did not work with V8 promise
+combinators which diminished its usefulness.
 
 ### DEP0161: `process._getActiveRequests()` and `process._getActiveHandles()`
 
diff --git a/doc/api/process.md b/doc/api/process.md
index b38ef46189f72e..f2f8eb6febb2a1 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -176,95 +176,6 @@ process, the `message` argument can contain data that JSON is not able
 to represent.
 See [Advanced serialization for `child_process`][] for more details.
 
-### Event: `'multipleResolves'`
-
-<!-- YAML
-added: v10.12.0
-deprecated:
-  - v17.6.0
-  - v16.15.0
--->
-
-> Stability: 0 - Deprecated
-
-* `type` {string} The resolution type. One of `'resolve'` or `'reject'`.
-* `promise` {Promise} The promise that resolved or rejected more than once.
-* `value` {any} The value with which the promise was either resolved or
-  rejected after the original resolve.
-
-The `'multipleResolves'` event is emitted whenever a `Promise` has been either:
-
-* Resolved more than once.
-* Rejected more than once.
-* Rejected after resolve.
-* Resolved after reject.
-
-This is useful for tracking potential errors in an application while using the
-`Promise` constructor, as multiple resolutions are silently swallowed. However,
-the occurrence of this event does not necessarily indicate an error. For
-example, [`Promise.race()`][] can trigger a `'multipleResolves'` event.
-
-Because of the unreliability of the event in cases like the
-[`Promise.race()`][] example above it has been deprecated.
-
-```mjs
-import process from 'node:process';
-
-process.on('multipleResolves', (type, promise, reason) => {
-  console.error(type, promise, reason);
-  setImmediate(() => process.exit(1));
-});
-
-async function main() {
-  try {
-    return await new Promise((resolve, reject) => {
-      resolve('First call');
-      resolve('Swallowed resolve');
-      reject(new Error('Swallowed reject'));
-    });
-  } catch {
-    throw new Error('Failed');
-  }
-}
-
-main().then(console.log);
-// resolve: Promise { 'First call' } 'Swallowed resolve'
-// reject: Promise { 'First call' } Error: Swallowed reject
-//     at Promise (*)
-//     at new Promise (<anonymous>)
-//     at main (*)
-// First call
-```
-
-```cjs
-const process = require('node:process');
-
-process.on('multipleResolves', (type, promise, reason) => {
-  console.error(type, promise, reason);
-  setImmediate(() => process.exit(1));
-});
-
-async function main() {
-  try {
-    return await new Promise((resolve, reject) => {
-      resolve('First call');
-      resolve('Swallowed resolve');
-      reject(new Error('Swallowed reject'));
-    });
-  } catch {
-    throw new Error('Failed');
-  }
-}
-
-main().then(console.log);
-// resolve: Promise { 'First call' } 'Swallowed resolve'
-// reject: Promise { 'First call' } Error: Swallowed reject
-//     at Promise (*)
-//     at new Promise (<anonymous>)
-//     at main (*)
-// First call
-```
-
 ### Event: `'rejectionHandled'`
 
 <!-- YAML
@@ -3856,7 +3767,6 @@ cases:
 [`Error`]: errors.md#class-error
 [`EventEmitter`]: events.md#class-eventemitter
 [`NODE_OPTIONS`]: cli.md#node_optionsoptions
-[`Promise.race()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race
 [`Worker`]: worker_threads.md#class-worker
 [`Worker` constructor]: worker_threads.md#new-workerfilename-options
 [`console.error()`]: console.md#consoleerrordata-args
diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js
index 421538373e0399..054891f0efc2f2 100644
--- a/lib/internal/process/promises.js
+++ b/lib/internal/process/promises.js
@@ -20,8 +20,6 @@ const {
   setPromiseRejectCallback
 } = internalBinding('task_queue');
 
-const { deprecate } = require('internal/util');
-
 const {
   noSideEffectsToString,
   triggerUncaughtException
@@ -118,29 +116,16 @@ function promiseRejectHandler(type, promise, reason) {
       handledRejection(promise);
       break;
     case kPromiseResolveAfterResolved:
-      resolveError('resolve', promise, reason);
+      // Do nothing in this case. Previous we would emit a multipleResolves
+      // event but that was deprecated then later removed.
       break;
     case kPromiseRejectAfterResolved:
-      resolveError('reject', promise, reason);
+      // Do nothing in this case. Previous we would emit a multipleResolves
+      // event but that was deprecated then later removed.
       break;
   }
 }
 
-const multipleResolvesDeprecate = deprecate(
-  () => {},
-  'The multipleResolves event has been deprecated.',
-  'DEP0160'
-);
-function resolveError(type, promise, reason) {
-  // We have to wrap this in a next tick. Otherwise the error could be caught by
-  // the executed promise.
-  process.nextTick(() => {
-    if (process.emit('multipleResolves', type, promise, reason)) {
-      multipleResolvesDeprecate();
-    }
-  });
-}
-
 function unhandledRejection(promise, reason) {
   const emit = (reason, promise, promiseInfo) => {
     if (promiseInfo.domain) {
diff --git a/test/parallel/test-events-once.js b/test/parallel/test-events-once.js
index 6acb795653590b..e42b3c1ae21353 100644
--- a/test/parallel/test-events-once.js
+++ b/test/parallel/test-events-once.js
@@ -107,7 +107,6 @@ async function stopListeningAfterCatchingError() {
   } catch (_e) {
     err = _e;
   }
-  process.removeAllListeners('multipleResolves');
   strictEqual(err, expected);
   strictEqual(ee.listenerCount('error'), 0);
   strictEqual(ee.listenerCount('myevent'), 0);
diff --git a/test/parallel/test-promise-swallowed-event.js b/test/parallel/test-promise-swallowed-event.js
deleted file mode 100644
index e9b97ab19d329d..00000000000000
--- a/test/parallel/test-promise-swallowed-event.js
+++ /dev/null
@@ -1,58 +0,0 @@
-'use strict';
-
-const common = require('../common');
-const assert = require('assert');
-
-const rejection = new Error('Swallowed reject');
-const rejection2 = new TypeError('Weird');
-const resolveMessage = 'First call';
-const rejectPromise = new Promise((r) => setTimeout(r, 10, rejection2));
-const swallowedResolve = 'Swallowed resolve';
-const swallowedResolve2 = 'Foobar';
-
-process.on('multipleResolves', common.mustCall(handler, 4));
-
-const p1 = new Promise((resolve, reject) => {
-  resolve(resolveMessage);
-  resolve(swallowedResolve);
-  reject(rejection);
-});
-
-const p2 = new Promise((resolve, reject) => {
-  reject(rejectPromise);
-  resolve(swallowedResolve2);
-  reject(rejection2);
-}).catch(common.mustCall((exception) => {
-  assert.strictEqual(exception, rejectPromise);
-}));
-
-const expected = [
-  'resolve',
-  p1,
-  swallowedResolve,
-  'reject',
-  p1,
-  rejection,
-  'resolve',
-  p2,
-  swallowedResolve2,
-  'reject',
-  p2,
-  rejection2,
-];
-
-let count = 0;
-
-function handler(type, promise, reason) {
-  assert.strictEqual(type, expected.shift());
-  // In the first two cases the promise is identical because it's not delayed.
-  // The other two cases are not identical, because the `promise` is caught in a
-  // state when it has no knowledge about the `.catch()` handler that is
-  // attached to it right afterwards.
-  if (count++ < 2) {
-    assert.strictEqual(promise, expected.shift());
-  } else {
-    assert.notStrictEqual(promise, expected.shift());
-  }
-  assert.strictEqual(reason, expected.shift());
-}
diff --git a/test/parallel/test-timers-immediate-promisified.js b/test/parallel/test-timers-immediate-promisified.js
index 5808312b564e48..ec41bf9a6dcea3 100644
--- a/test/parallel/test-timers-immediate-promisified.js
+++ b/test/parallel/test-timers-immediate-promisified.js
@@ -16,8 +16,6 @@ const exec = promisify(child_process.exec);
 
 assert.strictEqual(setPromiseImmediate, timerPromises.setImmediate);
 
-process.on('multipleResolves', common.mustNotCall());
-
 {
   const promise = setPromiseImmediate();
   promise.then(common.mustCall((value) => {
diff --git a/test/parallel/test-timers-interval-promisified.js b/test/parallel/test-timers-interval-promisified.js
index e6550445f142eb..fa839a03d6e841 100644
--- a/test/parallel/test-timers-interval-promisified.js
+++ b/test/parallel/test-timers-interval-promisified.js
@@ -16,8 +16,6 @@ const exec = promisify(child_process.exec);
 
 const { setInterval } = timerPromises;
 
-process.on('multipleResolves', common.mustNotCall());
-
 {
   const iterable = setInterval(1, undefined);
   const iterator = iterable[Symbol.asyncIterator]();
diff --git a/test/parallel/test-timers-timeout-promisified.js b/test/parallel/test-timers-timeout-promisified.js
index 4e3881acec1ce2..2b5f800e4985cc 100644
--- a/test/parallel/test-timers-timeout-promisified.js
+++ b/test/parallel/test-timers-timeout-promisified.js
@@ -16,8 +16,6 @@ const exec = promisify(child_process.exec);
 
 assert.strictEqual(setPromiseTimeout, timerPromises.setTimeout);
 
-process.on('multipleResolves', common.mustNotCall());
-
 {
   const promise = setPromiseTimeout(1);
   promise.then(common.mustCall((value) => {
diff --git a/test/parallel/test-warn-multipleResolves.mjs b/test/parallel/test-warn-multipleResolves.mjs
deleted file mode 100644
index 9320ff2635e563..00000000000000
--- a/test/parallel/test-warn-multipleResolves.mjs
+++ /dev/null
@@ -1,14 +0,0 @@
-import { expectWarning, mustCall } from '../common/index.mjs';
-
-expectWarning(
-  'DeprecationWarning',
-  'The multipleResolves event has been deprecated.',
-  'DEP0160',
-);
-
-process.on('multipleResolves', mustCall());
-
-new Promise((resolve) => {
-  resolve();
-  resolve();
-});

From e66f17abe54e4a367a8877f45295abe5199d2bb3 Mon Sep 17 00:00:00 2001
From: Kevin Gibbons <bakkot@gmail.com>
Date: Tue, 5 May 2026 20:01:49 -0700
Subject: [PATCH 2/2] src: skip JS callback for settled Promise.race losers

this was Co-Authored-By: Felipe Coelho <felipecoelho.ness@gmail.com>
---
 lib/internal/process/promises.js | 12 ++----------
 src/node_task_queue.cc           | 14 +++++---------
 2 files changed, 7 insertions(+), 19 deletions(-)

diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js
index 054891f0efc2f2..e866319142cb03 100644
--- a/lib/internal/process/promises.js
+++ b/lib/internal/process/promises.js
@@ -14,8 +14,6 @@ const {
   promiseRejectEvents: {
     kPromiseRejectWithNoHandler,
     kPromiseHandlerAddedAfterReject,
-    kPromiseResolveAfterResolved,
-    kPromiseRejectAfterResolved
   },
   setPromiseRejectCallback
 } = internalBinding('task_queue');
@@ -108,6 +106,8 @@ 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:
       unhandledRejection(promise, reason);
@@ -115,14 +115,6 @@ function promiseRejectHandler(type, promise, reason) {
     case kPromiseHandlerAddedAfterReject:
       handledRejection(promise);
       break;
-    case kPromiseResolveAfterResolved:
-      // Do nothing in this case. Previous we would emit a multipleResolves
-      // event but that was deprecated then later removed.
-      break;
-    case kPromiseRejectAfterResolved:
-      // Do nothing in this case. Previous we would emit a multipleResolves
-      // event but that was deprecated then later removed.
-      break;
   }
 }
 
diff --git a/src/node_task_queue.cc b/src/node_task_queue.cc
index 2e62a072ee493d..6bc89bf7ab3b85 100644
--- a/src/node_task_queue.cc
+++ b/src/node_task_queue.cc
@@ -19,9 +19,7 @@ using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Just;
 using v8::kPromiseHandlerAddedAfterReject;
-using v8::kPromiseRejectAfterResolved;
 using v8::kPromiseRejectWithNoHandler;
-using v8::kPromiseResolveAfterResolved;
 using v8::Local;
 using v8::Maybe;
 using v8::Number;
@@ -75,7 +73,11 @@ void PromiseRejectCallback(PromiseRejectMessage message) {
 
   Environment* env = Environment::GetCurrent(isolate);
 
-  if (env == nullptr || !env->can_call_into_js()) return;
+  if (env == nullptr || !env->can_call_into_js() ||
+      event != kPromiseRejectWithNoHandler &&
+      event != kPromiseHandlerAddedAfterReject) {
+    return;
+  }
 
   Local<Function> callback = env->promise_reject_callback();
   // The promise is rejected before JS land calls SetPromiseRejectCallback
@@ -99,10 +101,6 @@ void PromiseRejectCallback(PromiseRejectMessage message) {
                   "rejections",
                   "unhandled", unhandledRejections,
                   "handledAfter", rejectionsHandledAfter);
-  } else if (event == kPromiseResolveAfterResolved) {
-    value = message.GetValue();
-  } else if (event == kPromiseRejectAfterResolved) {
-    value = message.GetValue();
   } else {
     return;
   }
@@ -206,8 +204,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"),