[API reference](https://evolu.dev/docs/api-reference) › [@evolu/common](https://evolu.dev/docs/api-reference/common) › Task JavaScript-native structured concurrency. Structured concurrency organizes running tasks into a tree. Every child belongs to a parent, a parent waits for its children before it completes, and abort propagates from parents to descendants. Races and fail-fast control flow abort siblings that are no longer needed. With plain [AbortController](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) code, these guarantees depend on call-site discipline: someone must remember the `finally` that aborts started tasks and the await that waits for cleanup. Evolu makes both structural: `run(task)` registers every child before it starts, and the parent [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) settles only after child cleanup finishes. Evolu implements structured concurrency with: - A [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) is a function passed to Run that returns an [Awaitable](https://evolu.dev/docs/api-reference/common/Types/type-aliases/Awaitable) [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) and declares its dependencies. - A [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) starts Tasks and owns their lifetimes. - A [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber) is the Promise-backed handle returned when a Run starts a Task. - An [AbortableFiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/AbortableFiber) adds explicit abort and async disposal. Together, these APIs provide abort, cleanup, defect handling, dependency injection, monitoring, and resource management. Tasks return a [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) containing either success or a domain error. Abort is control flow represented by [AbortError](https://evolu.dev/docs/api-reference/common/Task/variables/AbortError). If a Task throws or rejects with anything else, that is a defect: the root Run reports it and shuts down its tree so code does not continue in a potentially invalid state. ```ts import { assertOk, assertType, createRun, err, ok, type Result, type Task, type Typed, } from "@evolu/common"; interface User { readonly id: string; readonly name: string; } interface Db { readonly usersById: ReadonlyMap; } interface DbDep { readonly db: Db; } const getUser = (id: string): Task => (run) => { const user = run.deps.db.usersById.get(id); return user ? ok(user) : err({ type: "UserNotFound", id }); }; // Typed declares the `type` discriminant without repeating the property. interface UserNotFoundError extends Typed<"UserNotFound"> { readonly id: string; } const user: User = { id: "user-1", name: "Ada" }; // Provide dependencies at the composition root. `await using` disposes the // Run and waits for its child Tasks before leaving this scope. await using run = createRun({ db: { usersById: new Map([[user.id, user]]) }, }); const result = await run(getUser(user.id)); assertType, typeof result>(); assertOk(result, user); ``` In composition roots, prefer the lifecycle API from the matching Evolu platform package: - Node.js: `@evolu/nodejs` - Web: `@evolu/web` - React Native: `@evolu/react-native` ## Composition | Category | Helper | Description | | ------------ | ------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | Collection | [all](https://evolu.dev/docs/api-reference/common/Task/functions/all) | Return [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) values or stop on first [Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/Err) | | | [allSettled](https://evolu.dev/docs/api-reference/common/Task/functions/allSettled) | Return every Task Result | | | [each](https://evolu.dev/docs/api-reference/common/Task/functions/each) | Handle each Task Result | | Interop | [callback](https://evolu.dev/docs/api-reference/common/Task/functions/callback) | Wrap callback APIs | | | [fetch](https://evolu.dev/docs/api-reference/common/Http/functions/fetch) | Native fetch with bounded Response use | | Timing | [sleep](https://evolu.dev/docs/api-reference/common/Task/functions/sleep) | Pause execution | | | [timeout](https://evolu.dev/docs/api-reference/common/Task/functions/timeout) | Time-bounded execution | | Resilience | [retry](https://evolu.dev/docs/api-reference/common/Task/functions/retry) | Retry domain errors with a schedule | | Repetition | [repeat](https://evolu.dev/docs/api-reference/common/Task/functions/repeat) | Repeat successes with a schedule | | Racing | [any](https://evolu.dev/docs/api-reference/common/Task/functions/any) | First Ok wins | | | [race](https://evolu.dev/docs/api-reference/common/Task/functions/race) | First settled Result wins | | | [firstN](https://evolu.dev/docs/api-reference/common/Task/functions/firstN) | First n Ok values win | | | [firstNSettled](https://evolu.dev/docs/api-reference/common/Task/functions/firstNSettled) | First n Results win | | Scheduling | [prioritized](https://evolu.dev/docs/api-reference/common/Task/functions/prioritized) | Assign scheduler priority | | | [yieldNow](https://evolu.dev/docs/api-reference/common/Task/variables/yieldNow) | Yield to the host scheduler | | Lifetime | [daemon](https://evolu.dev/docs/api-reference/common/Task/functions/daemon) | Run under root ownership | | | [acquireUseRelease](https://evolu.dev/docs/api-reference/common/Task/functions/acquireUseRelease) | Bracket acquire, use, and release | | Abortability | [unabortable](https://evolu.dev/docs/api-reference/common/Task/variables/unabortable) | Mask abort after a Task starts | | | [unabortableMask](https://evolu.dev/docs/api-reference/common/Task/functions/unabortableMask) | Mask abort and selectively restore it | Helpers that process multiple Tasks run sequentially by default. Use a `concurrency` option to run more than one Task at a time. ### Sequential composition For ordinary sequential composition, use imperative code: ```ts import { assertOk, assertType, createRun, err, ok, type Result, type Task, type Typed, } from "@evolu/common"; interface User { readonly id: string; readonly profileId: string; } interface Profile { readonly id: string; } const getUser = (id: string): Task => () => id === "user-1" ? ok({ id, profileId: "profile-1" }) : err({ type: "UserNotFound", id }); interface UserNotFoundError extends Typed<"UserNotFound"> { readonly id: string; } const getProfile = (id: string): Task => () => id === "profile-1" ? ok({ id }) : err({ type: "ProfileNotFound", id }); interface ProfileNotFoundError extends Typed<"ProfileNotFound"> { readonly id: string; } const getUserWithProfile = ( id: string, ): Task< { readonly user: User; readonly profile: Profile }, UserNotFoundError | ProfileNotFoundError > => async (run) => { const user = await run(getUser(id)); if (!user.ok) return user; const profile = await run(getProfile(user.value.profileId)); if (!profile.ok) return profile; return ok({ user: user.value, profile: profile.value }); }; await using run = createRun(); const result = await run(getUserWithProfile("user-1")); assertType< Result< { readonly user: User; readonly profile: Profile }, UserNotFoundError | ProfileNotFoundError >, typeof result >(); assertOk(result, { user: { id: "user-1", profileId: "profile-1" }, profile: { id: "profile-1" }, }); ``` Evolu intentionally avoids pipe APIs, chainable methods, and generator-based effect DSLs. Plain async/await with early returns is easier to read, review, and debug, and it lets TypeScript narrow Result values through ordinary control flow. ### Resilient fetch [fetch](https://evolu.dev/docs/api-reference/common/Http/functions/fetch) with a body mode already returns a plain value, so resilience is ordinary Task composition. Combine [timeout](https://evolu.dev/docs/api-reference/common/Task/functions/timeout) and [retry](https://evolu.dev/docs/api-reference/common/Task/functions/retry) to bound each attempt and retry recoverable domain errors: ```ts import { assertType, exponential, fetch, jitter, maxDelay, retry, take, timeout, type FetchError, type RetryTaskError, type Task, type TimeoutError, } from "@evolu/common"; const fetchWithRetry = (url: string) => retry( timeout(fetch(url, "text"), "30s"), // A jittered, capped, limited exponential backoff. jitter("100%")(maxDelay("20s")(take(2)(exponential("100ms")))), ); assertType< Task>, ReturnType >(); ``` ### Concurrent composition Run composed Tasks with a `concurrency` option and [all](https://evolu.dev/docs/api-reference/common/Task/functions/all): ```ts import { assertEqual, assertOk, all, createRun, ok, sleep, type Task, } from "@evolu/common"; await using run = createRun(); const urls = [ "https://api.example.com/users", "https://api.example.com/posts", "https://api.example.com/comments", ]; let activeRequests = 0; let maxActiveRequests = 0; const fetchUrl = (url: string): Task => async (run) => { activeRequests += 1; maxActiveRequests = Math.max(maxActiveRequests, activeRequests); await run.ok(sleep("1ms")); activeRequests -= 1; return ok(url); }; // At most 2 concurrent requests. const result = await run(all(urls, fetchUrl, { concurrency: 2 })); assertOk(result, urls); assertEqual(maxActiveRequests, 2); ``` Task helpers compose Tasks; concurrency primitives are stateful objects that coordinate Tasks across call sites. Create them with their `createX` factories and share them where coordination is needed. | Primitive | Description | | ------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | | [Deferred](https://evolu.dev/docs/api-reference/common/Task/interfaces/Deferred) | One-shot value resolved from outside | | [Gate](https://evolu.dev/docs/api-reference/common/Task/interfaces/Gate) | Block and release Tasks repeatedly | | [Semaphore](https://evolu.dev/docs/api-reference/common/Task/interfaces/Semaphore) | Limit concurrent Tasks with permits | | [Mutex](https://evolu.dev/docs/api-reference/common/Task/interfaces/Mutex) | Run Tasks one at a time | | [SemaphoreByKey](https://evolu.dev/docs/api-reference/common/Task/interfaces/SemaphoreByKey) | Per-key permits with automatic cleanup | | [MutexByKey](https://evolu.dev/docs/api-reference/common/Task/interfaces/MutexByKey) | Per-key one-at-a-time execution | | [MutexRef](https://evolu.dev/docs/api-reference/common/Task/interfaces/MutexRef) | [Ref](https://evolu.dev/docs/api-reference/common/Ref/interfaces/Ref) with serialized Task transitions | ## Dependency injection Task DI is [Evolu Pure DI](https://www.evolu.dev/docs/dependency-injection) applied to [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run). A [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) declares required capabilities with its `D` type parameter and reads them from [Run.deps](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run#deps). [createRun](https://evolu.dev/docs/api-reference/common/Task/variables/createRun) supplies dependencies to the root Run and its children. A Run can also start one child Task with runtime-created dependencies by calling `run(task, deps)`, where `deps` is checked as [RunCustomDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RunCustomDeps). Use normal Task arguments for per-call values and `D` for capabilities, resources, or services shared by all code running inside a Run. ```ts interface GreetingFormatter { readonly format: (name: string) => string; } interface GreetingFormatterDep { readonly greetingFormatter: GreetingFormatter; } const greet = (name: string): Task => (run) => ok(run.deps.greetingFormatter.format(name)); const formal: GreetingFormatter = { format: (name) => `Hello, ${name}`, }; const casual: GreetingFormatter = { format: (name) => `Hi, ${name}`, }; await using run = createRun({ greetingFormatter: formal }); // Root dependencies are inherited. assertOk(await run(greet("Ada")), "Hello, Ada"); // Child-specific dependencies replace the root's custom dependencies. assertOk(await run(greet("Ada"), { greetingFormatter: casual }), "Hi, Ada"); ``` ### Default dependencies [createRun](https://evolu.dev/docs/api-reference/common/Task/variables/createRun) provides default [RunDefaultDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RunDefaultDeps) available to all Tasks without declaring `D`: - [Console](https://evolu.dev/docs/api-reference/common/Console/interfaces/Console) — logging with hierarchical context via `child()` - [LeakDetector](https://evolu.dev/docs/api-reference/common/LeakDetector/interfaces/LeakDetector) — development-time leaked-handle detection - [NativeFetch](https://evolu.dev/docs/api-reference/common/Http/type-aliases/NativeFetch) — WHATWG-compatible native fetch - [Random](https://evolu.dev/docs/api-reference/common/Random/interfaces/Random) — random number generation - [RandomBytes](https://evolu.dev/docs/api-reference/common/Crypto/interfaces/RandomBytes) — cryptographic random bytes - [ReportDefect](https://evolu.dev/docs/api-reference/common/Task/type-aliases/ReportDefect) — defect reporting - [Time](https://evolu.dev/docs/api-reference/common/Time/interfaces/Time) — current time For testing, use [testCreateRun](https://evolu.dev/docs/api-reference/common/Task/functions/testCreateRun) to get deterministic, controllable implementations of all RunDefaultDeps. ## Resource management JavaScript provides standard [resource management](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Resource_management). Evolu adds [DisposableRun.defer](https://evolu.dev/docs/api-reference/common/Task/interfaces/DisposableRun#defer) for closure-held state owned by a reusable Run. Choose the ownership primitive by where the resource is reachable: - Synchronous stack frame: `using` or [DisposableStack](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DisposableStack) - Async Task stack frame: `await using` or [AsyncDisposableStack](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncDisposableStack) - Closure-held state bounded by a reusable [DisposableRun](https://evolu.dev/docs/api-reference/common/Task/interfaces/DisposableRun): [DisposableRun.defer](https://evolu.dev/docs/api-reference/common/Task/interfaces/DisposableRun#defer) ### Returning resources from Tasks A Task that successfully returns a disposable resource transfers ownership of a live resource to its caller. The resource must remain live after the Task settles. Do not register its disposal with the creating Task's [DisposableRun.defer](https://evolu.dev/docs/api-reference/common/Task/interfaces/DisposableRun#defer), because that child Run is disposed when the Task settles. Use [AsyncDisposableStack](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncDisposableStack) while creating a resource. On a Result error, abort, or defect, stack unwinding disposes partially created resources. On success, [AsyncDisposableStack.move](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncDisposableStack/move) transfers ownership to the returned resource. A recoverable creation failure should be a typed Result error; `undefined` should represent valid absence, not failure. ```ts import { assertEqual, assertFalse, assertTrue, createRun, ok, type Task, type Typed, } from "@evolu/common"; interface Socket extends AsyncDisposable { readonly send: (message: string) => string; } interface Connection extends AsyncDisposable { readonly send: (message: string) => string; } let socketDisposed = false; const openSocket: Task = () => ok({ send: (message) => message, [Symbol.asyncDispose]: () => { socketDisposed = true; return Promise.resolve(); }, }); interface ConnectionFailedError extends Typed<"ConnectionFailed"> {} const handshake = (_socket: Socket): Task => () => ok(); const createConnection: Task = async ( run, ) => { await using disposer = new AsyncDisposableStack(); const socketResult = await run(openSocket); if (!socketResult.ok) return socketResult; const socket = disposer.use(socketResult.value); const handshakeResult = await run(handshake(socket)); if (!handshakeResult.ok) return handshakeResult; const disposables = disposer.move(); return ok({ send: (message) => socket.send(message), [Symbol.asyncDispose]: () => disposables.disposeAsync(), }); }; await using run = createRun(); const result = await run(createConnection); assertTrue(result.ok); assertFalse(socketDisposed); assertEqual(result.value.send("hello"), "hello"); await result.value[Symbol.asyncDispose](); assertTrue(socketDisposed); ``` Use [Run.ok](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run#ok) with `await using` when a Task whose error type is `never` returns a disposable value. Use [acquireUseRelease](https://evolu.dev/docs/api-reference/common/Task/functions/acquireUseRelease) when acquisition and release are separate steps rather than a disposable value. ## Awaitable A [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) returns [Awaitable](https://evolu.dev/docs/api-reference/common/Types/type-aliases/Awaitable), so its body may produce a [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) immediately or asynchronously. [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) is always async and returns a [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber); callers use the same ownership model either way. - **Sync** → [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result), native `using` / `DisposableStack` - **Async** → Task, Run, [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber), `await using` / `AsyncDisposableStack` A Task is an async ownership boundary, not a general unit of program decomposition. Calling `run(task)` always creates a child Run by design. Use a plain async function when it does not need its own Run. A unified sync/async effect API is technically possible. It can detect Promise-like values with [isPromiseLike](https://evolu.dev/docs/api-reference/common/Types/functions/isPromiseLike), dispose synchronous resources first, continue with asynchronous disposal when necessary, and track whether callers must await the result. Evolu deliberately keeps the two models separate instead: plain functions and Result for synchronous code, Task and Run for asynchronous ownership. Most effects involve inherently asynchronous I/O, while synchronous code benefits from a simpler API and no Task overhead. Keep synchronous computation as plain functions returning Result. Prefer passing values rather than dependencies, following the [impure/pure/impure sandwich](https://blog.ploeh.dk/2017/02/02/dependency-rejection/) pattern where impure code gathers data, pure functions process it, and impure code performs effects with the result. For example, a pure function can accept a [RandomNumber](https://evolu.dev/docs/api-reference/common/Random/type-aliases/RandomNumber) value instead of depending on [Random](https://evolu.dev/docs/api-reference/common/Random/interfaces/Random). Large CPU-bound computations, such as parsing large JSON, sorting millions of items, or complex cryptography, belong in a worker. Model the asynchronous call to that worker as a Task so Run can provide timeout, abort, cleanup, and monitoring. ## Glossary - **Defect** — a thrown or rejected value other than [AbortError](https://evolu.dev/docs/api-reference/common/Task/variables/AbortError), rather than a declared [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) error. - **Outcome** — a Fiber's settlement: resolution with the Task [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result), or rejection with [AbortError](https://evolu.dev/docs/api-reference/common/Task/variables/AbortError). The original defect is reported through [ReportDefectDep](https://evolu.dev/docs/api-reference/common/Task/interfaces/ReportDefectDep) whether or not the Fiber is observed; the Fiber boundary represents the panic with AbortError whose reason is [PanicAbortReason](https://evolu.dev/docs/api-reference/common/Task/interfaces/PanicAbortReason). - **Create** — construct a new value or a resource. - **Acquire** — obtain a usable resource. Acquisition may create a new resource, borrow one, open one, or take a lease/lock. - **Release** — relinquish a previously acquired resource or lease. Release pairs with acquire and need not mean disposal; examples include unlock, logout, or returning a pooled resource. - **Dispose / disposal** — owner-driven resource finalization via JavaScript resource management (`Symbol.dispose`, `Symbol.asyncDispose`, `using`, `AsyncDisposableStack`). ## FAQ ### Why is AbortError not part of every Task error type? The `E` type parameter represents declared domain errors. Abort is structured-concurrency control flow, not a domain error. A direct `run(task)` rejects with [AbortError](https://evolu.dev/docs/api-reference/common/Task/variables/AbortError) when the Task observes abort. Use `run.abortable(task)` when abort should be handled as an ordinary [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) error at the Fiber boundary, or `daemon(task)` when waiting for a Task should stop immediately after abort. ### Do I have to await every Fiber? No. Awaiting a Fiber is join: it makes the child outcome part of the current control flow. When the outcome does not matter — a fire-and-forget side effect — discard the Fiber explicitly with `void run(task)`. That is safe because the Run tree supervises every Fiber it creates. A discarded Fiber whose Task observes abort (for example during Run disposal) never surfaces as an unhandled rejection, and cleanup is not lost — disposal already aborts and awaits the child. Defects are different: they still panic the root Run and are reported through [ReportDefectDep](https://evolu.dev/docs/api-reference/common/Task/interfaces/ReportDefectDep), so discarding a Fiber never hides bugs. Choose the boundary explicitly: - `void run(task)` — the outcome does not matter. Abort is silent; defects are still reported. - `await run(task)` — the continuation depends on the Result, so abort rejects into the awaiter and the boundary must handle it. - `run.abortable(task)` — abort is an expected outcome handled as a [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) error. ### What should Task code do with defects? Nothing. Once a defect reaches the [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run), it is too late: the root Run panics, running Tasks are aborted, and the Run tree shuts down. Use [trySync](https://evolu.dev/docs/api-reference/common/Result/functions/trySync) or [tryAsync](https://evolu.dev/docs/api-reference/common/Result/functions/tryAsync) to turn recoverable exceptions and Promise rejections into typed [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) errors. Let unrecoverable failures propagate as defects. ### Why does a defect panic the whole Run tree? The obvious alternative is partial recovery: only the failing subtree shuts down or restarts while the rest keeps running. Erlang/OTP made this "let it crash" model with supervisors the benchmark for fault-tolerant runtime design. Erlang can recover partially because of process isolation: each process owns its heap, so a crashed process cannot leave another process's state corrupted. JavaScript Tasks share a heap. A defect may throw after partially updating shared state, and the Run cannot prove which invariants are still valid. A subtree panic would stop the failing Task while leaving any corrupted shared state available to surviving Tasks. Locks make it worse: a defect inside a critical section may leave protected invariants half-updated. In-process restart is not a reliable recovery boundary either, because the restarted code may still share the same module state, closures, caches, or resources. JavaScript does have a boundary with Erlang-like isolation: workers. A worker has its own heap and structured-clone messaging, so corruption cannot cross the boundary, and respawning a worker starts from clean state. A defect can panic the worker's Run tree, the worker boundary can be torn down, and the supervising side decides whether to respawn — [retry](https://evolu.dev/docs/api-reference/common/Task/functions/retry) with a [Schedule](https://evolu.dev/docs/api-reference/common/Schedule/type-aliases/Schedule) around a "spawn worker, run until exit" Task is a one-for-one supervisor. Multiple root Runs that share no mutable state are a lighter alternative, but the share-nothing guarantee is then architectural discipline rather than enforced isolation, so keep it opt-in and rare. ### Why imperative code instead of monadic effect composition? Monads give pure functional languages a way to sequence effects while keeping functions pure. JavaScript already has native effect sequencing: loops, early returns, `try`/`finally`, exceptions, and `async`/`await`. A monadic effect wrapper moves that control flow into a library DSL. The wrapper type becomes viral, and ordinary debugging, profiling, stack traces, and TypeScript narrowing have to work through the DSL instead of the language. Task follows the opposite approach: Tasks are ordinary async functions, Run owns lifetimes and scoped context, [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) carries expected domain errors, and defects keep real exceptions with real stacks. Result propagation is explicit at each async boundary, so TypeScript narrows it through ordinary control flow and readers can see where an error is handled or returned. ### Are recursive Tasks stack-safe? Tasks have native JavaScript stack behavior. A deeply recursive Task can exceed the call stack when each step starts the next step synchronously. `await` alone does not prevent this: JavaScript evaluates its operand before suspending, and `run(nextTask)` starts the child Task immediately. Implement deep recursive algorithms with a loop and an explicit worklist so each iteration reuses the same stack frame: ```ts interface TreeNode { readonly value: string; readonly children: ReadonlyArray; } const visitTree = (root: TreeNode): Task> => () => { const remaining = [root]; const visited: Array = []; while (remaining.length > 0) { const node = remaining.pop(); if (!node) continue; visited.push(node.value); for (const child of node.children) remaining.push(child); } return ok(visited); }; await using run = createRun(); assertOk( await run( visitTree({ value: "root", children: [{ value: "child", children: [] }], }), ), ["root", "child"], ); ``` Task favors direct native execution, `async`/`await`, and native tooling over interpreted control flow. The trade-off is no transparent stack safety or automatic scheduling fairness. Use loops or worklists for deep algorithms, periodically await [yieldNow](https://evolu.dev/docs/api-reference/common/Task/variables/yieldNow) for cooperative scheduling, and move CPU-bound work to a worker. ### Where are fork and join? Calling `run(task)` is fork: it starts a child Task and returns a [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber). Awaiting or returning that Fiber is join: it makes the child Result or rejection part of the parent Task control flow. ### What runtime features does Task require? Task uses modern JavaScript APIs such as `Promise.withResolvers`, `AbortSignal.throwIfAborted`, `Symbol.dispose`, `Symbol.asyncDispose`, `DisposableStack`, and `AsyncDisposableStack`. Evolu provides polyfills for supported runtimes that need them: call `installPolyfills` from `@evolu/common/polyfills`, or from the platform package such as `@evolu/react-native/polyfills`. The `using` and `await using` syntax is emitted by TypeScript; the polyfills provide the runtime resource-management globals. ## Core | Name | Description | | ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [AbortableFiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/AbortableFiber) | A [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber) with explicit abort and async-disposal controls. | | [AbortError](https://evolu.dev/docs/api-reference/common/Task/interfaces/AbortError) | Structured-concurrency abort control-flow value. | | [AbortReason](https://evolu.dev/docs/api-reference/common/Task/interfaces/AbortReason) | Structured data explaining why a [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) was aborted. | | [DisposableRun](https://evolu.dev/docs/api-reference/common/Task/interfaces/DisposableRun) | A [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) with explicit disposal. | | [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber) | A Promise-backed handle to a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) started by a [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run). | | [PanicAbortReason](https://evolu.dev/docs/api-reference/common/Task/interfaces/PanicAbortReason) | Abort reason recorded when a defect panics the root [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run). | | [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) | A callable object that starts [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s and owns their lifetimes. | | [RunAbortState](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunAbortState) | [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) abort state. | | [RunStateAborted](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunStateAborted) | The [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) has an abort request and may still be running or disposing. | | [RunStateRunning](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunStateRunning) | The [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) has no abort request, observed abort, or exit. | | [RunStateSettled](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunStateSettled) | The [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) has recorded its final outcome and all descendants have settled. | | [NextTask](https://evolu.dev/docs/api-reference/common/Task/type-aliases/NextTask) | A [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) that can return a value, signal done, or return a [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) error. | | [RunCustomDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RunCustomDeps) | Custom deps accepted by [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) APIs. | | [RunExit](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RunExit) | Final outcome recorded by a [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run). | | [RunState](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RunState) | [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) lifetime states. | | [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) | A function passed to [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) that returns an [Awaitable](https://evolu.dev/docs/api-reference/common/Types/type-aliases/Awaitable) [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) and declares its dependencies through `D`. | | [AbortError](https://evolu.dev/docs/api-reference/common/Task/variables/AbortError) | Runtime Type for structured-concurrency abort control flow. | | [AbortReason](https://evolu.dev/docs/api-reference/common/Task/variables/AbortReason) | Runtime Type for structured data explaining why a [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) was aborted. | | [createAbortError](https://evolu.dev/docs/api-reference/common/Task/functions/createAbortError) | Creates an [AbortError](https://evolu.dev/docs/api-reference/common/Task/variables/AbortError) from an [AbortReason](https://evolu.dev/docs/api-reference/common/Task/variables/AbortReason). | | [createPanicAbortReason](https://evolu.dev/docs/api-reference/common/Task/functions/createPanicAbortReason) | Creates a [PanicAbortReason](https://evolu.dev/docs/api-reference/common/Task/interfaces/PanicAbortReason) from a defect. | ## Run | Name | Description | | ------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | [CreateRun](https://evolu.dev/docs/api-reference/common/Task/interfaces/CreateRun) | Factory type for creating root [DisposableRun](https://evolu.dev/docs/api-reference/common/Task/interfaces/DisposableRun) instances. | | [ReportDefectDep](https://evolu.dev/docs/api-reference/common/Task/interfaces/ReportDefectDep) | Dependency wrapper for [ReportDefect](https://evolu.dev/docs/api-reference/common/Task/type-aliases/ReportDefect). | | [ReportDefect](https://evolu.dev/docs/api-reference/common/Task/type-aliases/ReportDefect) | Reports a defect. | | [RunDefaultDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RunDefaultDeps) | Default dependencies provided by [createRun](https://evolu.dev/docs/api-reference/common/Task/variables/createRun). | | [createRun](https://evolu.dev/docs/api-reference/common/Task/variables/createRun) | Creates a root [DisposableRun](https://evolu.dev/docs/api-reference/common/Task/interfaces/DisposableRun). | | [explicitAbortReason](https://evolu.dev/docs/api-reference/common/Task/variables/explicitAbortReason) | Shared abort reason used when callers explicitly request abort without a more specific reason. | | [reportDefectAfterMicrotask](https://evolu.dev/docs/api-reference/common/Task/variables/reportDefectAfterMicrotask) | Default [ReportDefect](https://evolu.dev/docs/api-reference/common/Task/type-aliases/ReportDefect) for platform-independent [createRun](https://evolu.dev/docs/api-reference/common/Task/variables/createRun). | | [runDisposedAbortReason](https://evolu.dev/docs/api-reference/common/Task/variables/runDisposedAbortReason) | Shared abort reason used for ordinary [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) cleanup. | | [createRunDefaultDeps](https://evolu.dev/docs/api-reference/common/Task/functions/createRunDefaultDeps) | Creates [RunDefaultDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RunDefaultDeps). | ## Collection | Name | Description | | --------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [AllOptions](https://evolu.dev/docs/api-reference/common/Task/interfaces/AllOptions) | Options for [all](https://evolu.dev/docs/api-reference/common/Task/functions/all). | | [TaskCollectionOptions](https://evolu.dev/docs/api-reference/common/Task/interfaces/TaskCollectionOptions) | Options shared by [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) collection helpers. | | [EachCallback](https://evolu.dev/docs/api-reference/common/Task/type-aliases/EachCallback) | Handles one settled [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) from [each](https://evolu.dev/docs/api-reference/common/Task/functions/each). | | [EachDecision](https://evolu.dev/docs/api-reference/common/Task/type-aliases/EachDecision) | Decision returned by an [each](https://evolu.dev/docs/api-reference/common/Task/functions/each) result handler. | | [all](https://evolu.dev/docs/api-reference/common/Task/functions/all) | Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s until all return [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) or one returns [Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/Err). | | [allSettled](https://evolu.dev/docs/api-reference/common/Task/functions/allSettled) | Runs all [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s and returns every Task [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result). | | [each](https://evolu.dev/docs/api-reference/common/Task/functions/each) | Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s under a concurrency limit and calls `onResult` for each Task [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) as it settles. | ## Lifetime | Function | Description | | ------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [acquireUseRelease](https://evolu.dev/docs/api-reference/common/Task/functions/acquireUseRelease) | Runs acquire, use, and release as one bracketed [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task). | | [daemon](https://evolu.dev/docs/api-reference/common/Task/functions/daemon) | Starts a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) with [Run.daemon](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run#daemon) and waits until it settles or the current Run aborts. | ## Interop | Function | Description | | ------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------- | | [callback](https://evolu.dev/docs/api-reference/common/Task/functions/callback) | Creates a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) from a callback-based API. | ## Timing | Name | Description | | ---------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [TimeoutError](https://evolu.dev/docs/api-reference/common/Task/interfaces/TimeoutError) | Error returned by [timeout](https://evolu.dev/docs/api-reference/common/Task/functions/timeout) when a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) exceeds its duration. | | [timeoutError](https://evolu.dev/docs/api-reference/common/Task/variables/timeoutError) | The [TimeoutError](https://evolu.dev/docs/api-reference/common/Task/variables/TimeoutError-1) instance returned by [timeout](https://evolu.dev/docs/api-reference/common/Task/functions/timeout). | | [TimeoutError](https://evolu.dev/docs/api-reference/common/Task/variables/TimeoutError-1) | Runtime Type for the error returned by [timeout](https://evolu.dev/docs/api-reference/common/Task/functions/timeout) when a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) exceeds its duration. | | [sleep](https://evolu.dev/docs/api-reference/common/Task/functions/sleep) | Pauses execution for a specified [PositiveDuration](https://evolu.dev/docs/api-reference/common/Time/type-aliases/PositiveDuration). | | [timeout](https://evolu.dev/docs/api-reference/common/Task/functions/timeout) | Limits how long a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) may run. | ## Resilience | Name | Description | | --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [RetryAttempt](https://evolu.dev/docs/api-reference/common/Task/interfaces/RetryAttempt) | Information passed to [RetryOptions.onRetry](https://evolu.dev/docs/api-reference/common/Task/interfaces/RetryOptions#onretry). | | [RetryError](https://evolu.dev/docs/api-reference/common/Task/interfaces/RetryError) | Error returned by [retry](https://evolu.dev/docs/api-reference/common/Task/functions/retry) when retrying stops after a domain error. | | [RetryOptions](https://evolu.dev/docs/api-reference/common/Task/interfaces/RetryOptions) | Options for [retry](https://evolu.dev/docs/api-reference/common/Task/functions/retry). | | [RetryTaskError](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RetryTaskError) | Error type returned by [retry](https://evolu.dev/docs/api-reference/common/Task/functions/retry). | | [retry](https://evolu.dev/docs/api-reference/common/Task/functions/retry) | Retries a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) according to a [Schedule](https://evolu.dev/docs/api-reference/common/Schedule/type-aliases/Schedule). | ## Repetition | Name | Description | | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [RepeatAttempt](https://evolu.dev/docs/api-reference/common/Task/interfaces/RepeatAttempt) | Information passed to [RepeatOptions.onRepeat](https://evolu.dev/docs/api-reference/common/Task/interfaces/RepeatOptions#onrepeat). | | [RepeatOptions](https://evolu.dev/docs/api-reference/common/Task/interfaces/RepeatOptions) | Options for [repeat](https://evolu.dev/docs/api-reference/common/Task/functions/repeat). | | [repeat](https://evolu.dev/docs/api-reference/common/Task/functions/repeat) | Repeats a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) according to a [Schedule](https://evolu.dev/docs/api-reference/common/Schedule/type-aliases/Schedule). | ## Racing | Function | Description | | ---------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [any](https://evolu.dev/docs/api-reference/common/Task/functions/any) | Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s until one returns [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) or all return [Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/Err). | | [firstN](https://evolu.dev/docs/api-reference/common/Task/functions/firstN) | 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. | | [firstNSettled](https://evolu.dev/docs/api-reference/common/Task/functions/firstNSettled) | Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s until `count` Tasks settle or all Tasks settle. | | [race](https://evolu.dev/docs/api-reference/common/Task/functions/race) | Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s until the first Task settles. | ## Scheduling | Name | Description | | ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | | [TaskPriority](https://evolu.dev/docs/api-reference/common/Task/type-aliases/TaskPriority) | Scheduler priority for [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s started through a native scheduler. | | [yieldNow](https://evolu.dev/docs/api-reference/common/Task/variables/yieldNow) | Yields execution to the host scheduler. | | [prioritized](https://evolu.dev/docs/api-reference/common/Task/functions/prioritized) | Assigns static scheduler priority to a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task). | ## Abortability | Name | Description | | -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [AbortMask](https://evolu.dev/docs/api-reference/common/Task/type-aliases/AbortMask) | Abort mask depth for a [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run). | | [unabortable](https://evolu.dev/docs/api-reference/common/Task/variables/unabortable) | Makes a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) unabortable after it starts. | | [waitForAbort](https://evolu.dev/docs/api-reference/common/Task/variables/waitForAbort) | Waits until the current [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) aborts, then rejects with its [AbortError](https://evolu.dev/docs/api-reference/common/Task/variables/AbortError). | | [unabortableMask](https://evolu.dev/docs/api-reference/common/Task/functions/unabortableMask) | Like [unabortable](https://evolu.dev/docs/api-reference/common/Task/variables/unabortable), but provides `restore` for child [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s that should run with the previous abort mask. | ## Concurrency primitives | Name | Description | | --------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [CreateMutexByKeyOptions](https://evolu.dev/docs/api-reference/common/Task/interfaces/CreateMutexByKeyOptions) | Options for [createMutexByKey](https://evolu.dev/docs/api-reference/common/Task/functions/createMutexByKey). | | [CreateSemaphoreByKeyOptions](https://evolu.dev/docs/api-reference/common/Task/interfaces/CreateSemaphoreByKeyOptions) | Options for [createSemaphoreByKey](https://evolu.dev/docs/api-reference/common/Task/functions/createSemaphoreByKey). | | [Deferred](https://evolu.dev/docs/api-reference/common/Task/interfaces/Deferred) | A one-shot value resolved from outside the waiting [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task). | | [Gate](https://evolu.dev/docs/api-reference/common/Task/interfaces/Gate) | A reusable gate for blocking and releasing [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s. | | [Mutex](https://evolu.dev/docs/api-reference/common/Task/interfaces/Mutex) | Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s one at a time. | | [MutexByKey](https://evolu.dev/docs/api-reference/common/Task/interfaces/MutexByKey) | Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s one at a time independently for each key, like [Mutex](https://evolu.dev/docs/api-reference/common/Task/interfaces/Mutex). | | [MutexRef](https://evolu.dev/docs/api-reference/common/Task/interfaces/MutexRef) | [Ref](https://evolu.dev/docs/api-reference/common/Ref/interfaces/Ref) protected by a [Mutex](https://evolu.dev/docs/api-reference/common/Task/interfaces/Mutex). | | [Semaphore](https://evolu.dev/docs/api-reference/common/Task/interfaces/Semaphore) | Coordinates concurrent [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s by acquiring and releasing permits. | | [SemaphoreByKey](https://evolu.dev/docs/api-reference/common/Task/interfaces/SemaphoreByKey) | Coordinates concurrent [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s independently for each key. | | [SemaphorePermit](https://evolu.dev/docs/api-reference/common/Task/interfaces/SemaphorePermit) | An owned semaphore acquisition returned by [Semaphore.take](https://evolu.dev/docs/api-reference/common/Task/interfaces/Semaphore#take). | | [SemaphoreSnapshot](https://evolu.dev/docs/api-reference/common/Task/interfaces/SemaphoreSnapshot) | Snapshot returned by [Semaphore.snapshot](https://evolu.dev/docs/api-reference/common/Task/interfaces/Semaphore#snapshot). | | [SemaphorePolicy](https://evolu.dev/docs/api-reference/common/Task/type-aliases/SemaphorePolicy) | Scheduling policy for semaphore acquisition. | | [createDeferred](https://evolu.dev/docs/api-reference/common/Task/functions/createDeferred) | Creates a [Deferred](https://evolu.dev/docs/api-reference/common/Task/interfaces/Deferred). | | [createGate](https://evolu.dev/docs/api-reference/common/Task/functions/createGate) | Creates a [Gate](https://evolu.dev/docs/api-reference/common/Task/interfaces/Gate). | | [createMutex](https://evolu.dev/docs/api-reference/common/Task/functions/createMutex) | Creates a [Mutex](https://evolu.dev/docs/api-reference/common/Task/interfaces/Mutex). | | [createMutexByKey](https://evolu.dev/docs/api-reference/common/Task/functions/createMutexByKey) | Creates a [MutexByKey](https://evolu.dev/docs/api-reference/common/Task/interfaces/MutexByKey). | | [createMutexRef](https://evolu.dev/docs/api-reference/common/Task/functions/createMutexRef) | Creates a [MutexRef](https://evolu.dev/docs/api-reference/common/Task/interfaces/MutexRef). | | [createSemaphore](https://evolu.dev/docs/api-reference/common/Task/functions/createSemaphore) | Creates a [Semaphore](https://evolu.dev/docs/api-reference/common/Task/interfaces/Semaphore). | | [createSemaphoreByKey](https://evolu.dev/docs/api-reference/common/Task/functions/createSemaphoreByKey) | Creates a [SemaphoreByKey](https://evolu.dev/docs/api-reference/common/Task/interfaces/SemaphoreByKey). | ## Monitoring | Name | Description | | --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | | [RunConfig](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunConfig) | Configuration for [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) monitoring behavior. | | [RunConfigDep](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunConfigDep) | Dependency wrapper for [RunConfig](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunConfig). | | [RunEvent](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunEvent) | Event emitted by a [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) for monitoring and debugging. | | [RunEventDataChildAdded](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunEventDataChildAdded) | A child [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) was added to the emitting Run. | | [RunEventDataChildRemoved](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunEventDataChildRemoved) | A child [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) was removed from the emitting Run. | | [RunEventDataStateChanged](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunEventDataStateChanged) | The emitting [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) changed state. | | [RunSnapshot](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunSnapshot) | Recursive snapshot of a [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) tree. | | [RunEventData](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RunEventData) | Event-specific payload of a [RunEvent](https://evolu.dev/docs/api-reference/common/Task/interfaces/RunEvent). | ## Testing | Name | Description | | ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [TestReportDefect](https://evolu.dev/docs/api-reference/common/Task/interfaces/TestReportDefect) | Test [ReportDefect](https://evolu.dev/docs/api-reference/common/Task/type-aliases/ReportDefect) that records reported defects. | | [TestReportDefectDep](https://evolu.dev/docs/api-reference/common/Task/interfaces/TestReportDefectDep) | Dependency wrapper for [TestReportDefect](https://evolu.dev/docs/api-reference/common/Task/interfaces/TestReportDefect). | | [TestRunDep](https://evolu.dev/docs/api-reference/common/Task/interfaces/TestRunDep) | Provides a test [Run](https://evolu.dev/docs/api-reference/common/Task/interfaces/Run) with deterministic default dependencies. | | [TestRunDefaultDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/TestRunDefaultDeps) | Deterministic test variants of [RunDefaultDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/RunDefaultDeps). | | [testAbortError](https://evolu.dev/docs/api-reference/common/Task/variables/testAbortError) | Shared [AbortError](https://evolu.dev/docs/api-reference/common/Task/variables/AbortError) for tests, created from [testAbortReason](https://evolu.dev/docs/api-reference/common/Task/variables/testAbortReason). | | [testAbortReason](https://evolu.dev/docs/api-reference/common/Task/variables/testAbortReason) | Shared abort reason for tests that need a non-production abort reason. | | [testCreateDeps](https://evolu.dev/docs/api-reference/common/Task/functions/testCreateDeps) | Creates [TestRunDefaultDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/TestRunDefaultDeps). | | [testCreateReportDefect](https://evolu.dev/docs/api-reference/common/Task/functions/testCreateReportDefect) | Creates [TestReportDefect](https://evolu.dev/docs/api-reference/common/Task/interfaces/TestReportDefect). | | [testCreateRun](https://evolu.dev/docs/api-reference/common/Task/functions/testCreateRun) | Creates a root [DisposableRun](https://evolu.dev/docs/api-reference/common/Task/interfaces/DisposableRun) with [TestRunDefaultDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/TestRunDefaultDeps). | ## Type utilities | Type Alias | Description | | ------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [AnyFiber](https://evolu.dev/docs/api-reference/common/Task/type-aliases/AnyFiber) | Shorthand for a [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber) with `any` type parameters. | | [AnyTask](https://evolu.dev/docs/api-reference/common/Task/type-aliases/AnyTask) | Shorthand for a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) with `any` type parameters. | | [InferFiberDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferFiberDeps) | Extracts the dependency type from a [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber). | | [InferFiberErr](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferFiberErr) | Extracts the [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) error type from a [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber). | | [InferFiberOk](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferFiberOk) | Extracts the [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) value type from a [Fiber](https://evolu.dev/docs/api-reference/common/Task/interfaces/Fiber). | | [InferTaskDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferTaskDeps) | Extracts the dependency type from a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task). | | [InferTaskDone](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferTaskDone) | Extracts the done value type from a [NextTask](https://evolu.dev/docs/api-reference/common/Task/type-aliases/NextTask). | | [InferTaskErr](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferTaskErr) | Extracts the [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) error type from a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task). | | [InferTaskOk](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferTaskOk) | Extracts the [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) value type from a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task). | | [InferTaskRecordDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferTaskRecordDeps) | Extracts the dependency intersection required by a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) record. | | [InferTasksDeps](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferTasksDeps) | Extracts the dependency intersection required by a readonly [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) array. | | [InferTasksOk](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferTasksOk) | Maps a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) array or record to the [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) values produced by its Tasks. | | [InferTasksResult](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferTasksResult) | Extracts the [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) type produced by one [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) in a non-empty Task array. | | [InferTasksSettled](https://evolu.dev/docs/api-reference/common/Task/type-aliases/InferTasksSettled) | Maps a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) array or record to the [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) values produced by its Tasks. | | [TaskRecord](https://evolu.dev/docs/api-reference/common/Task/type-aliases/TaskRecord) | A readonly record whose values are [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s. | | [TaskWithError](https://evolu.dev/docs/api-reference/common/Task/type-aliases/TaskWithError) | A [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) whose error type is not `never`. |