Implement a concurrency-limited task runner with retry.

Two ideas, composed.

Concurrency limit. Promises start running when they are created, so the runner cannot accept promises. It accepts task functions and decides when to call each one. The simplest correct pool starts limit workers. Each worker is an async loop that claims the next unclaimed index, runs that task, stores the result at the same index, and repeats until nothing is left. Because JavaScript runs one job at a time, nextIndex++ needs no lock, and no two workers get the same task. At most limit tasks are in flight, a slot is reused as soon as a task ends, and results[index] keeps input order whatever the finish order.

Retry with backoff. A loop calls the task, returns on success, and after a failure waits baseDelayMs * 2 ** attempt (100, 200, 400, ...) before the next attempt. When the attempts are used up it throws the last error. Retrying lives inside the worker, so a task being retried keeps its slot and the limit still holds during backoff.

Failure. The runner is fail-fast like Promise.all. The first task that exhausts its retries rejects the whole call, and a failed flag stops workers from claiming new tasks. Tasks already in flight cannot be cancelled and finish on their own.

What this skips, on purpose: jitter on the delay and a maximum delay, a predicate to decide which errors are worth retrying, a per-task timeout, cancellation of in-flight tasks via AbortSignal, and settled-style results (allSettled) instead of fail-fast. Each is a small addition, but each adds options and states, so add them when a requirement asks for them.

async function withRetry(task, { retries, baseDelayMs }) {
  for (let attempt = 0; ; attempt++) {
    try {
      return await task();
    } catch (error) {
      if (attempt >= retries) throw error;
      await new Promise((resolve) => setTimeout(resolve, baseDelayMs * 2 ** attempt));
    }
  }
}

async function runTasks(tasks, { limit, retries = 0, baseDelayMs = 100 }) {
  if (!Number.isInteger(limit) || limit < 1) throw new RangeError('limit must be a positive integer');
  const results = new Array(tasks.length);
  let nextIndex = 0;
  let failed = false;
  async function worker() {
    while (!failed && nextIndex < tasks.length) {
      const index = nextIndex++;
      try {
        results[index] = await withRetry(tasks[index], { retries, baseDelayMs });
      } catch (error) {
        failed = true;
        throw error;
      }
    }
  }
  await Promise.all(Array.from({ length: Math.min(limit, tasks.length) }, worker));
  return results;
}

• Accepting an array of promises. They have already started, so the limit would limit nothing. Take functions.
• Chunking: for (const batch of chunks(tasks, limit)) await Promise.all(batch). It is correct but wasteful: each batch waits for its slowest task while slots sit idle. Workers that pull the next task keep all slots busy.
• Forgetting the stop flag. Without it, after one task fails, the other workers keep claiming and running the remaining tasks although the caller already got a rejection.
• Retrying everything. A validation error or a 404 will fail the same way every time. Real code passes a shouldRetry(error) predicate, which this version leaves out.