@evolu/common 8.5.0 → 8.6.0

package/src/Task.ts

@@ -1,6 +1,4 @@
 /**
- * ## Intro
- *
  * JavaScript-native structured concurrency.
  *
  * Structured concurrency organizes running tasks into a tree. Every child
@@ -34,6 +32,8 @@
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   createRun,
  *   err,
  *   ok,
@@ -76,8 +76,8 @@
  * });
  *
  * const result = await run(getUser(user.id));
- * expectTypeOf(result).toEqualTypeOf<Result<User, UserNotFoundError>>();
- * expectOk(result, user);
+ * assertType<Result<User, UserNotFoundError>, typeof result>();
+ * assertOk(result, user);
  * ```
  *
  * In composition roots, prefer the lifecycle API from the matching Evolu
@@ -120,6 +120,8 @@
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   createRun,
  *   err,
  *   ok,
@@ -178,13 +180,14 @@
  *
  * await using run = createRun();
  * const result = await run(getUserWithProfile("user-1"));
- * expectTypeOf(result).toEqualTypeOf<
+ * assertType<
  *   Result<
  *     { readonly user: User; readonly profile: Profile },
  *     UserNotFoundError | ProfileNotFoundError
- *   >
+ *   >,
+ *   typeof result
  * >();
- * expectOk(result, {
+ * assertOk(result, {
  *   user: { id: "user-1", profileId: "profile-1" },
  *   profile: { id: "profile-1" },
  * });
@@ -203,6 +206,7 @@
  *
  * ```ts
  * import {
+ *   assertType,
  *   exponential,
  *   fetch,
  *   jitter,
@@ -223,8 +227,9 @@
  *     jitter("100%")(maxDelay("20s")(take(2)(exponential("100ms")))),
  *   );
  *
- * expectTypeOf(fetchWithRetry).returns.toEqualTypeOf<
- *   Task<string, RetryTaskError<FetchError | TimeoutError>>
+ * assertType<
+ *   Task<string, RetryTaskError<FetchError | TimeoutError>>,
+ *   ReturnType<typeof fetchWithRetry>
  * >();
  * ```
  *
@@ -233,7 +238,15 @@
  * Run composed Tasks with a `concurrency` option and {@link all}:
  *
  * ```ts
- * import { all, createRun, ok, sleep, type Task } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   all,
+ *   createRun,
+ *   ok,
+ *   sleep,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * await using run = createRun();
  *
@@ -256,8 +269,8 @@
  *
  * // At most 2 concurrent requests.
  * const result = await run(all(urls, fetchUrl, { concurrency: 2 }));
- * expectOk(result, urls);
- * expect(maxActiveRequests).toBe(2);
+ * assertOk(result, urls);
+ * assertEqual(maxActiveRequests, 2);
  * ```
  *
  * Task helpers compose Tasks; concurrency primitives are stateful objects that
@@ -289,7 +302,7 @@
  * resources, or services shared by all code running inside a Run.
  *
  * ```ts
- * import { createRun, ok, type Task } from "@evolu/common";
+ * import { assertOk, createRun, ok, type Task } from "@evolu/common";
  *
  * interface GreetingFormatter {
  *   readonly format: (name: string) => string;
@@ -314,10 +327,10 @@
  * await using run = createRun({ greetingFormatter: formal });
  *
  * // Root dependencies are inherited.
- * expectOk(await run(greet("Ada")), "Hello, Ada");
+ * assertOk(await run(greet("Ada")), "Hello, Ada");
  *
  * // Child-specific dependencies replace the root's custom dependencies.
- * expectOk(
+ * assertOk(
  *   await run(greet("Ada"), { greetingFormatter: casual }),
  *   "Hi, Ada",
  * );
@@ -368,7 +381,15 @@
  * `undefined` should represent valid absence, not failure.
  *
  * ```ts
- * import { createRun, ok, type Task, type Typed } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   assertTrue,
+ *   createRun,
+ *   ok,
+ *   type Task,
+ *   type Typed,
+ * } from "@evolu/common";
  *
  * interface Socket extends AsyncDisposable {
  *   readonly send: (message: string) => string;
@@ -382,8 +403,9 @@
  * const openSocket: Task<Socket, ConnectionFailedError> = () =>
  *   ok({
  *     send: (message) => message,
- *     [Symbol.asyncDispose]: async () => {
+ *     [Symbol.asyncDispose]: () => {
  *       socketDisposed = true;
+ *       return Promise.resolve();
  *     },
  *   });
  *
@@ -415,11 +437,11 @@
  *
  * await using run = createRun();
  * const result = await run(createConnection);
- * assert(result.ok);
- * expect(socketDisposed).toBe(false);
- * expect(result.value.send("hello")).toBe("hello");
+ * assertTrue(result.ok);
+ * assertFalse(socketDisposed);
+ * assertEqual(result.value.send("hello"), "hello");
  * await result.value[Symbol.asyncDispose]();
- * expect(socketDisposed).toBe(true);
+ * assertTrue(socketDisposed);
  * ```
  *
  * Use {@link Run.ok} with `await using` when a Task whose error type is `never`
@@ -576,7 +598,7 @@
  * each iteration reuses the same stack frame:
  *
  * ```ts
- * import { createRun, ok, type Task } from "@evolu/common";
+ * import { assertOk, createRun, ok, type Task } from "@evolu/common";
  *
  * interface TreeNode {
  *   readonly value: string;
@@ -600,7 +622,7 @@
  *   };
  *
  * await using run = createRun();
- * expectOk(
+ * assertOk(
  *   await run(
  *     visitTree({
  *       value: "root",
@@ -758,22 +780,34 @@ import type {
  * A Task that can't fail with a domain error:
  *
  * ```ts
- * import { createRun, ok, type Task } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   createRun,
+ *   ok,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * const greet: Task<string> = () => ok("Hello!");
- * const main: Task<string> = async (run) => await run(greet);
+ * const main: Task<string> = (run) => run(greet);
  *
  * await using run = createRun();
- * expectOk(await run(main), "Hello!");
+ * assertOk(await run(main), "Hello!");
  *
  * // Without domain errors, `run.ok` returns the Ok value.
- * expect(await run.ok(main)).toBe("Hello!");
+ * assertEqual(await run.ok(main), "Hello!");
  * ```
  *
  * A Task that can fail with a domain error:
  *
  * ```ts
- * import { createRun, err, type Task, type Typed } from "@evolu/common";
+ * import {
+ *   assertErr,
+ *   createRun,
+ *   err,
+ *   type Task,
+ *   type Typed,
+ * } from "@evolu/common";
  *
  * const findUser =
  *   (id: string): Task<string, UserNotFoundError> =>
@@ -785,7 +819,7 @@ import type {
  * }
  *
  * await using run = createRun();
- * expectErr(await run(findUser("user-1")), {
+ * assertErr(await run(findUser("user-1")), {
  *   type: "UserNotFound",
  *   id: "user-1",
  * });
@@ -794,7 +828,7 @@ import type {
  * A Task with dependencies:
  *
  * ```ts
- * import { createRun, ok, type Task } from "@evolu/common";
+ * import { assertOk, createRun, ok, type Task } from "@evolu/common";
  *
  * interface Config {
  *   readonly greeting: string;
@@ -809,7 +843,7 @@ import type {
  *
  * const config: Config = { greeting: "Hello" };
  * await using run = createRun({ config });
- * expectOk(await run(greet), "Hello!");
+ * assertOk(await run(greet), "Hello!");
  * ```
  *
  * Start Tasks with `run(task)`, as shown above.
@@ -967,7 +1001,13 @@ export interface Run<D = unknown> {
    * ### Example
    *
    * ```ts
-   * import { createRun, ok, type Task } from "@evolu/common";
+   * import {
+   *   assertSame,
+   *   assertOk,
+   *   createRun,
+   *   ok,
+   *   type Task,
+   * } from "@evolu/common";
    *
    * interface Db {
    *   readonly name: string;
@@ -980,15 +1020,15 @@ export interface Run<D = unknown> {
    * const db: Db = { name: "main" };
    * const loadUser: Task<string> = () => ok("Ada");
    * const saveUser: Task<void, never, DbDep> = (run) => {
-   *   expect(run.deps.db).toBe(db);
+   *   assertSame(run.deps.db, db);
    *   return ok();
    * };
    *
    * await using run = createRun({ db });
    * const userResult = await run(loadUser);
    * const savedResult = await run(saveUser);
-   * expectOk(userResult, "Ada");
-   * expectOk(savedResult, undefined);
+   * assertOk(userResult, "Ada");
+   * assertOk(savedResult, undefined);
    * ```
    *
    * Start Tasks with `run(task)`, as shown above.
@@ -1022,7 +1062,13 @@ export interface Run<D = unknown> {
    * ### Example
    *
    * ```ts
-   * import { createRun, ok, type Task, type Typed } from "@evolu/common";
+   * import {
+   *   assertEqual,
+   *   createRun,
+   *   ok,
+   *   type Task,
+   *   type Typed,
+   * } from "@evolu/common";
    *
    * const loadConfig: Task<string, ConfigInvalidError> = () =>
    *   ok("config");
@@ -1030,7 +1076,7 @@ export interface Run<D = unknown> {
    * interface ConfigInvalidError extends Typed<"ConfigInvalid"> {}
    *
    * await using run = createRun();
-   * expect(await run.orThrow(loadConfig)).toBe("config");
+   * assertEqual(await run.orThrow(loadConfig), "config");
    * ```
    */
   readonly orThrow: {
@@ -1052,7 +1098,13 @@ export interface Run<D = unknown> {
    * ### Example
    *
    * ```ts
-   * import { createRun, ok, type Task } from "@evolu/common";
+   * import {
+   *   assertEqual,
+   *   assertTrue,
+   *   createRun,
+   *   ok,
+   *   type Task,
+   * } from "@evolu/common";
    *
    * interface Resource extends AsyncDisposable {
    *   readonly value: string;
@@ -1062,17 +1114,18 @@ export interface Run<D = unknown> {
    * const openResource: Task<Resource> = () =>
    *   ok({
    *     value: "resource",
-   *     [Symbol.asyncDispose]: async () => {
+   *     [Symbol.asyncDispose]: () => {
    *       disposed = true;
+   *       return Promise.resolve();
    *     },
    *   });
    *
    * await using run = createRun();
    * {
    *   await using resource = await run.ok(openResource);
-   *   expect(resource.value).toBe("resource");
+   *   assertEqual(resource.value, "resource");
    * }
-   * expect(disposed).toBe(true);
+   * assertTrue(disposed);
    * ```
    */
   readonly ok: {
@@ -1101,6 +1154,9 @@ export interface Run<D = unknown> {
    *
    * ```ts
    * import {
+   *   assertFalse,
+   *   assertType,
+   *   assertTrue,
    *   AbortError,
    *   createRun,
    *   ok,
@@ -1121,13 +1177,11 @@ export interface Run<D = unknown> {
    *
    * await using run = createRun();
    * const fiber = run.abortable(loadUser, { db });
-   * expectTypeOf(fiber).toEqualTypeOf<
-   *   AbortableFiber<string, never, DbDep>
-   * >();
+   * assertType<AbortableFiber<string, never, DbDep>, typeof fiber>();
    * fiber.abort();
    * const userResult = await fiber;
-   * assert(!userResult.ok);
-   * expect(AbortError.is(userResult.error)).toBe(true);
+   * assertFalse(userResult.ok);
+   * assertTrue(AbortError.is(userResult.error));
    * ```
    */
   readonly abortable: {
@@ -1167,35 +1221,45 @@ export interface Run<D = unknown> {
    * ### Abort masks
    *
    * ```ts
-   * import { createRun, ok, unabortable, type Task } from "@evolu/common";
+   * import {
+   *   assertEqual,
+   *   assertOk,
+   *   assertTrue,
+   *   createRun,
+   *   ok,
+   *   unabortable,
+   *   type Task,
+   * } from "@evolu/common";
    *
    * const syncUsers: Task<string> = () => ok("synced");
    * const syncParent = unabortable(async (run) => {
-   *   expect(run.snapshot().abortMask).toBe(1);
+   *   assertEqual(run.snapshot().abortMask, 1);
    *
    *   // Plain daemon — the caller's mask does not follow it, so abort
    *   // requests are observed.
    *   const fiber = run.daemon(syncUsers);
-   *   expect(fiber.run.snapshot().abortMask).toBe(0);
+   *   assertEqual(fiber.run.snapshot().abortMask, 0);
    *
    *   // Explicitly masked daemon — finishes once started.
    *   const maskedFiber = run.daemon(unabortable(syncUsers));
-   *   expect(maskedFiber.run.snapshot().abortMask).toBe(1);
+   *   assertEqual(maskedFiber.run.snapshot().abortMask, 1);
    *   const firstResult = await fiber;
    *   const secondResult = await maskedFiber;
-   *   assert(firstResult.ok);
-   *   assert(secondResult.ok);
+   *   assertTrue(firstResult.ok);
+   *   assertTrue(secondResult.ok);
    *   return ok([firstResult.value, secondResult.value] as const);
    * });
    *
    * await using run = createRun();
-   * expectOk(await run(syncParent), ["synced", "synced"]);
+   * assertOk(await run(syncParent), ["synced", "synced"]);
    * ```
    *
    * ### Aborting a daemon
    *
    * ```ts
    * import {
+   *   assertFalse,
+   *   assertTrue,
    *   AbortError,
    *   createRun,
    *   ok,
@@ -1217,14 +1281,21 @@ export interface Run<D = unknown> {
    * const fiber = run.daemon(syncUsers, { db });
    * fiber.abort();
    * const syncResult = await fiber;
-   * assert(!syncResult.ok);
-   * expect(AbortError.is(syncResult.error)).toBe(true);
+   * assertFalse(syncResult.ok);
+   * assertTrue(AbortError.is(syncResult.error));
    * ```
    *
    * ### Disposing a daemon
    *
    * ```ts
-   * import { createRun, ok, waitForAbort, type Task } from "@evolu/common";
+   * import {
+   *   assertOk,
+   *   assertTrue,
+   *   createRun,
+   *   ok,
+   *   waitForAbort,
+   *   type Task,
+   * } from "@evolu/common";
    *
    * let syncStopped = false;
    * const syncUsers: Task<never> = async (run) => {
@@ -1239,9 +1310,9 @@ export interface Run<D = unknown> {
    * {
    *   // Async disposal requests abort and waits for the daemon to stop.
    *   await using _syncFiber = run.daemon(syncUsers);
-   *   expectOk(await run(loadUser), "Ada");
+   *   assertOk(await run(loadUser), "Ada");
    * }
-   * expect(syncStopped).toBe(true);
+   * assertTrue(syncStopped);
    * ```
    */
   readonly daemon: {
@@ -1271,7 +1342,13 @@ export interface Run<D = unknown> {
    * ### Example
    *
    * ```ts
-   * import { createRun, ok, type Task } from "@evolu/common";
+   * import {
+   *   assertEqual,
+   *   assertOk,
+   *   createRun,
+   *   ok,
+   *   type Task,
+   * } from "@evolu/common";
    *
    * interface DbDep {
    *   readonly db: { readonly users: Array<string> };
@@ -1289,9 +1366,9 @@ export interface Run<D = unknown> {
    * await using createdRun = run.create({ db });
    * const userResult = await createdRun(loadUser);
    * const savedResult = await createdRun(saveUser);
-   * expectOk(userResult, "Ada");
-   * expectOk(savedResult, undefined);
-   * expect(db.users).toEqual(["Ada", "Grace"]);
+   * assertOk(userResult, "Ada");
+   * assertOk(savedResult, undefined);
+   * assertEqual(db.users, ["Ada", "Grace"]);
    * ```
    */
   readonly create: {
@@ -1347,20 +1424,27 @@ export interface Run<D = unknown> {
    * ### Example
    *
    * ```ts
-   * import { AbortError, createRun, ok, sleep } from "@evolu/common";
+   * import {
+   *   assertFalse,
+   *   assertTrue,
+   *   AbortError,
+   *   createRun,
+   *   ok,
+   *   sleep,
+   * } from "@evolu/common";
    *
    * let socketClosed = false;
    * const openSocket = () => ({
    *   close: () => {
    *     socketClosed = true;
    *   },
-   *   read: async () => "message",
+   *   read: () => Promise.resolve("message"),
    * });
    *
    * await using run = createRun();
    * const fiber = run.abortable(async (run) => {
    *   const socket = openSocket();
-   *   using closeOnAbort = run.onAbort(() => {
+   *   using _closeOnAbort = run.onAbort(() => {
    *     socket.close();
    *   });
    *
@@ -1370,9 +1454,9 @@ export interface Run<D = unknown> {
    * });
    * fiber.abort();
    * const result = await fiber;
-   * assert(!result.ok);
-   * expect(AbortError.is(result.error)).toBe(true);
-   * expect(socketClosed).toBe(true);
+   * assertFalse(result.ok);
+   * assertTrue(AbortError.is(result.error));
+   * assertTrue(socketClosed);
    * ```
    */
   readonly onAbort: (
@@ -1449,7 +1533,7 @@ export interface DisposableRun<D = unknown>
    * ### Example
    *
    * ```ts
-   * import { createRun } from "@evolu/common";
+   * import { assertFalse, assertTrue, createRun } from "@evolu/common";
    *
    * let connectionClosed = false;
    * {
@@ -1458,9 +1542,9 @@ export interface DisposableRun<D = unknown>
    *     connectionClosed = true;
    *   });
    *
-   *   expect(connectionClosed).toBe(false);
+   *   assertFalse(connectionClosed);
    * }
-   * expect(connectionClosed).toBe(true);
+   * assertTrue(connectionClosed);
    * ```
    */
   readonly defer: (finalizer: () => Awaitable<void>) => void;
@@ -1527,7 +1611,15 @@ export interface DisposableRun<D = unknown>
  * ### Example
  *
  * ```ts
- * import { createRun, ok, type Fiber, type Task } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
+ *   createRun,
+ *   ok,
+ *   type Fiber,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * await using run = createRun();
  *
@@ -1537,9 +1629,9 @@ export interface DisposableRun<D = unknown>
  * const userResult = await fiber;
  * const snapshot = fiber.run.snapshot();
  *
- * expectTypeOf(fiber).toEqualTypeOf<Fiber<string, never>>();
- * expectOk(userResult, "Ada");
- * expect(snapshot.id).toBe(fiber.run.id);
+ * assertType<Fiber<string, never>, typeof fiber>();
+ * assertOk(userResult, "Ada");
+ * assertEqual(snapshot.id, fiber.run.id);
  * ```
  *
  * @group Core
@@ -1599,6 +1691,9 @@ export type InferFiberDeps<TFiber extends AnyFiber> =
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertType,
+ *   assertTrue,
  *   AbortError,
  *   createRun,
  *   ok,
@@ -1615,11 +1710,11 @@ export type InferFiberDeps<TFiber extends AnyFiber> =
  * };
  *
  * const fiber = run.abortable<string, never>(fetchData);
- * expectTypeOf(fiber).toEqualTypeOf<AbortableFiber<string, never>>();
+ * assertType<AbortableFiber<string, never>, typeof fiber>();
  * fiber.abort();
  * const result = await fiber;
- * assert(!result.ok);
- * expect(AbortError.is(result.error)).toBe(true);
+ * assertFalse(result.ok);
+ * assertTrue(AbortError.is(result.error));
  * ```
  *
  * @group Core
@@ -2067,7 +2162,7 @@ export interface CreateRun {
  * ### Example
  *
  * ```ts
- * import { createRun, ok, type Task } from "@evolu/common";
+ * import { assertOk, createRun, ok, type Task } from "@evolu/common";
  *
  * interface ConfigDep {
  *   readonly config: { readonly apiUrl: string };
@@ -2079,7 +2174,7 @@ export interface CreateRun {
  * await using run = createRun({
  *   config: { apiUrl: "https://api.example.com" },
  * });
- * expectOk(await run(loadApiUrl), "https://api.example.com");
+ * assertOk(await run(loadApiUrl), "https://api.example.com");
  * ```
  *
  * @group Run
@@ -2256,12 +2351,12 @@ export const testCreateDeps = (options?: {
  * ### Example
  *
  * ```ts
- * import { ok, testCreateRun, type Task } from "@evolu/common";
+ * import { assertOk, ok, testCreateRun, type Task } from "@evolu/common";
  *
  * const readTime: Task<number> = (run) => ok(run.deps.time.now());
  *
  * await using run = testCreateRun();
- * expectOk(await run(readTime), 0);
+ * assertOk(await run(readTime), 0);
  * ```
  *
  * @group Testing
@@ -2276,7 +2371,7 @@ export function testCreateRun(
  * ### Example
  *
  * ```ts
- * import { ok, testCreateRun, type Task } from "@evolu/common";
+ * import { assertOk, ok, testCreateRun, type Task } from "@evolu/common";
  *
  * interface FeatureDep {
  *   readonly feature: { readonly enabled: boolean };
@@ -2286,7 +2381,7 @@ export function testCreateRun(
  *   ok(run.deps.feature.enabled);
  *
  * await using run = testCreateRun({ feature: { enabled: true } });
- * expectOk(await run(isFeatureEnabled), true);
+ * assertOk(await run(isFeatureEnabled), true);
  * ```
  */
 export function testCreateRun<D extends object>(
@@ -2889,6 +2984,9 @@ export type InferTasksOk<TTasks> = {
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertEqual,
+ *   assertType,
  *   all,
  *   createRun,
  *   err,
@@ -2919,14 +3017,12 @@ export type InferTasksOk<TTasks> = {
  *     collect: false,
  *   }),
  * );
- * expectTypeOf(saveResult).toEqualTypeOf<
- *   Result<void, SaveUserFailedError>
- * >();
- * expectErr(saveResult, {
+ * assertType<Result<void, SaveUserFailedError>, typeof saveResult>();
+ * assertErr(saveResult, {
  *   type: "SaveUserFailed",
  *   userId: "missing",
  * });
- * expect(savedUserIds).toEqual(["user-1"]);
+ * assertEqual(savedUserIds, ["user-1"]);
  * ```
  *
  * @group Collection
@@ -2949,6 +3045,8 @@ export function all<const TTasks extends TaskRecord>(
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   all,
  *   createRun,
  *   ok,
@@ -2970,10 +3068,11 @@ export function all<const TTasks extends TaskRecord>(
  *
  * await using run = createRun();
  * const dashboard = await run(all([fetchUser, fetchPosts]));
- * expectTypeOf(dashboard).toEqualTypeOf<
- *   Result<readonly [User, ReadonlyArray<Post>]>
+ * assertType<
+ *   Result<readonly [User, ReadonlyArray<Post>]>,
+ *   typeof dashboard
  * >();
- * expectOk(dashboard, [{ id: "user-1" }, [{ id: "post-1" }]]);
+ * assertOk(dashboard, [{ id: "user-1" }, [{ id: "post-1" }]]);
  * ```
  */
 export function all<const TTasks extends ReadonlyArray<AnyTask>>(
@@ -2992,6 +3091,8 @@ export function all<const TTasks extends ReadonlyArray<AnyTask>>(
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   all,
  *   createRun,
  *   ok,
@@ -3014,10 +3115,11 @@ export function all<const TTasks extends ReadonlyArray<AnyTask>>(
  * await using run = createRun();
  * const result = await run(all({ user: fetchUser, posts: fetchPosts }));
  *
- * expectTypeOf(result).toEqualTypeOf<
- *   Result<{ readonly user: User; readonly posts: ReadonlyArray<Post> }>
+ * assertType<
+ *   Result<{ readonly user: User; readonly posts: ReadonlyArray<Post> }>,
+ *   typeof result
  * >();
- * expectOk(result, {
+ * assertOk(result, {
  *   user: { id: "user-1" },
  *   posts: [{ id: "post-1" }],
  * });
@@ -3061,6 +3163,9 @@ export function all<
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   all,
  *   createRun,
  *   ok,
@@ -3085,12 +3190,12 @@ export function all<
  * });
  *
  * // Mapping is eager: it happens before the returned Task starts.
- * expect(indexes).toEqual([0, 1]);
+ * assertEqual(indexes, [0, 1]);
  *
  * await using run = createRun();
  * const result = await run(loadUsers);
- * expectTypeOf(result).toEqualTypeOf<Result<readonly [User, User]>>();
- * expectOk(result, [{ id: "user-1" }, { id: "user-2" }]);
+ * assertType<Result<readonly [User, User]>, typeof result>();
+ * assertOk(result, [{ id: "user-1" }, { id: "user-2" }]);
  * ```
  */
 export function all<
@@ -3113,6 +3218,9 @@ export function all<
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   all,
  *   createRun,
  *   ok,
@@ -3140,14 +3248,15 @@ export function all<
  * });
  *
  * // Mapping is eager: it happens before the returned Task starts.
- * expect(roles).toEqual(["admin", "reviewer"]);
+ * assertEqual(roles, ["admin", "reviewer"]);
  *
  * await using run = createRun();
  * const result = await run(loadUsersByRole);
- * expectTypeOf(result).toEqualTypeOf<
- *   Result<{ readonly admin: User; readonly reviewer: User }>
+ * assertType<
+ *   Result<{ readonly admin: User; readonly reviewer: User }>,
+ *   typeof result
  * >();
- * expectOk(result, {
+ * assertOk(result, {
  *   admin: { id: "user-1" },
  *   reviewer: { id: "user-2" },
  * });
@@ -3227,6 +3336,9 @@ export type InferTasksSettled<TTasks> = {
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
+ *   assertTrue,
  *   allSettled,
  *   createRun,
  *   err,
@@ -3249,20 +3361,21 @@ export type InferTasksSettled<TTasks> = {
  *
  * await using run = createRun();
  * const results = await run(allSettled([loadProfile, loadActivity]));
- * expectTypeOf(results).toEqualTypeOf<
+ * assertType<
  *   Result<
  *     readonly [
  *       Result<string, ProfileNotFoundError>,
  *       Result<ReadonlyArray<string>>,
  *     ]
- *   >
+ *   >,
+ *   typeof results
  * >();
- * expectOk(results, [
+ * assertOk(results, [
  *   { ok: false, error: { type: "ProfileNotFound" } },
  *   { ok: true, value: ["signed-in"] },
  * ]);
  * // Unlike all, a later Task still runs after an Err.
- * expect(activityLoaded).toBe(true);
+ * assertTrue(activityLoaded);
  * ```
  *
  * @group Collection
@@ -3279,6 +3392,8 @@ export function allSettled<const TTasks extends ReadonlyArray<AnyTask>>(
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   allSettled,
  *   createRun,
  *   err,
@@ -3303,13 +3418,14 @@ export function allSettled<const TTasks extends ReadonlyArray<AnyTask>>(
  *   allSettled({ user: fetchUser, profile: fetchProfile }),
  * );
  *
- * expectTypeOf(results).toEqualTypeOf<
+ * assertType<
  *   Result<{
  *     readonly user: Result<User>;
  *     readonly profile: Result<string, ProfileNotFoundError>;
- *   }>
+ *   }>,
+ *   typeof results
  * >();
- * expectOk(results, {
+ * assertOk(results, {
  *   user: { ok: true, value: { id: "user-1" } },
  *   profile: { ok: false, error: { type: "ProfileNotFound" } },
  * });
@@ -3327,6 +3443,9 @@ export function allSettled<const TTasks extends TaskRecord>(
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   allSettled,
  *   createRun,
  *   err,
@@ -3355,19 +3474,20 @@ export function allSettled<const TTasks extends TaskRecord>(
  * });
  *
  * // Mapping is eager: it happens before the returned Task starts.
- * expect(indexes).toEqual([0, 1]);
+ * assertEqual(indexes, [0, 1]);
  *
  * await using run = createRun();
  * const results = await run(loadUsers);
- * expectTypeOf(results).toEqualTypeOf<
+ * assertType<
  *   Result<
  *     readonly [
  *       Result<User, UserNotFoundError>,
  *       Result<User, UserNotFoundError>,
  *     ]
- *   >
+ *   >,
+ *   typeof results
  * >();
- * expectOk(results, [
+ * assertOk(results, [
  *   { ok: true, value: { id: "user-1" } },
  *   { ok: false, error: { type: "UserNotFound" } },
  * ]);
@@ -3398,6 +3518,9 @@ export function allSettled<
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   allSettled,
  *   createRun,
  *   err,
@@ -3426,17 +3549,18 @@ export function allSettled<
  * });
  *
  * // Mapping is eager: it happens before the returned Task starts.
- * expect(roles).toEqual(["admin", "reviewer"]);
+ * assertEqual(roles, ["admin", "reviewer"]);
  *
  * await using run = createRun();
  * const results = await run(loadUsersByRole);
- * expectTypeOf(results).toEqualTypeOf<
+ * assertType<
  *   Result<{
  *     readonly admin: Result<User, UserNotFoundError>;
  *     readonly reviewer: Result<User, UserNotFoundError>;
- *   }>
+ *   }>,
+ *   typeof results
  * >();
- * expectOk(results, {
+ * assertOk(results, {
  *   admin: { ok: true, value: { id: "user-1" } },
  *   reviewer: { ok: false, error: { type: "UserNotFound" } },
  * });
@@ -3579,14 +3703,23 @@ const mapInput = (
  * ### Example
  *
  * ```ts
- * import { callback, createRun, ok, type Task } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   callback,
+ *   createRun,
+ *   ok,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * const listeners = new Set<(message: string) => void>();
  * const subscribe = (
  *   listener: (message: string) => void,
  * ): (() => void) => {
  *   listeners.add(listener);
- *   return () => listeners.delete(listener);
+ *   return () => {
+ *     listeners.delete(listener);
+ *   };
  * };
  * const nextMessage: Task<string> = callback(({ resolve }) =>
  *   subscribe((message) => resolve(ok(message))),
@@ -3594,11 +3727,11 @@ const mapInput = (
  *
  * await using run = createRun();
  * const fiber = run(nextMessage);
- * expect(listeners.size).toBe(1);
+ * assertEqual(listeners.size, 1);
  * for (const listener of listeners) listener("ready");
- * expectOk(await fiber, "ready");
+ * assertOk(await fiber, "ready");
  * // The callback cleanup unsubscribes after settlement.
- * expect(listeners.size).toBe(0);
+ * assertEqual(listeners.size, 0);
  * ```
  *
  * @group Interop
@@ -3633,10 +3766,10 @@ export const callback =
  * ### Example
  *
  * ```ts
- * import { createRun, sleep } from "@evolu/common";
+ * import { assertOk, createRun, sleep } from "@evolu/common";
  *
  * await using run = createRun();
- * expectOk(await run(sleep("1ms")), undefined);
+ * assertOk(await run(sleep("1ms")), undefined);
  * ```
  *
  * @group Timing
@@ -3660,6 +3793,8 @@ export const sleep = (duration: PositiveDuration): Task<void> =>
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertType,
  *   createRun,
  *   timeout,
  *   timeoutError,
@@ -3671,8 +3806,8 @@ export const sleep = (duration: PositiveDuration): Task<void> =>
  * await using run = createRun();
  *
  * const result = await run(timeout(waitForAbort, "1ms"));
- * expectTypeOf(result).toEqualTypeOf<Result<never, TimeoutError>>();
- * expectErr(result, timeoutError);
+ * assertType<Result<never, TimeoutError>, typeof result>();
+ * assertErr(result, timeoutError);
  * ```
  *
  * @group Timing
@@ -3771,6 +3906,8 @@ export interface RetryAttempt<E, Output> extends ScheduleStep<Output> {
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertType,
  *   createRun,
  *   err,
  *   recurs,
@@ -3790,10 +3927,11 @@ export interface RetryAttempt<E, Output> extends ScheduleStep<Output> {
  *
  * await using run = createRun();
  * const result = await run(fetchWithRetry);
- * expectTypeOf(result).toEqualTypeOf<
- *   Result<string, RetryTaskError<ServiceUnavailableError>>
+ * assertType<
+ *   Result<string, RetryTaskError<ServiceUnavailableError>>,
+ *   typeof result
  * >();
- * expectErr(result, {
+ * assertErr(result, {
  *   type: "RetryError",
  *   attempts: 3,
  *   lastError: { type: "ServiceUnavailable" },
@@ -3804,6 +3942,7 @@ export interface RetryAttempt<E, Output> extends ScheduleStep<Output> {
  *
  * ```ts
  * import {
+ *   assertErr,
  *   createRun,
  *   err,
  *   recurs,
@@ -3826,7 +3965,8 @@ export interface RetryAttempt<E, Output> extends ScheduleStep<Output> {
  * });
  *
  * await using run = createRun();
- * expectErr(await run(fetchWithRetry), {
+ * const result = await run(fetchWithRetry);
+ * assertErr(result, {
  *   type: "RetryError",
  *   attempts: 1,
  *   lastError: { type: "PermanentFailure" },
@@ -3958,7 +4098,15 @@ export interface RepeatAttempt<T, Output> extends ScheduleStep<Output> {
  * ### Repeating successes
  *
  * ```ts
- * import { createRun, ok, recurs, repeat, type Task } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   createRun,
+ *   ok,
+ *   recurs,
+ *   repeat,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * let attempts = 0;
  * const checkStatus: Task<string> = () => {
@@ -3969,14 +4117,16 @@ export interface RepeatAttempt<T, Output> extends ScheduleStep<Output> {
  * const poll = repeat(checkStatus, recurs(3));
  *
  * await using run = createRun();
- * expectOk(await run(poll), "pending");
- * expect(attempts).toBe(4);
+ * assertOk(await run(poll), "pending");
+ * assertEqual(attempts, 4);
  * ```
  *
  * ### Stopping with Done
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertEqual,
  *   createRun,
  *   done,
  *   err,
@@ -3999,8 +4149,8 @@ export interface RepeatAttempt<T, Output> extends ScheduleStep<Output> {
  *
  * await using run = createRun();
  * const result = await run(repeat(processQueue, spaced("1ms")));
- * expectErr(result, done());
- * expect(queue).toEqual([]);
+ * assertErr(result, done());
+ * assertEqual(queue, []);
  * ```
  *
  * @group Repetition
@@ -4062,6 +4212,9 @@ export type InferTasksResult<TTasks extends NonEmptyReadonlyArray<AnyTask>> =
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
+ *   assertTrue,
  *   any,
  *   createRun,
  *   err,
@@ -4085,11 +4238,9 @@ export type InferTasksResult<TTasks extends NonEmptyReadonlyArray<AnyTask>> =
  * await using run = createRun();
  * const result = await run(any([unavailable, fallback]));
  *
- * expectTypeOf(result).toEqualTypeOf<
- *   Result<string, ServiceUnavailableError>
- * >();
- * expectOk(result, "fallback");
- * expect(fallbackStarted).toBe(true);
+ * assertType<Result<string, ServiceUnavailableError>, typeof result>();
+ * assertOk(result, "fallback");
+ * assertTrue(fallbackStarted);
  * ```
  *
  * @group Racing
@@ -4160,6 +4311,7 @@ export const any =
  *
  * ```ts
  * import {
+ *   assertOk,
  *   createRun,
  *   isNonEmptyArray,
  *   ok,
@@ -4171,7 +4323,7 @@ export const any =
  * await using run = createRun();
  * if (isNonEmptyArray(tasks)) {
  *   const result = await run(race(tasks));
- *   expectOk(result, "first");
+ *   assertOk(result, "first");
  * }
  * ```
  *
@@ -4179,6 +4331,9 @@ export const any =
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertOk,
+ *   assertType,
  *   createRun,
  *   ok,
  *   race,
@@ -4200,9 +4355,9 @@ export const any =
  * // Input order does not matter: the first settled Result wins, and the
  * // still-running loser is aborted.
  * const result = await run(race([slow, fast]));
- * expectTypeOf(result).toEqualTypeOf<Result<string>>();
- * expectOk(result, "fast");
- * expect(slowCompleted).toBe(false);
+ * assertType<Result<string>, typeof result>();
+ * assertOk(result, "fast");
+ * assertFalse(slowCompleted);
  * ```
  *
  * @group Racing
@@ -4251,6 +4406,8 @@ export const race =
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertOk,
  *   createRun,
  *   err,
  *   firstN,
@@ -4281,8 +4438,8 @@ export const race =
  *
  * // Errs do not count. After two Ok values settle, the slow Task is aborted.
  * const result = await run(firstN(tasks, 2, { concurrency: 4 }));
- * expectOk(result, ["fast-1", "fast-2"]);
- * expect(slowCompleted).toBe(false);
+ * assertOk(result, ["fast-1", "fast-2"]);
+ * assertFalse(slowCompleted);
  * ```
  *
  * @group Racing
@@ -4330,6 +4487,8 @@ export const firstN =
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertOk,
  *   createRun,
  *   err,
  *   firstNSettled,
@@ -4355,11 +4514,11 @@ export const firstN =
  *
  * // Err and Ok both count, and Results use settlement order.
  * const result = await run(firstNSettled(tasks, 2, { concurrency: 3 }));
- * expectOk(result, [
+ * assertOk(result, [
  *   { ok: false, error: { type: "ServiceUnavailable" } },
  *   { ok: true, value: "fast" },
  * ]);
- * expect(slowCompleted).toBe(false);
+ * assertFalse(slowCompleted);
  * ```
  *
  * @group Racing
@@ -4446,6 +4605,9 @@ export type EachCallback<TTasks extends NonEmptyReadonlyArray<AnyTask>> = (
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   assertOk,
  *   createRun,
  *   each,
  *   err,
@@ -4481,9 +4643,9 @@ export type EachCallback<TTasks extends NonEmptyReadonlyArray<AnyTask>> = (
  *   ),
  * );
  *
- * expectOk(result, undefined);
- * expect(first).toEqual(["fast", 2]);
- * expect(slowCompleted).toBe(false);
+ * assertOk(result, undefined);
+ * assertEqual(first, ["fast", 2]);
+ * assertFalse(slowCompleted);
  * ```
  *
  * `onResult` is a synchronous scheduling decision, not a place to do work. It
@@ -4593,13 +4755,19 @@ export type TaskPriority = "user-blocking" | "user-visible" | "background";
  * ### Example
  *
  * ```ts
- * import { createRun, ok, prioritized, type Task } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   createRun,
+ *   ok,
+ *   prioritized,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * const rebuildSearchIndex: Task<string> = () => ok("indexed");
  * const backgroundIndexing = prioritized("background", rebuildSearchIndex);
  *
  * await using run = createRun();
- * expectOk(await run(backgroundIndexing), "indexed");
+ * assertOk(await run(backgroundIndexing), "indexed");
  * ```
  *
  * @group Scheduling
@@ -4623,7 +4791,13 @@ export const prioritized = <T, E, D = unknown>(
  * ### Example
  *
  * ```ts
- * import { createRun, ok, yieldNow, type Task } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   createRun,
+ *   ok,
+ *   yieldNow,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * const sumTo =
  *   (count: number): Task<number> =>
@@ -4639,7 +4813,7 @@ export const prioritized = <T, E, D = unknown>(
  *   };
  *
  * await using run = createRun();
- * expectOk(await run(sumTo(1001)), 500500);
+ * assertOk(await run(sumTo(1001)), 500500);
  * ```
  *
  * @group Scheduling
@@ -4676,6 +4850,10 @@ export const yieldNow: Task<void> = async (run) => {
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   assertType,
+ *   assertTrue,
  *   AbortError,
  *   createRun,
  *   ok,
@@ -4692,23 +4870,22 @@ export const yieldNow: Task<void> = async (run) => {
  * const serverStarted = Promise.withResolvers<void>();
  * let serverStopped = false;
  * const startServer: Task<Server, never, ServerDep> = (run) => {
- *   expect(run.deps.port).toBe(3000);
+ *   assertEqual(run.deps.port, 3000);
  *   serverStarted.resolve();
  *   return ok({
- *     [Symbol.asyncDispose]: async () => {
+ *     [Symbol.asyncDispose]: () => {
  *       serverStopped = true;
+ *       return Promise.resolve();
  *     },
  *   });
  * };
  *
  * const serve = (): Task<never, never, ServerDep> => async (run) => {
- *   await using server = await run.ok(startServer);
+ *   await using _ = await run.ok(startServer);
  *   return await run(waitForAbort);
  * };
  *
- * expectTypeOf(serve).returns.toEqualTypeOf<
- *   Task<never, never, ServerDep>
- * >();
+ * assertType<Task<never, never, ServerDep>, ReturnType<typeof serve>>();
  *
  * await using run = createRun();
  * const fiber = run.abortable(serve(), { port: 3000 });
@@ -4716,9 +4893,9 @@ export const yieldNow: Task<void> = async (run) => {
  * fiber.abort();
  *
  * const result = await fiber;
- * assert(!result.ok);
- * expect(AbortError.is(result.error)).toBe(true);
- * expect(serverStopped).toBe(true);
+ * assertFalse(result.ok);
+ * assertTrue(AbortError.is(result.error));
+ * assertTrue(serverStopped);
  * ```
  *
  * @group Abortability
@@ -4773,6 +4950,9 @@ export const waitForAbort: Task<never> = async (run) => {
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   assertTrue,
  *   createRun,
  *   daemon,
  *   ok,
@@ -4793,18 +4973,24 @@ export const waitForAbort: Task<never> = async (run) => {
  * {
  *   await using run = createRun();
  *   const result = await run(timeout(daemon(taskNotUsingAbort), "1ms"));
- *   assert(!result.ok);
- *   expect(result.error.type).toBe("TimeoutError");
- *   expect(finished).toBe(false);
+ *   assertFalse(result.ok);
+ *   assertEqual(result.error.type, "TimeoutError");
+ *   assertFalse(finished);
  *   finishTask();
  * }
- * expect(finished).toBe(true);
+ * assertTrue(finished);
  * ```
  *
  * Promise-returning functions should be called inside the Task, not before it.
  *
  * ```ts
- * import { createRun, ok, type Result, type Task } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   createRun,
+ *   ok,
+ *   type Result,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * type ResultValue = string;
  * const createPromiseReturningResult = (): Promise<Result<ResultValue>> =>
@@ -4813,14 +4999,20 @@ export const waitForAbort: Task<never> = async (run) => {
  * const task: Task<ResultValue> = () => createPromiseReturningResult();
  *
  * await using run = createRun();
- * expectOk(await run(task), "value");
+ * assertOk(await run(task), "value");
  * ```
  *
  * Do not reuse an already-running Promise. It started outside the Task, so the
  * Run cannot own its lifetime or request abort before it begins.
  *
  * ```ts
- * import { ok, type Result, type Task } from "@evolu/common";
+ * import {
+ *   assertType,
+ *   assertTrue,
+ *   ok,
+ *   type Result,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * type ResultValue = string;
  * let promiseStarted = false;
@@ -4835,8 +5027,8 @@ export const waitForAbort: Task<never> = async (run) => {
  * const promise = createPromiseReturningResult();
  * const task: Task<ResultValue> = () => promise;
  *
- * expect(promiseStarted).toBe(true);
- * expectTypeOf(task).toEqualTypeOf<Task<ResultValue>>();
+ * assertTrue(promiseStarted);
+ * assertType<Task<ResultValue>, typeof task>();
  * ```
  *
  * @group Lifetime
@@ -4874,14 +5066,21 @@ export const daemon =
  * ### Example
  *
  * ```ts
- * import { createRun, ok, unabortable, type Task } from "@evolu/common";
+ * import {
+ *   assertFalse,
+ *   assertOk,
+ *   createRun,
+ *   ok,
+ *   unabortable,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * const commitStarted = Promise.withResolvers<void>();
  * const finishCommit = Promise.withResolvers<void>();
  * const commit: Task<string> = unabortable(async (run) => {
  *   commitStarted.resolve();
  *   await finishCommit.promise;
- *   expect(run.signal.aborted).toBe(false);
+ *   assertFalse(run.signal.aborted);
  *   return ok("committed");
  * });
  *
@@ -4891,7 +5090,7 @@ export const daemon =
  * fiber.abort();
  * finishCommit.resolve();
  *
- * expectOk(await fiber, "committed");
+ * assertOk(await fiber, "committed");
  * ```
  *
  * @group Abortability
@@ -4922,6 +5121,9 @@ export const unabortable = /*#__PURE__*/ withTaskMeta({
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   assertTrue,
  *   AbortError,
  *   createRun,
  *   ok,
@@ -4938,17 +5140,17 @@ export const unabortable = /*#__PURE__*/ withTaskMeta({
  * const operationStarted = Promise.withResolvers<void>();
  * const operate =
  *   (resource: Resource): Task<never> =>
- *   async (run) => {
- *     expect(resource.id).toBe("resource-1");
+ *   (run) => {
+ *     assertEqual(resource.id, "resource-1");
  *     operationStarted.resolve();
- *     return await run(waitForAbort);
+ *     return run(waitForAbort);
  *   };
  * let released = false;
  * const release =
  *   (_resource: Resource): Task<void> =>
  *   (run) => {
  *     // Release inherits the mask even after abort was requested.
- *     expect(run.signal.aborted).toBe(false);
+ *     assertFalse(run.signal.aborted);
  *     released = true;
  *     return ok();
  *   };
@@ -4972,9 +5174,9 @@ export const unabortable = /*#__PURE__*/ withTaskMeta({
  * await operationStarted.promise;
  * fiber.abort();
  * const result = await fiber;
- * assert(!result.ok);
- * expect(AbortError.is(result.error)).toBe(true);
- * expect(released).toBe(true);
+ * assertFalse(result.ok);
+ * assertTrue(AbortError.is(result.error));
+ * assertTrue(released);
  * ```
  *
  * @group Abortability
@@ -5034,6 +5236,8 @@ export const unabortableMask = <T, E, D = unknown>(
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertTrue,
  *   acquireUseRelease,
  *   createRun,
  *   err,
@@ -5073,9 +5277,9 @@ export const unabortableMask = <T, E, D = unknown>(
  * );
  *
  * await using run = createRun();
- * expectErr(await run(queryUser), { type: "UserUnavailable" });
+ * assertErr(await run(queryUser), { type: "UserUnavailable" });
  * // Release still runs when use returns a domain error.
- * expect(connectionClosed).toBe(true);
+ * assertTrue(connectionClosed);
  * ```
  *
  * @group Lifetime
@@ -5137,6 +5341,10 @@ export interface Deferred<T, E = never> {
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertOk,
+ *   assertType,
+ *   assertTrue,
  *   createDeferred,
  *   createRun,
  *   ok,
@@ -5147,22 +5355,28 @@ export interface Deferred<T, E = never> {
  * const deferred = createDeferred<string>();
  *
  * const fiber = run(deferred.task);
- * expect(deferred.resolve(ok("ready"))).toBe(true);
+ * assertTrue(deferred.resolve(ok("ready")));
  *
  * const result = await fiber;
- * expectTypeOf(result).toEqualTypeOf<Result<string>>();
- * expectOk(result, "ready");
+ * assertType<Result<string>, typeof result>();
+ * assertOk(result, "ready");
  *
  * // A Deferred is one-shot: later resolutions are ignored, and future
  * // waiters receive the original Result.
- * expect(deferred.resolve(ok("late"))).toBe(false);
- * expectOk(await run(deferred.task), "ready");
+ * assertFalse(deferred.resolve(ok("late")));
+ * assertOk(await run(deferred.task), "ready");
  * ```
  *
  * ### Aborting a waiter
  *
  * ```ts
- * import { AbortError, createDeferred, createRun } from "@evolu/common";
+ * import {
+ *   assertFalse,
+ *   assertTrue,
+ *   AbortError,
+ *   createDeferred,
+ *   createRun,
+ * } from "@evolu/common";
  *
  * await using run = createRun();
  * const deferred = createDeferred<string>();
@@ -5171,8 +5385,8 @@ export interface Deferred<T, E = never> {
  * fiber.abort({ type: "NoLongerNeeded" });
  *
  * const result = await fiber;
- * assert(!result.ok);
- * expect(AbortError.is(result.error)).toBe(true);
+ * assertFalse(result.ok);
+ * assertTrue(AbortError.is(result.error));
  * ```
  *
  * @group Concurrency primitives
@@ -5245,7 +5459,15 @@ export interface Gate {
  * ### Example
  *
  * ```ts
- * import { createGate, createRun, ok, type Task } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertTrue,
+ *   createGate,
+ *   createRun,
+ *   ok,
+ *   type Task,
+ * } from "@evolu/common";
  *
  * await using run = createRun();
  * const networkGate = createGate();
@@ -5261,13 +5483,13 @@ export interface Gate {
  *
  * const first = run(syncOnce("first"));
  * const second = run(syncOnce("second"));
- * expect(uploadedItems).toEqual([]);
+ * assertEqual(uploadedItems, []);
  *
  * networkGate.open();
- * expectOk(await first, undefined);
- * expectOk(await second, undefined);
- * expect(uploadedItems).toEqual(["first", "second"]);
- * expect(networkGate.isOpen()).toBe(true);
+ * assertOk(await first, undefined);
+ * assertOk(await second, undefined);
+ * assertEqual(uploadedItems, ["first", "second"]);
+ * assertTrue(networkGate.isOpen());
  * ```
  *
  * @group Concurrency primitives
@@ -5469,6 +5691,7 @@ export interface SemaphoreSnapshot {
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createRun,
  *   createSemaphore,
  *   getOk,
@@ -5500,8 +5723,8 @@ export interface SemaphoreSnapshot {
  * ]);
  *
  * const savedUsers = results.map(getOk);
- * expect(savedUsers).toEqual(["saved:1", "saved:2", "saved:3"]);
- * expect(maxActiveSaves).toBe(2);
+ * assertEqual(savedUsers, ["saved:1", "saved:2", "saved:3"]);
+ * assertEqual(maxActiveSaves, 2);
  * ```
  *
  * @group Concurrency primitives
@@ -5670,6 +5893,8 @@ export interface Mutex {
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
  *   createMutex,
  *   createRun,
  *   ok,
@@ -5692,9 +5917,9 @@ export interface Mutex {
  *   run(deposit(2)),
  *   run(deposit(3)),
  * ]);
- * expectOk(first, undefined);
- * expectOk(second, undefined);
- * expect(balance).toBe(5);
+ * assertOk(first, undefined);
+ * assertOk(second, undefined);
+ * assertEqual(balance, 5);
  * ```
  *
  * @group Concurrency primitives
@@ -5758,6 +5983,8 @@ export interface CreateSemaphoreByKeyOptions<K, L = K> extends LookupOption<
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertTrue,
  *   createRun,
  *   createSemaphoreByKey,
  *   ok,
@@ -5770,11 +5997,11 @@ export interface CreateSemaphoreByKeyOptions<K, L = K> extends LookupOption<
  *   downloadsByHost.withPermit(host, () => ok(`${host}/${file}`));
  *
  * await using run = createRun();
- * expectOk(
+ * assertOk(
  *   await run(download("a.example", "index.json")),
  *   "a.example/index.json",
  * );
- * expect(downloadsByHost.isIdle("a.example")).toBe(true);
+ * assertTrue(downloadsByHost.isIdle("a.example"));
  * ```
  *
  * @group Concurrency primitives
@@ -5852,6 +6079,8 @@ export interface CreateMutexByKeyOptions<K, L = K> extends LookupOption<K, L> {}
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertTrue,
  *   createMutexByKey,
  *   createRun,
  *   ok,
@@ -5868,9 +6097,9 @@ export interface CreateMutexByKeyOptions<K, L = K> extends LookupOption<K, L> {}
  *   });
  *
  * await using run = createRun();
- * expectOk(await run(deposit("checking", 2)), 2);
- * expectOk(await run(deposit("checking", 3)), 5);
- * expect(accountLocks.isIdle("checking")).toBe(true);
+ * assertOk(await run(deposit("checking", 2)), 2);
+ * assertOk(await run(deposit("checking", 3)), 5);
+ * assertTrue(accountLocks.isIdle("checking"));
  * ```
  *
  * @group Concurrency primitives
@@ -5960,14 +6189,14 @@ export interface MutexRef<T> {
  * ### Example
  *
  * ```ts
- * import { createMutexRef, createRun, ok } from "@evolu/common";
+ * import { assertOk, createMutexRef, createRun, ok } from "@evolu/common";
  *
  * const counter = createMutexRef(0);
  * const increment = counter.updateAndGet((value) => () => ok(value + 1));
  *
  * await using run = createRun();
- * expectOk(await run(increment), 1);
- * expectOk(await run(counter.get), 1);
+ * assertOk(await run(increment), 1);
+ * assertOk(await run(counter.get), 1);
  * ```
  *
  * @group Concurrency primitives