Racing promises and consuming them in the order of their resolution time
Issues
Lost resolution
You are issuing promises without a guarantee of being able to handle all or some of the resolving promises.
This will happen if promises resolve before you start the for await loop.
The offending code is in the line this.forEach(p =&gt; p.then(v =&gt; this.#resolve(v), e =&gt; this.#reject(e)));
The calls to this.#resolve and this.#reject require that the asyncIterator is run so that this.#resolve and this.#reject are assigned functions. If not they are undefined when a promise resolves.
It is also possible for a promise to overwrite the previous promise's resolved value without the iterator getting to see the value.
For example:

if you delay the call to sink(); with setTimeout(sink, 4000) none of the promises are handled within the function sink. The results are lost and can not be retrieved

If the iterator awaits content that allows more than one of the iterateable promises to resolve between iterations.
Example the following function loses the second promise. (given your test data)


async function sink() {
    const p = new Promise(v=&gt;setTimeout(v, 1200, &quot;zz&quot;))
    for await (const value of sortedPS){
       log(value);
       log(await p);
    };
};

Silencing errors!
Never silence errors that are not your responsibility.
You do this in the line:
super(...args.filter(p =&gt; Object(p).constructor === Promise)); // Make sure everybody is a Promise

Either throw an error or let the error happen naturally. If your code can not function correctly with the given arguments then throw
Example of vetting and throwing error:
constructor(...promises){
    super(...promises);
    if (promises.some(promise =&gt; !(promise instanceof Promise))) {
        throw new RangeError(&quot;Array can only contain Promises&quot;);
    }

Poor inheritance
You extend Array yet neglect to handle any of the inherited functions or properties.
For example one would expect that SortedPromisesArray.push would add a promise that will resolve. As it stands added promises are ignored.
Simple example of extending inherited function:
  push(...promises) {
      if (promises.some(promise =&gt; !(promise instanceof Promise))) {
          throw new RangeError(&quot;Array can only contain Promises&quot;);
      }      
      this.#count += promises.length;
      super.push(...promises);
      promises.forEach(p =&gt; p.then(v =&gt; this.#resolve(v), e =&gt; this.#reject(e)));
  }

The same would apply to any of the inherited functions that modify the arrays content.
Arrays are independent of content
However this leaves the problem of behaviors that can not be extended without the use of a proxy. Eg sortedPS[sortedPS.length] = new Promise(...)
Without a proxy you are left with an object that has inconsistent behavior.
It is therefor not advisable to extend Arrays if behavior of the extended array is dependent on the content of the array.
Update
I have added an example RaceAll as a factory that creates an async iterate-able object that races an array of promises in order of resolution.
This is achieved by marking promises with ids and using the id of resolved promises to remove then from the race array.
It does not include any vetting, nor does it resolve rejected / failed promises (both can easily be implemented).
It does guarantee no promises are lost and does not require iteration before any promises are resolved.
function RaceAll(...promises) {
    var racing = promises.map((promise, id) =&gt; Object.assign(
            new Promise(r =&gt; promise.then(result =&gt; r({id, result}))), {id}
        ));
    return Object.freeze({
            async *[Symbol.asyncIterator]() {
                while (racing.length) {
                    const resolved = await Promise.race(racing);
                    yield resolved.result;
                    racing = racing.filter(r =&gt; r.id !== resolved.id);
                }
            }
        });
}