From 0d8f9ffc1b81a691dfdfb02017141498d5f29649 Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Tue, 2 May 2023 17:06:56 +0300
Subject: [PATCH 01/10] lib: implement AbortSignal.any()

---
 doc/api/globals.md                            |  13 ++
 lib/internal/abort_controller.js              |  73 ++++++-
 lib/internal/validators.js                    |  21 ++
 test/fixtures/wpt/README.md                   |   2 +-
 .../wpt/dom/abort/abort-signal-any.any.js     |   4 +
 .../abort/resources/abort-signal-any-tests.js | 185 ++++++++++++++++++
 test/fixtures/wpt/versions.json               |   2 +-
 7 files changed, 290 insertions(+), 10 deletions(-)
 create mode 100644 test/fixtures/wpt/dom/abort/abort-signal-any.any.js
 create mode 100644 test/fixtures/wpt/dom/abort/resources/abort-signal-any-tests.js

diff --git a/doc/api/globals.md b/doc/api/globals.md
index 28aa3526110e7e..5e5ef761a94d9a 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -121,6 +121,18 @@ added:
 
 Returns a new `AbortSignal` which will be aborted in `delay` milliseconds.
 
+#### Static method: `AbortSignal.any(signals)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `signals` {Array} The `AbortSignal`s of which to compose a new `AbortSignal`.
+
+Returns a new `AbortSignal` which will be aborted if any of the provided
+signals are aborted. Its [`abortSignal.reason`][] will be set to whichever
+one of the `signals` caused it to be aborted.
+
 #### Event: `'abort'`
 
 <!-- YAML
@@ -1026,6 +1038,7 @@ A browser-compatible implementation of [`WritableStreamDefaultWriter`][].
 [`WritableStream`]: webstreams.md#class-writablestream
 [`__dirname`]: modules.md#__dirname
 [`__filename`]: modules.md#__filename
+[`abortSignal.reason`]: #abortsignalreason
 [`buffer.atob()`]: buffer.md#bufferatobdata
 [`buffer.btoa()`]: buffer.md#bufferbtoadata
 [`clearImmediate`]: timers.md#clearimmediateimmediate
diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index 2c1f43354f9f7c..bd9e196f8243b8 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -42,6 +42,7 @@ const {
 
 const {
   validateAbortSignal,
+  validateAbortSignalArray,
   validateObject,
   validateUint32,
 } = require('internal/validators');
@@ -54,6 +55,7 @@ const {
   clearTimeout,
   setTimeout,
 } = require('timers');
+const assert = require('internal/assert');
 
 const {
   messaging_deserialize_symbol: kDeserialize,
@@ -80,13 +82,16 @@ function lazyMakeTransferable(obj) {
 }
 
 const clearTimeoutRegistry = new SafeFinalizationRegistry(clearTimeout);
-const timeOutSignals = new SafeSet();
+const gcPersistentSignals = new SafeSet();
 
 const kAborted = Symbol('kAborted');
 const kReason = Symbol('kReason');
 const kCloneData = Symbol('kCloneData');
 const kTimeout = Symbol('kTimeout');
 const kMakeTransferable = Symbol('kMakeTransferable');
+const kComposite = Symbol('kComposite');
+const kSourceSignals = Symbol('kSourceSignals');
+const kDependantSignals = Symbol('kDependantSignals');
 
 function customInspect(self, obj, depth, options) {
   if (depth < 0)
@@ -116,7 +121,7 @@ function setWeakAbortSignalTimeout(weakRef, delay) {
   const timeout = setTimeout(() => {
     const signal = weakRef.deref();
     if (signal !== undefined) {
-      timeOutSignals.delete(signal);
+      gcPersistentSignals.delete(signal);
       abortSignal(
         signal,
         new DOMException(
@@ -185,25 +190,69 @@ class AbortSignal extends EventTarget {
     return signal;
   }
 
+  /**
+   * @param {AbortSignal[]} signals
+   * @returns {AbortSignal}
+   */
+  static any(signals) {
+    validateAbortSignalArray(signals, 'signals');
+    const resultSignal = createAbortSignal({ composite: true });
+    const resultSignalWeakRef = new WeakRef(resultSignal);
+    for (let i = 0; i < signals.length; i++) {
+      const signal = signals[i];
+      if (signal.aborted) {
+        abortSignal(resultSignal, signal.reason);
+        return resultSignal;
+      }
+      resultSignal[kSourceSignals] ??= new SafeSet();
+      signal[kDependantSignals] ??= new SafeSet();
+      if (!signal[kComposite]) {
+        resultSignal[kSourceSignals].add(new WeakRef(signal));
+        signal[kDependantSignals].add(resultSignalWeakRef);
+      } else {
+        if (!signal[kSourceSignals]) {
+          continue;
+        }
+        for (const sourceSignal of signal[kSourceSignals]) {
+          const sourceSignalRef = sourceSignal.deref();
+          if (!sourceSignalRef) {
+            continue;
+          }
+          assert(!sourceSignalRef.aborted);
+          assert(!sourceSignalRef[kComposite]);
+
+          if (resultSignal[kSourceSignals].has(sourceSignal)) {
+            continue;
+          }
+          resultSignal[kSourceSignals].add(sourceSignal);
+          sourceSignalRef[kDependantSignals].add(resultSignalWeakRef);
+        }
+      }
+    }
+    return resultSignal;
+  }
+
   [kNewListener](size, type, listener, once, capture, passive, weak) {
     super[kNewListener](size, type, listener, once, capture, passive, weak);
-    if (this[kTimeout] &&
+    const isTimeoutOrNonEmptyCompositeSignal = this[kTimeout] || (this[kComposite] && this[kSourceSignals]?.size);
+    if (isTimeoutOrNonEmptyCompositeSignal &&
         type === 'abort' &&
         !this.aborted &&
         !weak &&
         size === 1) {
-      // If this is a timeout signal, and we're adding a non-weak abort
+      // If this is a timeout signal, or a non-empty composite signal, and we're adding a non-weak abort
       // listener, then we don't want it to be gc'd while the listener
       // is attached and the timer still hasn't fired. So, we retain a
       // strong ref that is held for as long as the listener is registered.
-      timeOutSignals.add(this);
+      gcPersistentSignals.add(this);
     }
   }
 
   [kRemoveListener](size, type, listener, capture) {
     super[kRemoveListener](size, type, listener, capture);
-    if (this[kTimeout] && type === 'abort' && size === 0) {
-      timeOutSignals.delete(this);
+    const isTimeoutOrNonEmptyCompositeSignal = this[kTimeout] || (this[kComposite] && this[kSourceSignals]?.size);
+    if (isTimeoutOrNonEmptyCompositeSignal && type === 'abort' && size === 0) {
+      gcPersistentSignals.delete(this);
     }
   }
 
@@ -287,7 +336,8 @@ defineEventHandler(AbortSignal.prototype, 'abort');
  * @param {{
  *   aborted? : boolean,
  *   reason? : any,
- *   transferable? : boolean
+ *   transferable? : boolean,
+ *   composite? : boolean,
  * }} [init]
  * @returns {AbortSignal}
  */
@@ -296,11 +346,13 @@ function createAbortSignal(init = kEmptyObject) {
     aborted = false,
     reason = undefined,
     transferable = false,
+    composite = false,
   } = init;
   const signal = new EventTarget();
   ObjectSetPrototypeOf(signal, AbortSignal.prototype);
   signal[kAborted] = aborted;
   signal[kReason] = reason;
+  signal[kComposite] = composite;
   return transferable ? lazyMakeTransferable(signal) : signal;
 }
 
@@ -312,6 +364,11 @@ function abortSignal(signal, reason) {
     [kTrustEvent]: true,
   });
   signal.dispatchEvent(event);
+  signal[kDependantSignals]?.forEach((s) => {
+    const signalRef = s.deref();
+    if (!signalRef) return;
+    abortSignal(signalRef, reason);
+  });
 }
 
 class AbortController {
diff --git a/lib/internal/validators.js b/lib/internal/validators.js
index edca7956d9ce98..c73cb213ebe72b 100644
--- a/lib/internal/validators.js
+++ b/lib/internal/validators.js
@@ -324,6 +324,26 @@ function validateBooleanArray(value, name) {
   }
 }
 
+/**
+ * @callback validateAbortSignalArray
+ * @param {*} value
+ * @param {string} name
+ * @returns {asserts value is AbortSignal[]}
+ */
+
+/** @type {validateAbortSignalArray} */
+function validateAbortSignalArray(value, name) {
+  validateArray(value, name);
+  for (let i = 0; i < value.length; i++) {
+    const signal = value[i];
+    const indexedName = `${name}[${i}]`;
+    if (signal == null) {
+      throw new ERR_INVALID_ARG_TYPE(indexedName, 'AbortSignal', signal);
+    }
+    validateAbortSignal(signal, indexedName);
+  }
+}
+
 /**
  * @param {*} signal
  * @param {string} [name='signal']
@@ -534,6 +554,7 @@ module.exports = {
   validateArray,
   validateStringArray,
   validateBooleanArray,
+  validateAbortSignalArray,
   validateBoolean,
   validateBuffer,
   validateDictionary,
diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md
index 8e15bcb9922bb5..0269d61a649184 100644
--- a/test/fixtures/wpt/README.md
+++ b/test/fixtures/wpt/README.md
@@ -12,7 +12,7 @@ Last update:
 
 - common: https://github.com/web-platform-tests/wpt/tree/dbd648158d/common
 - console: https://github.com/web-platform-tests/wpt/tree/767ae35464/console
-- dom/abort: https://github.com/web-platform-tests/wpt/tree/8fadb38120/dom/abort
+- dom/abort: https://github.com/web-platform-tests/wpt/tree/d1f1ecbd52/dom/abort
 - dom/events: https://github.com/web-platform-tests/wpt/tree/ab8999891c/dom/events
 - encoding: https://github.com/web-platform-tests/wpt/tree/0c1b9d1622/encoding
 - fetch/data-urls/resources: https://github.com/web-platform-tests/wpt/tree/7c79d998ff/fetch/data-urls/resources
diff --git a/test/fixtures/wpt/dom/abort/abort-signal-any.any.js b/test/fixtures/wpt/dom/abort/abort-signal-any.any.js
new file mode 100644
index 00000000000000..b4abb14c1a3eff
--- /dev/null
+++ b/test/fixtures/wpt/dom/abort/abort-signal-any.any.js
@@ -0,0 +1,4 @@
+// META: script=./resources/abort-signal-any-tests.js
+
+abortSignalAnySignalOnlyTests(AbortSignal);
+abortSignalAnyTests(AbortSignal, AbortController);
diff --git a/test/fixtures/wpt/dom/abort/resources/abort-signal-any-tests.js b/test/fixtures/wpt/dom/abort/resources/abort-signal-any-tests.js
new file mode 100644
index 00000000000000..66e4141eaccb08
--- /dev/null
+++ b/test/fixtures/wpt/dom/abort/resources/abort-signal-any-tests.js
@@ -0,0 +1,185 @@
+// Tests for AbortSignal.any() and subclasses that don't use a controller.
+function abortSignalAnySignalOnlyTests(signalInterface) {
+  const desc = `${signalInterface.name}.any()`
+
+  test(t => {
+    const signal = signalInterface.any([]);
+    assert_false(signal.aborted);
+  }, `${desc} works with an empty array of signals`);
+}
+
+// Tests for AbortSignal.any() and subclasses that use a controller.
+function abortSignalAnyTests(signalInterface, controllerInterface) {
+  const suffix = `(using ${controllerInterface.name})`;
+  const desc = `${signalInterface.name}.any()`;
+
+  test(t => {
+    const controller = new controllerInterface();
+    const signal = controller.signal;
+    const cloneSignal = signalInterface.any([signal]);
+    assert_false(cloneSignal.aborted);
+    assert_true("reason" in cloneSignal, "cloneSignal has reason property");
+    assert_equals(cloneSignal.reason, undefined,
+        "cloneSignal.reason is initially undefined");
+    assert_not_equals(signal, cloneSignal,
+        `${desc} returns a new signal.`);
+
+    let eventFired = false;
+    cloneSignal.onabort = t.step_func((e) => {
+      assert_equals(e.target, cloneSignal,
+          `The event target is the signal returned by ${desc}`);
+      eventFired = true;
+    });
+
+    controller.abort("reason string");
+    assert_true(signal.aborted);
+    assert_true(cloneSignal.aborted);
+    assert_true(eventFired);
+    assert_equals(cloneSignal.reason, "reason string",
+        `${desc} propagates the abort reason`);
+  }, `${desc} follows a single signal ${suffix}`);
+
+  test(t => {
+    for (let i = 0; i < 3; ++i) {
+      const controllers = [];
+      for (let j = 0; j < 3; ++j) {
+        controllers.push(new controllerInterface());
+      }
+      const combinedSignal = signalInterface.any(controllers.map(c => c.signal));
+
+      let eventFired = false;
+      combinedSignal.onabort = t.step_func((e) => {
+        assert_equals(e.target, combinedSignal,
+            `The event target is the signal returned by ${desc}`);
+        eventFired = true;
+      });
+
+      controllers[i].abort();
+      assert_true(eventFired);
+      assert_true(combinedSignal.aborted);
+      assert_true(combinedSignal.reason instanceof DOMException,
+          "signal.reason is a DOMException");
+      assert_equals(combinedSignal.reason.name, "AbortError",
+          "signal.reason is a AbortError");
+    }
+  }, `${desc} follows multiple signals ${suffix}`);
+
+  test(t => {
+    const controllers = [];
+    for (let i = 0; i < 3; ++i) {
+      controllers.push(new controllerInterface());
+    }
+    controllers[1].abort("reason 1");
+    controllers[2].abort("reason 2");
+
+    const signal = signalInterface.any(controllers.map(c => c.signal));
+    assert_true(signal.aborted);
+    assert_equals(signal.reason, "reason 1",
+        "The signal should be aborted with the first reason");
+  }, `${desc} returns an aborted signal if passed an aborted signal ${suffix}`);
+
+  test(t => {
+    const controller = new controllerInterface();
+    const signal = signalInterface.any([controller.signal, controller.signal]);
+    assert_false(signal.aborted);
+    controller.abort("reason");
+    assert_true(signal.aborted);
+    assert_equals(signal.reason, "reason");
+  }, `${desc} can be passed the same signal more than once ${suffix}`);
+
+  test(t => {
+    const controller1 = new controllerInterface();
+    controller1.abort("reason 1");
+    const controller2 = new controllerInterface();
+    controller2.abort("reason 2");
+
+    const signal = signalInterface.any([controller1.signal, controller2.signal, controller1.signal]);
+    assert_true(signal.aborted);
+    assert_equals(signal.reason, "reason 1");
+  }, `${desc} uses the first instance of a duplicate signal ${suffix}`);
+
+  test(t => {
+    for (let i = 0; i < 3; ++i) {
+      const controllers = [];
+      for (let j = 0; j < 3; ++j) {
+        controllers.push(new controllerInterface());
+      }
+      const combinedSignal1 =
+          signalInterface.any([controllers[0].signal, controllers[1].signal]);
+      const combinedSignal2 =
+          signalInterface.any([combinedSignal1, controllers[2].signal]);
+
+      let eventFired = false;
+      combinedSignal2.onabort = t.step_func((e) => {
+        eventFired = true;
+      });
+
+      controllers[i].abort();
+      assert_true(eventFired);
+      assert_true(combinedSignal2.aborted);
+      assert_true(combinedSignal2.reason instanceof DOMException,
+          "signal.reason is a DOMException");
+      assert_equals(combinedSignal2.reason.name, "AbortError",
+          "signal.reason is a AbortError");
+    }
+  }, `${desc} signals are composable ${suffix}`);
+
+  async_test(t => {
+    const controller = new controllerInterface();
+    const timeoutSignal = AbortSignal.timeout(5);
+
+    const combinedSignal = signalInterface.any([controller.signal, timeoutSignal]);
+
+    combinedSignal.onabort = t.step_func_done(() => {
+      assert_true(combinedSignal.aborted);
+      assert_true(combinedSignal.reason instanceof DOMException,
+          "combinedSignal.reason is a DOMException");
+      assert_equals(combinedSignal.reason.name, "TimeoutError",
+          "combinedSignal.reason is a TimeoutError");
+    });
+  }, `${desc} works with signals returned by AbortSignal.timeout() ${suffix}`);
+
+  test(t => {
+    const controller = new controllerInterface();
+    let combined = signalInterface.any([controller.signal]);
+    combined = signalInterface.any([combined]);
+    combined = signalInterface.any([combined]);
+    combined = signalInterface.any([combined]);
+
+    let eventFired = false;
+    combined.onabort = () => {
+      eventFired = true;
+    }
+
+    assert_false(eventFired);
+    assert_false(combined.aborted);
+
+    controller.abort("the reason");
+
+    assert_true(eventFired);
+    assert_true(combined.aborted);
+    assert_equals(combined.reason, "the reason");
+  }, `${desc} works with intermediate signals ${suffix}`);
+
+  test(t => {
+    const controller = new controllerInterface();
+    const signals = [];
+    // The first event should be dispatched on the originating signal.
+    signals.push(controller.signal);
+    // All dependents are linked to `controller.signal` (never to another
+    // composite signal), so this is the order events should fire.
+    signals.push(signalInterface.any([controller.signal]));
+    signals.push(signalInterface.any([controller.signal]));
+    signals.push(signalInterface.any([signals[0]]));
+    signals.push(signalInterface.any([signals[1]]));
+
+    let result = "";
+    for (let i = 0; i < signals.length; i++) {
+      signals[i].addEventListener('abort', () => {
+        result += i;
+      });
+    }
+    controller.abort();
+    assert_equals(result, "01234");
+  }, `Abort events for ${desc} signals fire in the right order ${suffix}`);
+}
diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json
index 266e6b4a92a20c..2b8b03da53bfa2 100644
--- a/test/fixtures/wpt/versions.json
+++ b/test/fixtures/wpt/versions.json
@@ -8,7 +8,7 @@
     "path": "console"
   },
   "dom/abort": {
-    "commit": "8fadb381209a215280dc3ad96d0f135b6005f176",
+    "commit": "d1f1ecbd52f2eab3b7fe5dc1b20b41174f1341ce",
     "path": "dom/abort"
   },
   "dom/events": {

From fff6b40370f863c4969a40eaeb160ff2f6f4548b Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Tue, 2 May 2023 22:02:17 +0300
Subject: [PATCH 02/10] CR

---
 doc/api/globals.md               | 2 +-
 lib/internal/abort_controller.js | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/doc/api/globals.md b/doc/api/globals.md
index 5e5ef761a94d9a..dc530b796f68b8 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -127,7 +127,7 @@ Returns a new `AbortSignal` which will be aborted in `delay` milliseconds.
 added: REPLACEME
 -->
 
-* `signals` {Array} The `AbortSignal`s of which to compose a new `AbortSignal`.
+* `signals` {AbortSignal\[]} The `AbortSignal`s of which to compose a new `AbortSignal`.
 
 Returns a new `AbortSignal` which will be aborted if any of the provided
 signals are aborted. Its [`abortSignal.reason`][] will be set to whichever
diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index bd9e196f8243b8..b427a928469a88 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -198,21 +198,20 @@ class AbortSignal extends EventTarget {
     validateAbortSignalArray(signals, 'signals');
     const resultSignal = createAbortSignal({ composite: true });
     const resultSignalWeakRef = new WeakRef(resultSignal);
+    resultSignal[kSourceSignals] = new SafeSet();
     for (let i = 0; i < signals.length; i++) {
       const signal = signals[i];
       if (signal.aborted) {
         abortSignal(resultSignal, signal.reason);
         return resultSignal;
       }
-      resultSignal[kSourceSignals] ??= new SafeSet();
       signal[kDependantSignals] ??= new SafeSet();
       if (!signal[kComposite]) {
         resultSignal[kSourceSignals].add(new WeakRef(signal));
         signal[kDependantSignals].add(resultSignalWeakRef);
+      } else if (!signal[kSourceSignals]) {
+        continue;
       } else {
-        if (!signal[kSourceSignals]) {
-          continue;
-        }
         for (const sourceSignal of signal[kSourceSignals]) {
           const sourceSignalRef = sourceSignal.deref();
           if (!sourceSignalRef) {

From f86f5bb2edc4f7470de4da919da41498c85ca3b1 Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Wed, 3 May 2023 07:22:18 +0300
Subject: [PATCH 03/10] experimental

---
 doc/api/globals.md               | 2 ++
 lib/internal/abort_controller.js | 5 +++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/doc/api/globals.md b/doc/api/globals.md
index dc530b796f68b8..b3b88946bec89c 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -127,6 +127,8 @@ Returns a new `AbortSignal` which will be aborted in `delay` milliseconds.
 added: REPLACEME
 -->
 
+> Stability: 1 - Experimental
+
 * `signals` {AbortSignal\[]} The `AbortSignal`s of which to compose a new `AbortSignal`.
 
 Returns a new `AbortSignal` which will be aborted if any of the provided
diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index b427a928469a88..6e47cea4b5a445 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -28,6 +28,7 @@ const {
 const {
   createDeferredPromise,
   customInspectSymbol,
+  emitExperimentalWarning,
   kEmptyObject,
   kEnumerableProperty,
 } = require('internal/util');
@@ -195,6 +196,7 @@ class AbortSignal extends EventTarget {
    * @returns {AbortSignal}
    */
   static any(signals) {
+    emitExperimentalWarning('AbortSignal.any');
     validateAbortSignalArray(signals, 'signals');
     const resultSignal = createAbortSignal({ composite: true });
     const resultSignalWeakRef = new WeakRef(resultSignal);
@@ -365,8 +367,7 @@ function abortSignal(signal, reason) {
   signal.dispatchEvent(event);
   signal[kDependantSignals]?.forEach((s) => {
     const signalRef = s.deref();
-    if (!signalRef) return;
-    abortSignal(signalRef, reason);
+    if (signalRef) abortSignal(signalRef, reason);
   });
 }
 

From 2ab215a4fe25b7fa0c37f8b742b54da654a27128 Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Fri, 5 May 2023 12:39:45 +0300
Subject: [PATCH 04/10] add UT

---
 test/parallel/test-abortsignal-any.mjs | 107 +++++++++++++++++++++++++
 1 file changed, 107 insertions(+)
 create mode 100644 test/parallel/test-abortsignal-any.mjs

diff --git a/test/parallel/test-abortsignal-any.mjs b/test/parallel/test-abortsignal-any.mjs
new file mode 100644
index 00000000000000..99f1c6ddd97ca5
--- /dev/null
+++ b/test/parallel/test-abortsignal-any.mjs
@@ -0,0 +1,107 @@
+import * as common from '../common/index.mjs';
+import { describe, it } from 'node:test';
+import { setTimeout } from 'node:timers/promises';
+import assert from 'node:assert';
+
+describe('AbortSignal.any()', { concurrency: true }, () => {
+  it('should throw when not receiving an array', () => {
+    const regex = /The "signals" argument must be an instance of Array\. Received/;
+    assert.throws(() => AbortSignal.any(), regex);
+    assert.throws(() => AbortSignal.any(null), regex);
+    assert.throws(() => AbortSignal.any(undefined), regex);
+  });
+
+  it('should throw when input contains non-signal values', () => {
+    try {
+      AbortSignal.any([AbortSignal.abort(), undefined]);
+      assert.fail('AbortSignal.any() should not accept an input with non-signals');
+    } catch (err) {
+      assert.strictEqual(
+        err.message,
+        'The "signals[1]" argument must be an instance of AbortSignal. Received undefined'
+      );
+    }
+  });
+
+  it('creates a non-aborted signal for an empty input', () => {
+    const signal = AbortSignal.any([]);
+    assert.strictEqual(signal.aborted, false);
+    signal.addEventListener('abort', common.mustNotCall());
+  });
+
+  it('returns a new signal', () => {
+    const originalSignal = new AbortController().signal;
+    const signalAny = AbortSignal.any([originalSignal]);
+    assert.notStrictEqual(originalSignal, signalAny);
+  });
+
+  it('returns an aborted signal if input has an aborted signal', () => {
+    const signal = AbortSignal.any([AbortSignal.abort('some reason')]);
+    assert.strictEqual(signal.aborted, true);
+    assert.strictEqual(signal.reason, 'some reason');
+    signal.addEventListener('abort', common.mustNotCall());
+  });
+
+  it('returns an aborted signal with the reason of first aborted signal input', () => {
+    const signal = AbortSignal.any([AbortSignal.abort('some reason'), AbortSignal.abort('another reason')]);
+    assert.strictEqual(signal.aborted, true);
+    assert.strictEqual(signal.reason, 'some reason');
+    signal.addEventListener('abort', common.mustNotCall());
+  });
+
+  it('returns the correct signal in the event target', async () => {
+    const signal = AbortSignal.any([AbortSignal.timeout(5)]);
+    signal.addEventListener('abort', common.mustCall((e) => {
+      assert.strictEqual(e.target, signal);
+    }));
+    await setTimeout(10);
+    assert.ok(signal.aborted);
+    assert.strictEqual(signal.reason.name, 'TimeoutError');
+    assert.strictEqual(signal.reason.message, 'The operation was aborted due to timeout');
+  });
+
+  it('aborts with reason of first aborted signal', () => {
+    const controllers = Array.from({ length: 3 }, () => new AbortController());
+    const combinedSignal = AbortSignal.any(controllers.map((c) => c.signal));
+    controllers[1].abort(1);
+    controllers[2].abort(2);
+    assert.ok(combinedSignal.aborted);
+    assert.strictEqual(combinedSignal.reason, 1);
+  });
+
+  it('can accept the same signal more than once', () => {
+    const controller = new AbortController();
+    const signal = AbortSignal.any([controller.signal, controller.signal]);
+    assert.strictEqual(signal.aborted, false);
+    controller.abort('reason');
+    assert.ok(signal.aborted);
+    assert.strictEqual(signal.reason, 'reason');
+  });
+
+  it('handles deeply aborted signals', async () => {
+    const controllers = Array.from({ length: 2 }, () => new AbortController());
+    const composedSignal1 = AbortSignal.any([controllers[0].signal]);
+    const composedSignal2 = AbortSignal.any([composedSignal1, controllers[1].signal]);
+
+    composedSignal2.onabort = common.mustCall();
+    controllers[0].abort();
+    assert.ok(composedSignal2.aborted);
+    assert.ok(composedSignal2.reason instanceof DOMException);
+    assert.strictEqual(composedSignal2.reason.name, 'AbortError');
+  });
+
+  it('executes abort handlers in correct order', () => {
+    const controller = new AbortController();
+    const signals = [];
+    signals.push(controller.signal);
+    signals.push(AbortSignal.any([controller.signal]));
+    signals.push(AbortSignal.any([controller.signal]));
+    signals.push(AbortSignal.any([signals[0]]));
+    signals.push(AbortSignal.any([signals[1]]));
+
+    let result = '';
+    signals.forEach((signal, i) => signal.addEventListener('abort', () => result += i));
+    controller.abort();
+    assert.strictEqual(result, '01234');
+  });
+});

From db2c783e941dc1c5184b25fd96fddc5db1fb8de5 Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Sun, 7 May 2023 21:34:03 +0300
Subject: [PATCH 05/10] wip

---
 lib/internal/abort_controller.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index 6e47cea4b5a445..c94296e462476f 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -195,6 +195,22 @@ class AbortSignal extends EventTarget {
    * @param {AbortSignal[]} signals
    * @returns {AbortSignal}
    */
+  // static any(signals) {
+  //   // emitExperimentalWarning('AbortSignal.any');
+  //   validateAbortSignalArray(signals, 'signals');
+  //   const ac = new AbortController();
+  //   for (let i = 0; i < signals.length; i++) {
+  //     const signal = signals[i];
+  //     if (signal.aborted) {
+  //       ac.abort(signal.reason);
+  //       return ac.signal;
+  //     }
+  //     signal.addEventListener("abort", (e) => {
+  //       ac.abort(e.target.reason);
+  //     }, { once: true, [kWeakHandler]: ac.signal });
+  //   }
+  //   return ac.signal;
+  // }
   static any(signals) {
     emitExperimentalWarning('AbortSignal.any');
     validateAbortSignalArray(signals, 'signals');

From 6086ef6a09e80f04d665d859c10498e918741300 Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Mon, 15 May 2023 11:57:19 +0300
Subject: [PATCH 06/10] CR

---
 lib/internal/abort_controller.js       | 18 ------------------
 test/parallel/test-abortsignal-any.mjs | 25 +++++++++++--------------
 2 files changed, 11 insertions(+), 32 deletions(-)

diff --git a/lib/internal/abort_controller.js b/lib/internal/abort_controller.js
index c94296e462476f..779d2a7c39144a 100644
--- a/lib/internal/abort_controller.js
+++ b/lib/internal/abort_controller.js
@@ -28,7 +28,6 @@ const {
 const {
   createDeferredPromise,
   customInspectSymbol,
-  emitExperimentalWarning,
   kEmptyObject,
   kEnumerableProperty,
 } = require('internal/util');
@@ -195,24 +194,7 @@ class AbortSignal extends EventTarget {
    * @param {AbortSignal[]} signals
    * @returns {AbortSignal}
    */
-  // static any(signals) {
-  //   // emitExperimentalWarning('AbortSignal.any');
-  //   validateAbortSignalArray(signals, 'signals');
-  //   const ac = new AbortController();
-  //   for (let i = 0; i < signals.length; i++) {
-  //     const signal = signals[i];
-  //     if (signal.aborted) {
-  //       ac.abort(signal.reason);
-  //       return ac.signal;
-  //     }
-  //     signal.addEventListener("abort", (e) => {
-  //       ac.abort(e.target.reason);
-  //     }, { once: true, [kWeakHandler]: ac.signal });
-  //   }
-  //   return ac.signal;
-  // }
   static any(signals) {
-    emitExperimentalWarning('AbortSignal.any');
     validateAbortSignalArray(signals, 'signals');
     const resultSignal = createAbortSignal({ composite: true });
     const resultSignalWeakRef = new WeakRef(resultSignal);
diff --git a/test/parallel/test-abortsignal-any.mjs b/test/parallel/test-abortsignal-any.mjs
index 99f1c6ddd97ca5..8fff1edbf68733 100644
--- a/test/parallel/test-abortsignal-any.mjs
+++ b/test/parallel/test-abortsignal-any.mjs
@@ -5,22 +5,20 @@ import assert from 'node:assert';
 
 describe('AbortSignal.any()', { concurrency: true }, () => {
   it('should throw when not receiving an array', () => {
-    const regex = /The "signals" argument must be an instance of Array\. Received/;
-    assert.throws(() => AbortSignal.any(), regex);
-    assert.throws(() => AbortSignal.any(null), regex);
-    assert.throws(() => AbortSignal.any(undefined), regex);
+    const expectedError = { code: 'ERR_INVALID_ARG_TYPE' };
+    assert.throws(() => AbortSignal.any(), expectedError);
+    assert.throws(() => AbortSignal.any(null), expectedError);
+    assert.throws(() => AbortSignal.any(undefined), expectedError);
   });
 
   it('should throw when input contains non-signal values', () => {
-    try {
-      AbortSignal.any([AbortSignal.abort(), undefined]);
-      assert.fail('AbortSignal.any() should not accept an input with non-signals');
-    } catch (err) {
-      assert.strictEqual(
-        err.message,
-        'The "signals[1]" argument must be an instance of AbortSignal. Received undefined'
-      );
-    }
+    assert.throws(
+      () => AbortSignal.any([AbortSignal.abort(), undefined]),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        message: 'The "signals[1]" argument must be an instance of AbortSignal. Received undefined'
+      },
+    );
   });
 
   it('creates a non-aborted signal for an empty input', () => {
@@ -57,7 +55,6 @@ describe('AbortSignal.any()', { concurrency: true }, () => {
     await setTimeout(10);
     assert.ok(signal.aborted);
     assert.strictEqual(signal.reason.name, 'TimeoutError');
-    assert.strictEqual(signal.reason.message, 'The operation was aborted due to timeout');
   });
 
   it('aborts with reason of first aborted signal', () => {

From e09e0eea1e31e2faad3f4be2ccf7b4b4432b51d2 Mon Sep 17 00:00:00 2001
From: Filip Skokan <panva.ip@gmail.com>
Date: Mon, 15 May 2023 22:32:33 +0200
Subject: [PATCH 07/10] test: keep the event loop alive

---
 test/common/wpt.js        | 8 +++++---
 test/common/wpt/worker.js | 9 +++++++++
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/test/common/wpt.js b/test/common/wpt.js
index cc7c5320fa972e..5ff731e13051d5 100644
--- a/test/common/wpt.js
+++ b/test/common/wpt.js
@@ -680,7 +680,7 @@ class WPTRunner {
 
     process.on('exit', () => {
       for (const spec of this.inProgress) {
-        this.fail(spec, { name: 'Unknown' }, kIncomplete);
+        this.fail(spec, { name: 'Incomplete' }, kIncomplete);
       }
       inspect.defaultOptions.depth = Infinity;
       // Sorts the rules to have consistent output
@@ -796,9 +796,11 @@ class WPTRunner {
    * @param {object} harnessStatus - The status object returned by WPT harness.
    */
   completionCallback(spec, harnessStatus) {
+    const status = this.getTestStatus(harnessStatus.status);
+
     // Treat it like a test case failure
-    if (harnessStatus.status === 2) {
-      this.resultCallback(spec, { status: 2, name: 'Unknown' });
+    if (status === kTimeout) {
+      this.fail(spec, { name: 'WPT testharness timeout' }, kTimeout);
     }
     this.inProgress.delete(spec);
     // Always force termination of the worker. Some tests allocate resources
diff --git a/test/common/wpt/worker.js b/test/common/wpt/worker.js
index 80b32bf5b912e7..5638845131b7f1 100644
--- a/test/common/wpt/worker.js
+++ b/test/common/wpt/worker.js
@@ -48,8 +48,17 @@ add_result_callback((result) => {
   });
 });
 
+// Keep the event loop alive
+const timeout = setTimeout(() => {
+  parentPort.postMessage({
+    type: 'completion',
+    status: { status: 2 },
+  });
+}, Math.pow(2, 31) - 1); // Max timeout is 2^31-1, when overflown the timeout is set to 1
+
 // eslint-disable-next-line no-undef
 add_completion_callback((_, status) => {
+  clearTimeout(timeout);
   parentPort.postMessage({
     type: 'completion',
     status,

From b5be2a8d230532f8318af709cb31f6e40892e057 Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Tue, 16 May 2023 07:35:46 +0300
Subject: [PATCH 08/10] CR

---
 test/common/wpt/worker.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/common/wpt/worker.js b/test/common/wpt/worker.js
index 5638845131b7f1..855ec7e91c394b 100644
--- a/test/common/wpt/worker.js
+++ b/test/common/wpt/worker.js
@@ -54,7 +54,7 @@ const timeout = setTimeout(() => {
     type: 'completion',
     status: { status: 2 },
   });
-}, Math.pow(2, 31) - 1); // Max timeout is 2^31-1, when overflown the timeout is set to 1
+}, 2 ** 31 - 1); // Max timeout is 2^31-1, when overflown the timeout is set to 1.
 
 // eslint-disable-next-line no-undef
 add_completion_callback((_, status) => {

From a086465e8acc680e79f8623bc5821f9ecba16279 Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Wed, 17 May 2023 18:53:45 +0300
Subject: [PATCH 09/10] test no sleep

---
 test/parallel/test-abortsignal-any.mjs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/parallel/test-abortsignal-any.mjs b/test/parallel/test-abortsignal-any.mjs
index 8fff1edbf68733..ca99c98d122db4 100644
--- a/test/parallel/test-abortsignal-any.mjs
+++ b/test/parallel/test-abortsignal-any.mjs
@@ -1,6 +1,6 @@
 import * as common from '../common/index.mjs';
 import { describe, it } from 'node:test';
-import { setTimeout } from 'node:timers/promises';
+import { once } from 'node:events';
 import assert from 'node:assert';
 
 describe('AbortSignal.any()', { concurrency: true }, () => {
@@ -49,10 +49,10 @@ describe('AbortSignal.any()', { concurrency: true }, () => {
 
   it('returns the correct signal in the event target', async () => {
     const signal = AbortSignal.any([AbortSignal.timeout(5)]);
-    signal.addEventListener('abort', common.mustCall((e) => {
-      assert.strictEqual(e.target, signal);
-    }));
-    await setTimeout(10);
+    const interval = setInterval(() => {}, 100000); // Keep event loop alive
+    const [{ target }] = await once(signal, 'abort');
+    clearInterval(interval);
+    assert.strictEqual(target, signal);
     assert.ok(signal.aborted);
     assert.strictEqual(signal.reason.name, 'TimeoutError');
   });

From 28f5b847f4b199dbc2162b5422148f92196a35e3 Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Wed, 17 May 2023 19:10:36 +0300
Subject: [PATCH 10/10] fix

---
 doc/api/globals.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/doc/api/globals.md b/doc/api/globals.md
index b3b88946bec89c..dc530b796f68b8 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -127,8 +127,6 @@ Returns a new `AbortSignal` which will be aborted in `delay` milliseconds.
 added: REPLACEME
 -->
 
-> Stability: 1 - Experimental
-
 * `signals` {AbortSignal\[]} The `AbortSignal`s of which to compose a new `AbortSignal`.
 
 Returns a new `AbortSignal` which will be aborted if any of the provided