@evolu/common 8.5.0 → 8.6.0

package/dist/src/Result.d.ts

@@ -1,6 +1,4 @@
 /**
- * ## Intro
- *
  * Type-safe error handling with {@link Result}.
  *
  * The problem with exceptions in JavaScript is that a caught value is always of
@@ -17,6 +15,9 @@
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertType,
  *   err,
  *   exhaustiveCheck,
  *   type Result,
@@ -27,7 +28,7 @@
  * try {
  *   throw new Error("Not found");
  * } catch (error) {
- *   expectTypeOf(error).toEqualTypeOf<unknown>();
+ *   assertType<unknown, typeof error>();
  * }
  *
  * // With Result, errors are part of the return type.
@@ -46,22 +47,24 @@
  * if (!result.ok) {
  *   switch (result.error.type) {
  *     case "NotFound":
- *       expect(result.error).toEqual({ type: "NotFound" });
+ *       assertEqual(result.error, { type: "NotFound" });
  *       break;
  *     case "InvalidInput":
- *       expect(result.error).toEqual({ type: "InvalidInput" });
+ *       assertEqual(result.error, { type: "InvalidInput" });
  *       break;
  *     default:
  *       exhaustiveCheck(result.error);
  *   }
  * }
- * expectErr(result, { type: "NotFound" });
+ * assertErr(result, { type: "NotFound" });
  * ```
  *
  * A `Result` is either {@link Ok} (success with a value) or {@link Err} (failure
  * with an error). Create them with {@link ok} and {@link err}.
  *
  * ```ts
+ * import { assertEqual } from "@evolu/common";
+ *
  * type Result<T, E = never> = Ok<T> | Err<E>;
  *
  * interface Ok<T> {
@@ -73,6 +76,9 @@
  *   readonly ok: false;
  *   readonly error: E;
  * }
+ *
+ * const result: Result<number> = { ok: true, value: 1 };
+ * assertEqual(result, { ok: true, value: 1 });
  * ```
  *
  * Use {@link trySync} and {@link tryAsync} to intentionally convert thrown values
@@ -85,7 +91,13 @@
  * Since `Result` is a plain object, imperative code works naturally.
  *
  * ```ts
- * import { ok, type Result, type Typed } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ *   type Typed,
+ * } from "@evolu/common";
  *
  * interface User {
  *   readonly id: string;
@@ -117,10 +129,11 @@
  * };
  *
  * const profile = getCurrentProfile();
- * expectTypeOf(profile).toEqualTypeOf<
- *   Result<Profile, UserNotFoundError | ProfileNotFoundError>
+ * assertType<
+ *   Result<Profile, UserNotFoundError | ProfileNotFoundError>,
+ *   typeof profile
  * >();
- * expectOk(profile, { userId: "user-1" });
+ * assertOk(profile, { userId: "user-1" });
  * ```
  *
  * Note `user` and `profile` are named after their success values, not after the
@@ -212,15 +225,15 @@ export type AnyResult = Result<any, any>;
  * ### Example
  *
  * ```ts
- * import { ok, type Result } from "@evolu/common";
+ * import { assertOk, assertType, ok, type Result } from "@evolu/common";
  *
  * const result = ok();
  * const count = ok(42);
  *
- * expectTypeOf(result).toEqualTypeOf<Result<void>>();
- * expectTypeOf(count).toEqualTypeOf<Result<number>>();
- * expectOk(result, undefined);
- * expectOk(count, 42);
+ * assertType<Result<void>, typeof result>();
+ * assertType<Result<number>, typeof count>();
+ * assertOk(result, undefined);
+ * assertOk(count, 42);
  * ```
  *
  * @group Core
@@ -238,7 +251,14 @@ export interface Ok<out T> {
  * ### Example
  *
  * ```ts
- * import { err, ok, type Result, type Typed } from "@evolu/common";
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   err,
+ *   ok,
+ *   type Result,
+ *   type Typed,
+ * } from "@evolu/common";
  *
  * interface User {
  *   readonly id: string;
@@ -255,8 +275,8 @@ export interface Ok<out T> {
  *   readonly id: string;
  * }
  *
- * expectOk(findUser("user-1"), { id: "user-1" });
- * expectErr(findUser("missing"), {
+ * assertOk(findUser("user-1"), { id: "user-1" });
+ * assertErr(findUser("missing"), {
  *   type: "NotFound",
  *   id: "missing",
  * });
@@ -305,6 +325,8 @@ export declare const err: <E>(error: E) => Result<never, E>;
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   isOk,
  *   ok,
  *   type Ok,
@@ -318,8 +340,8 @@ export declare const err: <E>(error: E) => Result<never, E>;
  *
  * const count = getCount();
  * if (isOk(count)) {
- *   expectTypeOf(count).toEqualTypeOf<Ok<number>>();
- *   expect(count.value).toBe(2);
+ *   assertType<Ok<number>, typeof count>();
+ *   assertEqual(count.value, 2);
  * }
  * ```
  *
@@ -333,6 +355,8 @@ export declare const isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertType,
  *   err,
  *   isErr,
  *   type Err,
@@ -347,8 +371,8 @@ export declare const isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
  *
  * const count = getCount();
  * if (isErr(count)) {
- *   expectTypeOf(count).toEqualTypeOf<Err<CountUnavailableError>>();
- *   expect(count.error).toEqual({ type: "CountUnavailable" });
+ *   assertType<Err<CountUnavailableError>, typeof count>();
+ *   assertErr(count, { type: "CountUnavailable" });
  * }
  * ```
  *
@@ -376,9 +400,14 @@ export declare const isErr: <T, E>(result: Result<T, E>) => result is Err<E>;
  *
  * ```ts
  * import {
+ *   assert,
+ *   assertErr,
+ *   assertEqual,
+ *   assertType,
  *   err,
  *   getOrThrow,
  *   ok,
+ *   trySync,
  *   type Result,
  *   type Typed,
  * } from "@evolu/common";
@@ -394,17 +423,21 @@ export declare const isErr: <T, E>(result: Result<T, E>) => result is Err<E>;
  *
  * // At app startup, crash if the config is invalid.
  * const config = getOrThrow(loadConfig());
- * expectTypeOf(config).toEqualTypeOf<Config>();
- * expect(config).toEqual({ port: 3000 });
- *
- * try {
- *   getOrThrow(err({ type: "InvalidConfig" }));
- *   assert.fail("Expected getOrThrow to throw");
- * } catch (error) {
- *   assert(error instanceof Error);
- *   expect(error.message).toBe("getOrThrow");
- *   expect(error.cause).toEqual({ type: "InvalidConfig" });
- * }
+ * assertType<Config, typeof config>();
+ * assertEqual(config.port, 3000);
+ *
+ * const thrown = trySync(() => getOrThrow(err({ type: "InvalidConfig" })));
+ * assertErr(thrown);
+ * assert(thrown.error instanceof Error, "Expected an Error.");
+ * assertEqual(thrown.error.message, "getOrThrow");
+ * const cause = thrown.error.cause;
+ * assert(
+ *   typeof cause === "object" &&
+ *     cause !== null &&
+ *     "type" in cause &&
+ *     cause.type === "InvalidConfig",
+ *   "Expected InvalidConfig cause.",
+ * );
  * ```
  *
  * Throws: `Error` with the original error attached as `cause`.
@@ -425,6 +458,8 @@ export declare const getOrThrow: <T, E>(result: Result<T, E>) => T;
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   err,
  *   getOrNull,
  *   ok,
@@ -445,9 +480,9 @@ export declare const getOrThrow: <T, E>(result: Result<T, E>) => T;
  * const user = getOrNull(findUser("user-1"));
  * const missingUser = getOrNull(findUser("missing"));
  *
- * expectTypeOf(user).toEqualTypeOf<User | null>();
- * expect(user).toEqual({ id: "user-1" });
- * expect(missingUser).toBeNull();
+ * assertType<User | null, typeof user>();
+ * assertEqual(user, { id: "user-1" });
+ * assertEqual(missingUser, null);
  * ```
  *
  * @group Unwrapping
@@ -463,12 +498,18 @@ export declare const getOrNull: <T, E>(result: Result<T, E>) => T | null;
  * ### Example
  *
  * ```ts
- * import { getOk, ok, type Result } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   getOk,
+ *   ok,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * const getCount = (): Result<number> => ok(2);
  * const count = getOk(getCount());
- * expectTypeOf(count).toEqualTypeOf<number>();
- * expect(count).toBe(2);
+ * assertType<number, typeof count>();
+ * assertEqual(count, 2);
  * ```
  *
  * @group Unwrapping
@@ -488,7 +529,16 @@ export declare const getOk: <T>(result: Result<T>) => T;
  * ### Example
  *
  * ```ts
- * import { trySync, type Result, type Typed } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertErr,
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
+ *   trySync,
+ *   type Result,
+ *   type Typed,
+ * } from "@evolu/common";
  *
  * class LegacySeatUnavailableError extends Error {}
  *
@@ -513,10 +563,13 @@ export declare const getOk: <T>(result: Result<T>) => T;
  * }
  *
  * const result = reserveSeat("B2");
- * expectTypeOf(result).toEqualTypeOf<Result<void, SeatUnavailableError>>();
- * expectOk(result, undefined);
- * expectErr(reserveSeat("A1"), { type: "SeatUnavailable", seat: "A1" });
- * expect(() => reserveSeat("B1")).toThrow("Database error");
+ * assertType<Result<void, SeatUnavailableError>, typeof result>();
+ * assertOk(result, undefined);
+ * assertErr(reserveSeat("A1"), { type: "SeatUnavailable", seat: "A1" });
+ * const databaseError = trySync(() => reserveSeat("B1"));
+ * assertErr(databaseError);
+ * assert(databaseError.error instanceof Error, "Expected an Error.");
+ * assertEqual(databaseError.error.message, "Database error");
  * ```
  *
  * @group Exception interop
@@ -538,13 +591,25 @@ export declare function trySync<T, E>(fn: () => T, mapError: (error: unknown) =>
  * ### Example
  *
  * ```ts
- * import { tryAsync, type Result, type Typed } from "@evolu/common";
+ * import {
+ *   assert,
+ *   assertErr,
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
+ *   tryAsync,
+ *   type Result,
+ *   type Typed,
+ * } from "@evolu/common";
  *
  * class LegacySeatUnavailableError extends Error {}
  *
- * const legacyReserveSeat = async (seat: string): Promise<void> => {
- *   if (seat === "A1") throw new LegacySeatUnavailableError();
- *   if (seat === "B1") throw new Error("Database error");
+ * const legacyReserveSeat = (seat: string): Promise<void> => {
+ *   if (seat === "A1") {
+ *     return Promise.reject(new LegacySeatUnavailableError());
+ *   }
+ *   if (seat === "B1") return Promise.reject(new Error("Database error"));
+ *   return Promise.resolve();
  * };
  *
  * const reserveSeat = (
@@ -565,13 +630,16 @@ export declare function trySync<T, E>(fn: () => T, mapError: (error: unknown) =>
  * }
  *
  * const result = await reserveSeat("B2");
- * expectTypeOf(result).toEqualTypeOf<Result<void, SeatUnavailableError>>();
- * expectOk(result, undefined);
- * expectErr(await reserveSeat("A1"), {
+ * assertType<Result<void, SeatUnavailableError>, typeof result>();
+ * assertOk(result, undefined);
+ * assertErr(await reserveSeat("A1"), {
  *   type: "SeatUnavailable",
  *   seat: "A1",
  * });
- * await expect(reserveSeat("B1")).rejects.toThrow("Database error");
+ * const databaseError = await tryAsync(() => reserveSeat("B1"));
+ * assertErr(databaseError);
+ * assert(databaseError.error instanceof Error, "Expected an Error.");
+ * assertEqual(databaseError.error.message, "Database error");
  * ```
  *
  * @group Exception interop
@@ -595,6 +663,9 @@ export declare function tryAsync<T, E>(promiseThunk: Thunk<Awaitable<T>>, mapErr
  *
  * ```ts
  * import {
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
  *   done,
  *   err,
  *   ok,
@@ -613,12 +684,10 @@ export declare function tryAsync<T, E>(promiseThunk: Thunk<Awaitable<T>>, mapErr
  * interface ReadFailedError extends Typed<"ReadFailed"> {}
  *
  * const value = next(0);
- * expectTypeOf(value).toEqualTypeOf<
- *   NextResult<string, ReadFailedError, number>
- * >();
- * expectOk(value, "first");
- * expectErr(next(1), { type: "ReadFailed" });
- * expectErr(next(2), { type: "Done", done: 2 });
+ * assertType<NextResult<string, ReadFailedError, number>, typeof value>();
+ * assertOk(value, "first");
+ * assertErr(next(1), { type: "ReadFailed" });
+ * assertErr(next(2), { type: "Done", done: 2 });
  * ```
  *
  * @group Pull
@@ -636,14 +705,14 @@ export type NextResult<A, E = never, D = void> = Result<A, E | Done<D>>;
  * ### Example
  *
  * ```ts
- * import { done, type Done } from "@evolu/common";
+ * import { assertEqual, assertType, done, type Done } from "@evolu/common";
  *
  * const withoutValue = done();
  * const withValue = done(42);
- * expectTypeOf(withoutValue).toEqualTypeOf<Done<void>>();
- * expectTypeOf(withValue).toEqualTypeOf<Done<number>>();
- * expect(withoutValue).toEqual({ type: "Done", done: undefined });
- * expect(withValue).toEqual({ type: "Done", done: 42 });
+ * assertType<Done<void>, typeof withoutValue>();
+ * assertType<Done<number>, typeof withValue>();
+ * assertEqual(withoutValue, { type: "Done", done: undefined });
+ * assertEqual(withValue, { type: "Done", done: 42 });
  * ```
  *
  * @group Pull
@@ -671,13 +740,18 @@ export declare function done<D>(value: D): Done<D>;
  * ### Example
  *
  * ```ts
- * import { type Done, type ExcludeDone, type Typed } from "@evolu/common";
+ * import {
+ *   assertType,
+ *   type Done,
+ *   type ExcludeDone,
+ *   type Typed,
+ * } from "@evolu/common";
  *
  * type Errors = ReadFailedError | Done<number>;
  *
  * interface ReadFailedError extends Typed<"ReadFailed"> {}
  *
- * expectTypeOf<ExcludeDone<Errors>>().toEqualTypeOf<ReadFailedError>();
+ * assertType<ReadFailedError, ExcludeDone<Errors>>();
  * ```
  *
  * @group Pull
@@ -692,13 +766,18 @@ export type ExcludeDone<E> = Exclude<E, Done<any>>;
  * ### Example
  *
  * ```ts
- * import { type Done, type OnlyDone, type Typed } from "@evolu/common";
+ * import {
+ *   assertType,
+ *   type Done,
+ *   type OnlyDone,
+ *   type Typed,
+ * } from "@evolu/common";
  *
  * type Errors = ReadFailedError | Done<number>;
  *
  * interface ReadFailedError extends Typed<"ReadFailed"> {}
  *
- * expectTypeOf<OnlyDone<Errors>>().toEqualTypeOf<Done<number>>();
+ * assertType<Done<number>, OnlyDone<Errors>>();
  * ```
  *
  * @group Pull
@@ -711,6 +790,7 @@ export type OnlyDone<E> = Extract<E, Done<any>>;
  *
  * ```ts
  * import {
+ *   assertType,
  *   type InferDone,
  *   type NextResult,
  *   type Typed,
@@ -720,7 +800,7 @@ export type OnlyDone<E> = Extract<E, Done<any>>;
  *
  * interface ReadFailedError extends Typed<"ReadFailed"> {}
  *
- * expectTypeOf<InferDone<ReadResult>>().toEqualTypeOf<number>();
+ * assertType<number, InferDone<ReadResult>>();
  * ```
  *
  * @group Pull
@@ -739,6 +819,8 @@ export type InferDone<R extends Result<any, any>> = InferErr<R> extends infer Er
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   flatMapResult,
  *   ok,
  *   type Result,
@@ -763,10 +845,11 @@ export type InferDone<R extends Result<any, any>> = InferErr<R> extends infer Er
  *
  * const user: Result<User, UserNotFoundError> = ok({ id: "user-1" });
  * const profile = flatMapResult(user, ({ id }) => getProfile(id));
- * expectTypeOf(profile).toEqualTypeOf<
- *   Result<Profile, UserNotFoundError | ProfileNotFoundError>
+ * assertType<
+ *   Result<Profile, UserNotFoundError | ProfileNotFoundError>,
+ *   typeof profile
  * >();
- * expectOk(profile, { userId: "user-1" });
+ * assertOk(profile, { userId: "user-1" });
  * ```
  *
  * @group Composition
@@ -784,7 +867,14 @@ export declare const flatMapResult: <T, E, U, F>(result: Result<T, E>, fn: (valu
  * ### Example
  *
  * ```ts
- * import { allResult, ok, type Result, type Typed } from "@evolu/common";
+ * import {
+ *   allResult,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ *   type Typed,
+ * } from "@evolu/common";
  *
  * const getCount = (): Result<number, CountUnavailableError> => ok(2);
  *
@@ -796,13 +886,14 @@ export declare const flatMapResult: <T, E, U, F>(result: Result<T, E>, fn: (valu
  * interface LabelUnavailableError extends Typed<"LabelUnavailable"> {}
  *
  * const values = allResult([getCount(), getLabel()]);
- * expectTypeOf(values).toEqualTypeOf<
+ * assertType<
  *   Result<
  *     readonly [number, string],
  *     CountUnavailableError | LabelUnavailableError
- *   >
+ *   >,
+ *   typeof values
  * >();
- * expectOk(values, [2, "books"]);
+ * assertOk(values, [2, "books"]);
  * ```
  *
  * @group Composition
@@ -816,14 +907,21 @@ export declare function allResult<const T extends readonly [AnyResult, ...Readon
  * ### Example
  *
  * ```ts
- * import { allResult, ok, type Result } from "@evolu/common";
+ * import {
+ *   allResult,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * const resultsByName = { a: ok(1), b: ok(2) } as const;
  * const valuesByName = allResult(resultsByName);
- * expectTypeOf(valuesByName).toEqualTypeOf<
- *   Result<{ readonly a: number; readonly b: number }>
+ * assertType<
+ *   Result<{ readonly a: number; readonly b: number }>,
+ *   typeof valuesByName
  * >();
- * expectOk(valuesByName, { a: 1, b: 2 });
+ * assertOk(valuesByName, { a: 1, b: 2 });
  * ```
  */
 export declare function allResult<T extends Readonly<Record<string, AnyResult>>>(results: T): Result<{
@@ -837,12 +935,18 @@ export declare function allResult<T extends Readonly<Record<string, AnyResult>>>
  * ### Example
  *
  * ```ts
- * import { allResult, ok, type Result } from "@evolu/common";
+ * import {
+ *   allResult,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * const results: ReadonlyArray<Result<number>> = [ok(1), ok(2)];
  * const numbers = allResult(results);
- * expectTypeOf(numbers).toEqualTypeOf<Result<ReadonlyArray<number>>>();
- * expectOk(numbers, [1, 2]);
+ * assertType<Result<ReadonlyArray<number>>, typeof numbers>();
+ * assertOk(numbers, [1, 2]);
  * ```
  */
 export declare function allResult<T, E>(results: Iterable<Result<T, E>>): Result<ReadonlyArray<T>, E>;
@@ -854,6 +958,8 @@ export declare function allResult<T, E>(results: Iterable<Result<T, E>>): Result
  * ```ts
  * import {
  *   allResult,
+ *   assertOk,
+ *   assertType,
  *   ok,
  *   type NonEmptyReadonlyArray,
  *   type Result,
@@ -861,10 +967,8 @@ export declare function allResult<T, E>(results: Iterable<Result<T, E>>): Result
  *
  * const results: NonEmptyReadonlyArray<Result<number>> = [ok(1), ok(2)];
  * const numbers = allResult(results);
- * expectTypeOf(numbers).toEqualTypeOf<
- *   Result<NonEmptyReadonlyArray<number>>
- * >();
- * expectOk(numbers, [1, 2]);
+ * assertType<Result<NonEmptyReadonlyArray<number>>, typeof numbers>();
+ * assertOk(numbers, [1, 2]);
  * ```
  */
 export declare function allResult<T, E>(results: NonEmptyReadonlyArray<Result<T, E>>): Result<NonEmptyReadonlyArray<T>, E>;
@@ -874,11 +978,17 @@ export declare function allResult<T, E>(results: NonEmptyReadonlyArray<Result<T,
  * ### Example
  *
  * ```ts
- * import { allResult, ok, type Result } from "@evolu/common";
+ * import {
+ *   allResult,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * const result = allResult({ a: ok(1), b: ok(2) }, { collect: false });
- * expectTypeOf(result).toEqualTypeOf<Result<void>>();
- * expectOk(result, undefined);
+ * assertType<Result<void>, typeof result>();
+ * assertOk(result, undefined);
  * ```
  */
 export declare function allResult<T extends Readonly<Record<string, AnyResult>>>(results: T, options: {
@@ -893,12 +1003,18 @@ export declare function allResult<T extends Readonly<Record<string, AnyResult>>>
  * ### Example
  *
  * ```ts
- * import { allResult, ok, type Result } from "@evolu/common";
+ * import {
+ *   allResult,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * const results: ReadonlyArray<Result<number>> = [ok(1), ok(2)];
  * const result = allResult(results, { collect: false });
- * expectTypeOf(result).toEqualTypeOf<Result<void>>();
- * expectOk(result, undefined);
+ * assertType<Result<void>, typeof result>();
+ * assertOk(result, undefined);
  * ```
  */
 export declare function allResult<R extends AnyResult>(results: Iterable<R>, options: {
@@ -912,6 +1028,8 @@ export declare function allResult<R extends AnyResult>(results: Iterable<R>, opt
  * ```ts
  * import {
  *   allResult,
+ *   assertOk,
+ *   assertType,
  *   ok,
  *   type NonEmptyReadonlyArray,
  *   type Result,
@@ -919,14 +1037,12 @@ export declare function allResult<R extends AnyResult>(results: Iterable<R>, opt
  *
  * const numbers: NonEmptyReadonlyArray<number> = [1, 2];
  * const doubled = allResult(numbers, (number) => ok(number * 2));
- * expectTypeOf(doubled).toEqualTypeOf<
- *   Result<NonEmptyReadonlyArray<number>>
- * >();
- * expectOk(doubled, [2, 4]);
+ * assertType<Result<NonEmptyReadonlyArray<number>>, typeof doubled>();
+ * assertOk(doubled, [2, 4]);
  *
  * const tuple = allResult([1, 2] as const, (number) => ok(number * 2));
- * expectTypeOf(tuple).toEqualTypeOf<Result<readonly [number, number]>>();
- * expectOk(tuple, [2, 4]);
+ * assertType<Result<readonly [number, number]>, typeof tuple>();
+ * assertOk(tuple, [2, 4]);
  * ```
  */
 export declare function allResult<const A extends readonly [unknown, ...Array<unknown>], R extends AnyResult>(values: A, fn: (value: A[number]) => R): Result<{
@@ -938,12 +1054,18 @@ export declare function allResult<const A extends readonly [unknown, ...Array<un
  * ### Example
  *
  * ```ts
- * import { allResult, ok, type Result } from "@evolu/common";
+ * import {
+ *   allResult,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * const numbers: Iterable<number> = new Set([1, 2]);
  * const doubled = allResult(numbers, (number) => ok(number * 2));
- * expectTypeOf(doubled).toEqualTypeOf<Result<ReadonlyArray<number>>>();
- * expectOk(doubled, [2, 4]);
+ * assertType<Result<ReadonlyArray<number>>, typeof doubled>();
+ * assertOk(doubled, [2, 4]);
  * ```
  */
 export declare function allResult<A, R extends AnyResult>(values: Iterable<A>, fn: (value: A) => R): Result<ReadonlyArray<InferOk<R>>, InferErr<R>>;
@@ -953,7 +1075,13 @@ export declare function allResult<A, R extends AnyResult>(values: Iterable<A>, f
  * ### Example
  *
  * ```ts
- * import { allResult, ok, type Result } from "@evolu/common";
+ * import {
+ *   allResult,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * interface User {
  *   readonly id: string;
@@ -963,10 +1091,11 @@ export declare function allResult<A, R extends AnyResult>(values: Iterable<A>, f
  *
  * const userIdsByRole = { owner: "user-1", reviewer: "user-2" } as const;
  * const usersByRole = allResult(userIdsByRole, toUser);
- * expectTypeOf(usersByRole).toEqualTypeOf<
- *   Result<Readonly<Record<"owner" | "reviewer", User>>>
+ * assertType<
+ *   Result<Readonly<Record<"owner" | "reviewer", User>>>,
+ *   typeof usersByRole
  * >();
- * expectOk(usersByRole, {
+ * assertOk(usersByRole, {
  *   owner: { id: "user-1" },
  *   reviewer: { id: "user-2" },
  * });
@@ -982,7 +1111,14 @@ export declare function allResult<A, R extends AnyResult, K extends string>(valu
  * ### Example
  *
  * ```ts
- * import { allResult, ok, type Result } from "@evolu/common";
+ * import {
+ *   allResult,
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * const visited: Array<number> = [];
  * const result = allResult(
@@ -995,9 +1131,9 @@ export declare function allResult<A, R extends AnyResult, K extends string>(valu
  *     collect: false,
  *   },
  * );
- * expectTypeOf(result).toEqualTypeOf<Result<void>>();
- * expectOk(result, undefined);
- * expect(visited).toEqual([1, 2]);
+ * assertType<Result<void>, typeof result>();
+ * assertOk(result, undefined);
+ * assertEqual(visited, [1, 2]);
  * ```
  */
 export declare function allResult<A, R extends AnyResult>(values: Iterable<A>, fn: (value: A) => R, options: {
@@ -1009,13 +1145,19 @@ export declare function allResult<A, R extends AnyResult>(values: Iterable<A>, f
  * ### Example
  *
  * ```ts
- * import { allResult, ok, type Result } from "@evolu/common";
+ * import {
+ *   allResult,
+ *   assertOk,
+ *   assertType,
+ *   ok,
+ *   type Result,
+ * } from "@evolu/common";
  *
  * const result = allResult({ a: 1, b: 2 }, (number) => ok(number * 2), {
  *   collect: false,
  * });
- * expectTypeOf(result).toEqualTypeOf<Result<void>>();
- * expectOk(result, undefined);
+ * assertType<Result<void>, typeof result>();
+ * assertOk(result, undefined);
  * ```
  */
 export declare function allResult<A, R extends AnyResult, K extends string>(values: Readonly<Record<K, A>>, fn: (value: A) => R, options: {
@@ -1034,6 +1176,8 @@ export declare function allResult<A, R extends AnyResult, K extends string>(valu
  * ```ts
  * import {
  *   anyResult,
+ *   assertOk,
+ *   assertType,
  *   err,
  *   ok,
  *   type Result,
@@ -1046,8 +1190,8 @@ export declare function allResult<A, R extends AnyResult, K extends string>(valu
  * interface CacheMissError extends Typed<"CacheMiss"> {}
  *
  * const number = anyResult([getCachedPrice(), ok(42)]);
- * expectTypeOf(number).toEqualTypeOf<Result<number, CacheMissError>>();
- * expectOk(number, 42);
+ * assertType<Result<number, CacheMissError>, typeof number>();
+ * assertOk(number, 42);
  * ```
  *
  * @group Composition