@evolu/common 8.5.0 → 8.6.1

package/dist/src/Task.d.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",
@@ -663,22 +685,34 @@ import type { Awaitable, ParameterIntersection, Predicate } from "./Types.ts";
  * 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> =>
@@ -690,7 +724,7 @@ import type { Awaitable, ParameterIntersection, Predicate } from "./Types.ts";
  * }
  *
  * await using run = createRun();
- * expectErr(await run(findUser("user-1")), {
+ * assertErr(await run(findUser("user-1")), {
  *   type: "UserNotFound",
  *   id: "user-1",
  * });
@@ -699,7 +733,7 @@ import type { Awaitable, ParameterIntersection, Predicate } from "./Types.ts";
  * 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;
@@ -714,7 +748,7 @@ import type { Awaitable, ParameterIntersection, Predicate } from "./Types.ts";
  *
  * 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.
@@ -849,7 +883,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;
@@ -862,15 +902,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.
@@ -899,7 +939,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");
@@ -907,7 +953,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: {
@@ -923,7 +969,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;
@@ -933,17 +985,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: {
@@ -968,6 +1021,9 @@ export interface Run<D = unknown> {
      *
      * ```ts
      * import {
+     *   assertFalse,
+     *   assertType,
+     *   assertTrue,
      *   AbortError,
      *   createRun,
      *   ok,
@@ -988,13 +1044,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: {
@@ -1030,35 +1084,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,
@@ -1080,14 +1144,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) => {
@@ -1102,9 +1173,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: {
@@ -1130,7 +1201,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> };
@@ -1148,9 +1225,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: {
@@ -1201,20 +1278,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();
      *   });
      *
@@ -1224,9 +1308,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: (callback: (abortError: AbortError) => void) => Disposable | null;
@@ -1291,7 +1375,7 @@ export interface DisposableRun<D = unknown> extends Run<D>, Disposable, AsyncDis
      * ### Example
      *
      * ```ts
-     * import { createRun } from "@evolu/common";
+     * import { assertFalse, assertTrue, createRun } from "@evolu/common";
      *
      * let connectionClosed = false;
      * {
@@ -1300,9 +1384,9 @@ export interface DisposableRun<D = unknown> extends Run<D>, Disposable, AsyncDis
      *     connectionClosed = true;
      *   });
      *
-     *   expect(connectionClosed).toBe(false);
+     *   assertFalse(connectionClosed);
      * }
-     * expect(connectionClosed).toBe(true);
+     * assertTrue(connectionClosed);
      * ```
      */
     readonly defer: (finalizer: () => Awaitable<void>) => void;
@@ -1366,7 +1450,15 @@ export interface DisposableRun<D = unknown> extends Run<D>, Disposable, AsyncDis
  * ### 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();
  *
@@ -1376,9 +1468,9 @@ export interface DisposableRun<D = unknown> extends Run<D>, Disposable, AsyncDis
  * 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
@@ -1428,6 +1520,9 @@ export type InferFiberDeps<TFiber extends AnyFiber> = TFiber extends Fiber<any,
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertType,
+ *   assertTrue,
  *   AbortError,
  *   createRun,
  *   ok,
@@ -1444,11 +1539,11 @@ export type InferFiberDeps<TFiber extends AnyFiber> = TFiber extends Fiber<any,
  * };
  *
  * 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
@@ -1821,7 +1916,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 };
@@ -1833,7 +1928,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
@@ -1914,12 +2009,12 @@ export declare 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
@@ -1931,7 +2026,7 @@ export declare function testCreateRun(deps?: TestRunDefaultDeps): DisposableRun<
  * ### 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 };
@@ -1941,7 +2036,7 @@ export declare function testCreateRun(deps?: TestRunDefaultDeps): DisposableRun<
  *   ok(run.deps.feature.enabled);
  *
  * await using run = testCreateRun({ feature: { enabled: true } });
- * expectOk(await run(isFeatureEnabled), true);
+ * assertOk(await run(isFeatureEnabled), true);
  * ```
  */
 export declare function testCreateRun<D extends object>(deps: RunCustomDeps<D>): DisposableRun<TestRunDefaultDeps & D>;
@@ -2029,6 +2124,9 @@ export type InferTasksOk<TTasks> = {
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertEqual,
+ *   assertType,
  *   all,
  *   createRun,
  *   err,
@@ -2059,14 +2157,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
@@ -2081,6 +2177,8 @@ export declare function all<const TTasks extends TaskRecord>(tasks: TTasks, opti
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   all,
  *   createRun,
  *   ok,
@@ -2102,10 +2200,11 @@ export declare function all<const TTasks extends TaskRecord>(tasks: TTasks, opti
  *
  * 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 declare function all<const TTasks extends ReadonlyArray<AnyTask>>(tasks: TTasks, options?: TaskCollectionOptions): Task<InferTasksOk<TTasks>, InferTaskErr<TTasks[number]>, InferTasksDeps<TTasks>>;
@@ -2116,6 +2215,8 @@ export declare function all<const TTasks extends ReadonlyArray<AnyTask>>(tasks:
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   all,
  *   createRun,
  *   ok,
@@ -2138,10 +2239,11 @@ export declare function all<const TTasks extends ReadonlyArray<AnyTask>>(tasks:
  * 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" }],
  * });
@@ -2160,6 +2262,9 @@ export declare function all<const TValues extends Readonly<Record<string, unknow
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   all,
  *   createRun,
  *   ok,
@@ -2184,12 +2289,12 @@ export declare function all<const TValues extends Readonly<Record<string, unknow
  * });
  *
  * // 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 declare function all<const TValues extends ReadonlyArray<unknown>, TTask extends AnyTask>(values: TValues, fn: (value: TValues[number], index: number) => TTask, options?: TaskCollectionOptions): Task<{
@@ -2202,6 +2307,9 @@ export declare function all<const TValues extends ReadonlyArray<unknown>, TTask
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   all,
  *   createRun,
  *   ok,
@@ -2229,14 +2337,15 @@ export declare function all<const TValues extends ReadonlyArray<unknown>, TTask
  * });
  *
  * // 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" },
  * });
