[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) › firstN

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

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

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

Returns [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) with Ok values in settlement order, not input order.
[Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/Err) [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result)s are ignored. When `count` Ok values have settled,
queued Tasks are not started and remaining running Tasks are aborted. If
fewer than `count` Tasks return Ok, returns the Ok values 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,
  firstN,
  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-1"),
  () => ok("fast-2"),
] as const;
await using run = createRun();

// Errs do not count. After two Ok values settle, the slow Task is aborted.
const result = await run(firstN(tasks, 2, { concurrency: 4 }));
assertOk(result, ["fast-1", "fast-2"]);
assertFalse(slowCompleted);
```