[API reference](https://evolu.dev/docs/api-reference) › [@evolu/common](https://evolu.dev/docs/api-reference/common) › [Task](https://evolu.dev/docs/api-reference/common/Task) › firstNSettled

```ts
function firstNSettled<TTasks>(
  tasks: TTasks,
  count: Int1To100OrPositiveInt,
  options?: TaskCollectionOptions,
): Task<
  readonly InferTasksResult<TTasks>[],
  never,
  ParameterIntersection<
    TTasks[number] extends TTask
      ? TTask extends AnyTask
        ? (deps: InferTaskDeps<TTask>) => void
        : never
      : never
  >
>;
```

Defined in: [packages/common/src/Task.ts:4527](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L4527)

Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s until `count` Tasks settle or all Tasks settle.

Returns [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) with Task [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result)s in settlement order, not input
order. When `count` Results have settled, queued Tasks are not started and
remaining running Tasks are aborted. If fewer than `count` Tasks settle,
returns the Results that did settle.

Sequential by default; pass a `concurrency` option to run more than one Task
at a time. The count uses [Int1To100OrPositiveInt](https://evolu.dev/docs/api-reference/common/Number/type-aliases/Int1To100OrPositiveInt): pass `1` to `100` as
a literal, or a validated [PositiveInt](https://evolu.dev/docs/api-reference/common/Type/variables/PositiveInt) for larger values.

### Example

```ts
import {
  assertFalse,
  assertOk,
  createRun,
  err,
  firstNSettled,
  ok,
  sleep,
  type Task,
  type Typed,
} from "@evolu/common";

let slowCompleted = false;
const slow: Task<string> = async (run) => {
  await run.ok(sleep("10ms"));
  slowCompleted = true;
  return ok("slow");
};
const unavailable: Task<never, ServiceUnavailableError> = () =>
  err({ type: "ServiceUnavailable" });

interface ServiceUnavailableError extends Typed<"ServiceUnavailable"> {}

const tasks = [slow, unavailable, () => ok("fast")] as const;
await using run = createRun();

// Err and Ok both count, and Results use settlement order.
const result = await run(firstNSettled(tasks, 2, { concurrency: 3 }));
assertOk(result, [
  { ok: false, error: { type: "ServiceUnavailable" } },
  { ok: true, value: "fast" },
]);
assertFalse(slowCompleted);
```