@@ -2279,6 +2388,9 @@ export type InferTasksSettled<TTasks> = {
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
+ *   assertTrue,
  *   allSettled,
  *   createRun,
  *   err,
@@ -2301,20 +2413,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
@@ -2327,6 +2440,8 @@ export declare function allSettled<const TTasks extends ReadonlyArray<AnyTask>>(
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   allSettled,
  *   createRun,
  *   err,
@@ -2351,13 +2466,14 @@ export declare 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" } },
  * });
@@ -2371,6 +2487,9 @@ export declare function allSettled<const TTasks extends TaskRecord>(tasks: TTask
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   allSettled,
  *   createRun,
  *   err,
@@ -2399,19 +2518,20 @@ export declare function allSettled<const TTasks extends TaskRecord>(tasks: TTask
  * });
  *
  * // 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" } },
  * ]);
@@ -2427,6 +2547,9 @@ export declare function allSettled<const TValues extends ReadonlyArray<unknown>,
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   allSettled,
  *   createRun,
  *   err,
@@ -2455,17 +2578,18 @@ export declare function allSettled<const TValues extends ReadonlyArray<unknown>,
  * });
  *
  * // 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" } },
  * });
@@ -2515,14 +2639,23 @@ export declare function allSettled<const TValues extends Readonly<Record<string,
  * ### 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))),
@@ -2530,11 +2663,11 @@ export declare function allSettled<const TValues extends Readonly<Record<string,
  *
  * 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
