lib: fix AbortSignal.any() with timeout signals

lib/internal/abort_controller.js

@@ -259,14 +259,30 @@ class AbortSignal extends EventTarget {
     if (!signalsArray.length) {
       return resultSignal;
     }
+
     const resultSignalWeakRef = new SafeWeakRef(resultSignal);
     resultSignal[kSourceSignals] = new SafeSet();
+
+    // Track if we have any timeout signals
+    let hasTimeoutSignals = false;
+
     for (let i = 0; i < signalsArray.length; i++) {
       const signal = signalsArray[i];
+
+      // Check if this is a timeout signal
+      if (signal[kTimeout]) {
+        hasTimeoutSignals = true;
+
+        // Add the timeout signal to gcPersistentSignals to keep it alive
+        // This is what the kNewListener method would do when adding abort listeners
+        gcPersistentSignals.add(signal);
+      }
+
       if (signal.aborted) {
         abortSignal(resultSignal, signal.reason);
         return resultSignal;
       }
+
       signal[kDependantSignals] ??= new SafeSet();
       if (!signal[kComposite]) {
         const signalWeakRef = new SafeWeakRef(signal);
@@ -301,6 +317,12 @@ class AbortSignal extends EventTarget {
         }
       }
     }
+
+    // If we have any timeout signals, add the composite signal to gcPersistentSignals
+    if (hasTimeoutSignals && resultSignal[kSourceSignals].size > 0) {
+      gcPersistentSignals.add(resultSignal);
+    }
+
     return resultSignal;
   }
 
@@ -416,8 +438,10 @@ function abortSignal(signal, reason) {
   //    otherwise to a new "AbortError" DOMException.
   signal[kAborted] = true;
   signal[kReason] = reason;
+
   // 3. Let dependentSignalsToAbort be a new list.
   const dependentSignalsToAbort = ObjectSetPrototypeOf([], null);
+
   // 4. For each dependentSignal of signal's dependent signals:
   signal[kDependantSignals]?.forEach((s) => {
     const dependentSignal = s.deref();
@@ -433,12 +457,27 @@ function abortSignal(signal, reason) {
 
   // 5. Run the abort steps for signal
   runAbort(signal);
+
   // 6. For each dependentSignal of dependentSignalsToAbort,
   //    run the abort steps for dependentSignal.
   for (let i = 0; i < dependentSignalsToAbort.length; i++) {
     const dependentSignal = dependentSignalsToAbort[i];
     runAbort(dependentSignal);
   }
+
+  // Clean up the signal from gcPersistentSignals
+  gcPersistentSignals.delete(signal);
+
+  // If this is a composite signal, also remove all of its source signals from gcPersistentSignals
+  // when they get dereferenced from the signal's kSourceSignals set
+  if (signal[kComposite] && signal[kSourceSignals]) {
+    signal[kSourceSignals].forEach((sourceWeakRef) => {
+      const sourceSignal = sourceWeakRef.deref();
+      if (sourceSignal) {
+        gcPersistentSignals.delete(sourceSignal);
+      }
+    });
+  }
 }
 
 // To run the abort steps for an AbortSignal signal

test/parallel/test-abort-controller-any-timeout.js

@@ -0,0 +1,28 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { once } = require('node:events');
+const { describe, it } = require('node:test');
+
+describe('AbortSignal.any() with timeout signals', () => {
+  it('should abort when the first timeout signal fires', async () => {
+    const signal = AbortSignal.any([AbortSignal.timeout(9000), AbortSignal.timeout(110000)]);
+
+    const abortPromise = Promise.race([
+      once(signal, 'abort').then(() => {
+        throw signal.reason;
+      }),
+      new Promise((resolve) => setTimeout(resolve, 10000)),
+    ]);
+
+    // The promise should be aborted by the 9000ms timeout
+    await assert.rejects(
+      () => abortPromise,
+      {
+        name: 'TimeoutError',
+        message: 'The operation was aborted due to timeout'
+      }
+    );
+  });
+});