JavaScript Promise.race Timeout Does Not Cancel Work: Use an AbortSignal

Prove that the losing operation still runs#

Save this complete example as race-timeout.mjs and run node race-timeout.mjs. It was executed during article preparation on macOS with Node.js 24.13.0, on November 6, 2026. The first case uses a rejected promise as a controlled deadline signal: no wall-clock timing assumption decides which operation wins. The second case cancels a real Node.js promise timer.

1
import assert from 'node:assert/strict';
2
import { setTimeout as delay } from 'node:timers/promises';
3

4
const events = [];
5
let release;
6
const gate = new Promise(resolve => { release = resolve; });
7
const work = gate.then(() => { events.push('write'); return 'done'; });
8
try {
9
  await Promise.race([work, Promise.reject(new Error('deadline'))]);
10
} catch (error) {
11
  events.push(error.message);
12
}
13
assert.deepEqual(events, ['deadline']);
14
release();
15
await work;
16
assert.deepEqual(events, ['deadline', 'write']);
17
console.log('race:', events.join(' -> '));
18

19
const controller = new AbortController();
20
const canceled = [];
21
const pending = delay(60_000, undefined, { signal: controller.signal })
22
  .then(() => canceled.push('write'));
23
const drained = Promise.allSettled([pending]);
24
controller.abort();
25
const [result] = await drained;
26
assert.equal(result.status, 'rejected');
27
assert.equal(result.reason.name, 'AbortError');
28
assert.deepEqual(canceled, []);
29
console.log('abort:', result.reason.name, '; writes:', canceled.length);

The assertions pass and print:

1
race: deadline -> write
2
abort: AbortError ; writes: 0

The first assertion runs before the gate opens. Only deadline exists then; the write happens after the caller has caught the rejection. Replacing the immediate rejection with a timer that rejects before the gate opens changes when the deadline arrives, not whether the gated work can continue.

The second case passes a signal into the operation itself. Aborting that signal rejects the pending timer, so its fulfillment handler never records a write. allSettled() observes the rejection before the script finishes; cancellation and observing completion are separate steps.

Choose between abandoning a result and stopping work#

The ECMAScript race algorithm connects each input to the returned promise’s resolve and reject functions. It contains no instruction to cancel the losing operations. This explains the first trace without treating a timeout as a special promise state.

Node’s timer documentation specifies cancellation through an AbortController for promise timers. The test covers that API, not arbitrary promises. A library that ignores the signal will keep running; a synchronous loop cannot be interrupted merely by attaching a signal to an unrelated object.

For the separate problem of an aggregate rejection triggering cleanup while sibling work continues, see Promise.all cleanup ordering. Here the central issue is the timeout’s authority over the operation, rather than collecting a group of results.

Apply the boundary to fetch timeouts#

For fetch, a supported timeout signal can be passed directly as the request’s signal, using AbortSignal.timeout(milliseconds). MDN documents that expiration aborts this signal with a TimeoutError. This is an API-specific cancellation route; racing fetch against an unrelated rejecting timer does not connect that timer to the request.

This article’s executed fixture does not test fetch, browser suspension, response-body streaming, or remote server behavior. In particular, client cancellation does not establish that a server rolled back work it already accepted. Check the affected request and server contract before retrying an operation with side effects.

If you implement a deadline with your own setTimeout, keep its handle and call clearTimeout when the operation finishes before that deadline. Settling a race does not clear a losing timer either. Choose one owner for the timer, the cancellation request, and the observation of task completion; keep resource cleanup after the boundary your application actually requires.

References:

• ECMAScript: PerformPromiseRace
• Node.js: Cancelling timers
• MDN: AbortSignal.timeout()