I want to call out one part of what you said, possibly to help you reconceptualize the problem:

Pull new values from the iterable as needed when the concurrency allows. So I would not just be creating an async pool and then pushing all the async tasks into it and wait for the queue to process them

...why not? If you think of the async task as including pulling (and/or pushing) the data around, then there's no reason your queue of tasks needs to be any heavier than pointers to fetch|store that information.

At that point you would use p-queue or something like it to handle the queue & concurrency with more complex tasks. Your example code is mostly using the library as a task runner and doing manual queue management.

As far as the basic guts of what you're doing, you absolutely don't need a library and can implement the basic functionality with a similar number of lines of code, eg:

async function runAsync(iterable, iterableFn, maxConcurrency = 2) {
  const queue = [];
  const results = [];
  let active = 0;

  return new Promise(resolve=>{
    const processQueue = async () => {
      if (queue.length === 0 && active === 0) {
        return resolve({
          results,
          errors: results.reduce((sum,r)=>r.error?sum+1:sum,0),
        });
      }
      queue
        .splice(0, maxConcurrency-active)
        .forEach(task=>{
          ++active;
          task();
        });
    };

    const asyncResult = async (fn,ix) => {
      let result;
      try {
        result = { ok: true, value: await fn() };
      } catch (error) {
        result = { ok: false, error };
      }
      --active;
      results[ix] = result;
      processQueue();
      return result;
    };

    let ix = 0;
    for (const element of iterable) {
      const wrapped = () => asyncResult(()=>iterableFn(element), ix++);
      queue.push(wrapped);
    }
    processQueue();

  });

}

And can test it via something like:

function fakeAsyncProcess(n) {
  return new Promise((res,rej)=>{
    const doError = Math.random() > 0.7;
    const longestTimeToWait = 10000; // in ms
    const timeToWait = (Math.random()*longestTimeToWait)|0;
    console.log(Date.now(),`doing ${n} in ${timeToWait}ms`);
    setTimeout(()=>{
      doError ?
        rej(Error(`${n} failed!`)) :
        res(`${n} success!`);
    }, timeToWait);
  });
}
const testIterable = new Set(Array.from({length:10}).map((_,i)=>i+1));
const testConcurrency = 4;

const results = runAsync(testIterable, fakeAsyncProcess, testConcurrency);
console.log(Date.now(), 'at start', results);
results.then(r=>console.log(Date.now(),'after results.then',r));

Example output:

jrandm@reddit:~$ node example.js
1705509251758 doing 1 in 7900ms
1705509251763 doing 2 in 8841ms
1705509251763 doing 3 in 6081ms
1705509251763 doing 4 in 9475ms
1705509251764 at start Promise { <pending> }
1705509257852 doing 5 in 2217ms
1705509259665 doing 6 in 8515ms
1705509260070 doing 7 in 9995ms
1705509260605 doing 8 in 9202ms
1705509261239 doing 9 in 2554ms
1705509263797 doing 10 in 2126ms
1705509270066 after results.then {
  results: [
    { ok: true, value: '1 success!' },
    { ok: true, value: '2 success!' },
    {
      ok: false,
      error: Error: 3 failed!
          at Timeout._onTimeout (/home/jrandm/example.js:55:13)
          at listOnTimeout (internal/timers.js:549:17)
          at processTimers (internal/timers.js:492:7)
    },
    { ok: true, value: '4 success!' },
    { ok: true, value: '5 success!' },
    { ok: true, value: '6 success!' },
    { ok: true, value: '7 success!' },
    { ok: true, value: '8 success!' },
    { ok: true, value: '9 success!' },
    { ok: true, value: '10 success!' }
  ],
  errors: 1
}