@@ -2552,10 +2685,10 @@ export declare const callback: <T, E = never, D = unknown>(fn: (options: {
  * ### 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
@@ -2574,6 +2707,8 @@ export declare const sleep: (duration: PositiveDuration) => Task<void>;
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertType,
  *   createRun,
  *   timeout,
  *   timeoutError,
@@ -2585,8 +2720,8 @@ export declare 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
@@ -2668,6 +2803,8 @@ export interface RetryAttempt<E, Output> extends ScheduleStep<Output> {
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertType,
  *   createRun,
  *   err,
  *   recurs,
@@ -2687,10 +2824,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" },
@@ -2701,6 +2839,7 @@ export interface RetryAttempt<E, Output> extends ScheduleStep<Output> {
  *
  * ```ts
  * import {
+ *   assertErr,
  *   createRun,
  *   err,
  *   recurs,
@@ -2723,7 +2862,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" },
@@ -2803,7 +2943,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> = () => {
@@ -2814,14 +2962,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,
@@ -2844,8 +2994,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
@@ -2880,6 +3030,9 @@ export type InferTasksResult<TTasks extends NonEmptyReadonlyArray<AnyTask>> = Re
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
+ *   assertTrue,
  *   any,
  *   createRun,
  *   err,
@@ -2903,11 +3056,9 @@ export type InferTasksResult<TTasks extends NonEmptyReadonlyArray<AnyTask>> = Re
  * 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
@@ -2939,6 +3090,7 @@ export declare const any: <TTasks extends NonEmptyReadonlyArray<AnyTask>>(tasks:
  *
  * ```ts
  * import {
+ *   assertOk,
  *   createRun,
  *   isNonEmptyArray,
  *   ok,
@@ -2950,7 +3102,7 @@ export declare const any: <TTasks extends NonEmptyReadonlyArray<AnyTask>>(tasks:
  * await using run = createRun();
  * if (isNonEmptyArray(tasks)) {
  *   const result = await run(race(tasks));
- *   expectOk(result, "first");
+ *   assertOk(result, "first");
  * }
  * ```
  *
@@ -2958,6 +3110,9 @@ export declare const any: <TTasks extends NonEmptyReadonlyArray<AnyTask>>(tasks:
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertOk,
+ *   assertType,
  *   createRun,
  *   ok,
  *   race,
@@ -2979,9 +3134,9 @@ export declare const any: <TTasks extends NonEmptyReadonlyArray<AnyTask>>(tasks:
  * // 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
@@ -3003,6 +3158,8 @@ export declare const race: <TTasks extends NonEmptyReadonlyArray<AnyTask>>(tasks
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertOk,
  *   createRun,
  *   err,
  *   firstN,
@@ -3033,8 +3190,8 @@ export declare const race: <TTasks extends NonEmptyReadonlyArray<AnyTask>>(tasks
  *
  * // 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
@@ -3056,6 +3213,8 @@ export declare const firstN: <TTasks extends NonEmptyReadonlyArray<AnyTask>>(tas
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertOk,
  *   createRun,
  *   err,
  *   firstNSettled,
@@ -3081,11 +3240,11 @@ export declare const firstN: <TTasks extends NonEmptyReadonlyArray<AnyTask>>(tas
  *
  * // 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
@@ -3141,6 +3300,9 @@ export type EachCallback<TTasks extends NonEmptyReadonlyArray<AnyTask>> = (resul
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   assertOk,
  *   createRun,
  *   each,
  *   err,
@@ -3176,9 +3338,9 @@ export type EachCallback<TTasks extends NonEmptyReadonlyArray<AnyTask>> = (resul
  *   ),
  * );
  *
- * 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
@@ -3222,13 +3384,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
@@ -3248,7 +3416,13 @@ export declare const prioritized: <T, E, D = unknown>(priority: TaskPriority, ta
  * ### 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> =>
@@ -3264,7 +3438,7 @@ export declare const prioritized: <T, E, D = unknown>(priority: TaskPriority, ta
  *   };
  *
  * await using run = createRun();
- * expectOk(await run(sumTo(1001)), 500500);
+ * assertOk(await run(sumTo(1001)), 500500);
  * ```
  *
  * @group Scheduling
@@ -3281,6 +3455,10 @@ export declare const yieldNow: Task<void>;
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   assertType,
+ *   assertTrue,
  *   AbortError,
  *   createRun,
  *   ok,
@@ -3297,23 +3475,22 @@ export declare const yieldNow: Task<void>;
  * 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 });
@@ -3321,9 +3498,9 @@ export declare const yieldNow: Task<void>;
  * 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
@@ -3373,6 +3550,9 @@ export declare const waitForAbort: Task<never>;
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   assertTrue,
  *   createRun,
  *   daemon,
  *   ok,
@@ -3393,18 +3573,24 @@ export declare const waitForAbort: Task<never>;
  * {
  *   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>> =>
@@ -3413,14 +3599,20 @@ export declare const waitForAbort: Task<never>;
  * 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;
@@ -3435,8 +3627,8 @@ export declare const waitForAbort: Task<never>;
  * 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
@@ -3457,14 +3649,21 @@ export declare const daemon: <T, E, D = unknown>(task: Task<T, E, D>) => Task<T,
  * ### 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");
  * });
  *
@@ -3474,7 +3673,7 @@ export declare const daemon: <T, E, D = unknown>(task: Task<T, E, D>) => Task<T,
  * fiber.abort();
  * finishCommit.resolve();
  *
- * expectOk(await fiber, "committed");
+ * assertOk(await fiber, "committed");
  * ```
  *
  * @group Abortability
@@ -3502,6 +3701,9 @@ export declare const unabortable: <T, E, D>(task: Task<T, E, D>) => Task<T, E, D
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertFalse,
+ *   assertTrue,
  *   AbortError,
  *   createRun,
  *   ok,
@@ -3518,17 +3720,17 @@ export declare const unabortable: <T, E, D>(task: Task<T, E, D>) => Task<T, E, D
  * 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();
  *   };
@@ -3552,9 +3754,9 @@ export declare const unabortable: <T, E, D>(task: Task<T, E, D>) => Task<T, E, D
  * 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
@@ -3581,6 +3783,8 @@ export declare const unabortableMask: <T, E, D = unknown>(fn: (restore: <T2, E2,
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertTrue,
  *   acquireUseRelease,
  *   createRun,
  *   err,
@@ -3620,9 +3824,9 @@ export declare const unabortableMask: <T, E, D = unknown>(fn: (restore: <T2, E2,
  * );
  *
  * 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
@@ -3656,6 +3860,10 @@ export interface Deferred<T, E = never> {
  *
  * ```ts
  * import {
+ *   assertFalse,
+ *   assertOk,
+ *   assertType,
+ *   assertTrue,
  *   createDeferred,
  *   createRun,
  *   ok,
@@ -3666,22 +3874,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>();
@@ -3690,8 +3904,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
@@ -3733,7 +3947,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();
@@ -3749,13 +3971,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
@@ -3907,6 +4129,7 @@ export interface SemaphoreSnapshot {
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createRun,
  *   createSemaphore,
  *   getOk,
@@ -3938,8 +4161,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
@@ -3973,6 +4196,8 @@ export interface Mutex {
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
  *   createMutex,
  *   createRun,
  *   ok,
@@ -3995,9 +4220,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
@@ -4043,6 +4268,8 @@ export interface CreateSemaphoreByKeyOptions<K, L = K> extends LookupOption<K, L
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertTrue,
  *   createRun,
  *   createSemaphoreByKey,
  *   ok,
@@ -4055,11 +4282,11 @@ export interface CreateSemaphoreByKeyOptions<K, L = K> extends LookupOption<K, L
  *   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
@@ -4095,6 +4322,8 @@ export interface CreateMutexByKeyOptions<K, L = K> extends LookupOption<K, L> {
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertTrue,
  *   createMutexByKey,
  *   createRun,
  *   ok,
@@ -4111,9 +4340,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
@@ -4169,14 +4398,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