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

```ts
function race<TTasks>(
  tasks: TTasks,
): Task<
  InferTaskOk<TTasks[number]>,
  InferTaskErr<TTasks[number]>,
  ParameterIntersection<
    TTasks[number] extends TTask
      ? TTask extends AnyTask
        ? (deps: InferTaskDeps<TTask>) => void
        : never
      : never
  >
>;
```

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

Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s until the first Task settles.

Returns the first Task [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) to settle, whether [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) or
[Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/Err).

Use [any](https://evolu.dev/docs/api-reference/common/Task/functions/any) to wait for the first Ok instead.

Losing Tasks are aborted.

Tasks always run concurrently because racing sequentially would be
meaningless.

Similar to
[Promise.race](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race),
but races Tasks, returns Result values, and aborts losers.

Requires a non-empty array: zero Tasks have no meaningful first settled
Result. This is enforced at compile time for non-empty tuple types. For
arrays whose emptiness is only known at runtime, guard with
[isNonEmptyArray](https://evolu.dev/docs/api-reference/common/Array/functions/isNonEmptyArray):

### Runtime arrays

```ts
import {
  assertOk,
  createRun,
  isNonEmptyArray,
  ok,
  race,
  type Task,
} from "@evolu/common";

const tasks: ReadonlyArray<Task<string>> = [() => ok("first")];
await using run = createRun();
if (isNonEmptyArray(tasks)) {
  const result = await run(race(tasks));
  assertOk(result, "first");
}
```

### First settlement

```ts
import {
  assertFalse,
  assertOk,
  assertType,
  createRun,
  ok,
  race,
  sleep,
  type Result,
  type Task,
} from "@evolu/common";

await using run = createRun();

const fast: Task<string> = () => ok("fast");
let slowCompleted = false;
const slow: Task<string> = async (run) => {
  await run.ok(sleep("10ms"));
  slowCompleted = true;
  return ok("slow");
};

// Input order does not matter: the first settled Result wins, and the
// still-running loser is aborted.
const result = await run(race([slow, fast]));
assertType<Result<string>, typeof result>();
assertOk(result, "fast");
assertFalse(slowCompleted);
```