@evolu/common 8.4.0 → 8.6.0

package/dist/src/Type.d.ts

@@ -1,11 +1,11 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { AtLeastTwoReadonlyArray, NonEmptyReadonlyArray } from "./Array.ts";
+import { type AtLeastTwoReadonlyArray, type NonEmptyReadonlyArray } from "./Array.ts";
 import type { Brand } from "./Brand.ts";
 import type { RandomBytesDep } from "./Crypto.ts";
 import { type Thunk } from "./Function.ts";
 import { type Result } from "./Result.ts";
 import type { TimeDep } from "./Time.ts";
-import { type CompileTimeError, type IsUnion, type Literal, type Simplify, type ValueWithLength, type WidenLiteral } from "./Types.ts";
+import { type CompileTimeError, type IsSameType, type IsUnion, type Literal, type Simplify, type ValueWithLength, type WidenLiteral } from "./Types.ts";
 /**
  * A runtime representation of a TypeScript type, including its encoded input,
  * semantic output, structured errors, and canonical encoding.
@@ -77,12 +77,12 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * ### Example
      *
      * ```ts
-     * import { PositiveInt } from "@evolu/common";
+     * import { assertOk, PositiveInt } from "@evolu/common";
      *
      * const value: unknown = 42;
      * const result = PositiveInt.fromUnknown(value);
      *
-     * expectOk(result, 42);
+     * assertOk(result, 42);
      * ```
      */
     readonly fromUnknown: (value: unknown, options?: ValidationOptions) => Result<Output, Errors>;
@@ -98,12 +98,25 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * ### Example
      *
      * ```ts
-     * import { String } from "@evolu/common";
+     * import {
+     *   assertEqual,
+     *   assertType,
+     *   Data,
+     *   assertErr,
+     *   String,
+     * } from "@evolu/common";
      *
      * const result = String.fromUnknown(42);
      *
-     * expectErr(result, { type: "TypeOf", expected: "String", value: 42 });
-     * expect(String.formatError(result.error)).toBe(
+     * assertErr(result);
+     * assertType(Data, result.error);
+     * assertEqual(result.error, {
+     *   type: "TypeOf",
+     *   expected: "String",
+     *   value: 42,
+     * });
+     * assertEqual(
+     *   String.formatError(result.error),
      *   "A value 42 is not a string.",
      * );
      * ```
@@ -119,14 +132,20 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * ### Example
      *
      * ```ts
-     * import { Int64FromInt64String, type Int64 } from "@evolu/common";
+     * import {
+     *   assertFalse,
+     *   assertType,
+     *   assertTrue,
+     *   Int64FromInt64String,
+     *   type Int64,
+     * } from "@evolu/common";
      *
      * const values: ReadonlyArray<unknown> = [42n, "42", null];
      * const integers = values.filter(Int64FromInt64String.is);
      *
-     * expectTypeOf(integers).toEqualTypeOf<globalThis.Array<Int64>>();
-     * expect(Int64FromInt64String.is(42n)).toBe(true);
-     * expect(Int64FromInt64String.is("42")).toBe(false);
+     * assertType<Array<Int64>, typeof integers>();
+     * assertTrue(Int64FromInt64String.is(42n));
+     * assertFalse(Int64FromInt64String.is("42"));
      * ```
      */
     readonly is: (value: unknown) => value is Output;
@@ -151,6 +170,8 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      *
      * ```ts
      * import {
+     *   assertOk,
+     *   assertType,
      *   flatMapResult,
      *   NonEmptyTrimmedString100,
      *   object,
@@ -183,10 +204,11 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * const note = TrimmedString.orThrow("Remember oat milk");
      * const result = saveTodo(title, note);
      *
-     * expectTypeOf(result).toEqualTypeOf<
-     *   Result<typeof Todo.Output, MaxLengthError<100> | MinLengthError<1>>
+     * assertType<
+     *   Result<typeof Todo.Output, MaxLengthError<100> | MinLengthError<1>>,
+     *   typeof result
      * >();
-     * expectOk(result, { title, note });
+     * assertOk(result, { title, note });
      * ```
      */
     readonly from: [CustomFrom] extends [never] ? [Parent] extends [infer P extends TypeNode] ? FromOperation<Output, Error, P> : TypeOperationFn<"from", Output, Output, never> : CustomFrom;
@@ -201,11 +223,15 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * ### Example
      *
      * ```ts
-     * import { Int64, Int64FromInt64String } from "@evolu/common";
+     * import {
+     *   assertEqual,
+     *   Int64,
+     *   Int64FromInt64String,
+     * } from "@evolu/common";
      *
      * const value = Int64.orThrow(42n);
      *
-     * expect(Int64FromInt64String.to(value)).toBe("42");
+     * assertEqual(Int64FromInt64String.to(value), "42");
      * ```
      */
     readonly to: [Parent] extends [infer P extends TypeNode] ? ToOperation<Output, CanonicalInput, P> : (value: Output) => CanonicalInput;
@@ -228,7 +254,12 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * ### Example
      *
      * ```ts
-     * import { getOrThrow, minLength, String } from "@evolu/common";
+     * import {
+     *   assertEqual,
+     *   getOrThrow,
+     *   minLength,
+     *   String,
+     * } from "@evolu/common";
      *
      * const NonEmptyString = minLength(1)(String);
      *
@@ -237,8 +268,8 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * // Equivalent because `from.parent` is this Type's deepest `from` operation:
      * const sameValue = getOrThrow(NonEmptyString.from.parent("Evolu"));
      *
-     * expect(value).toBe("Evolu");
-     * expect(sameValue).toBe(value);
+     * assertEqual(value, "Evolu");
+     * assertEqual(sameValue, value);
      * ```
      */
     readonly orThrow: TypeOperationFn<"orThrow", Input, Output, never>;
@@ -261,7 +292,12 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * ### Example
      *
      * ```ts
-     * import { getOrNull, minLength, String } from "@evolu/common";
+     * import {
+     *   assertEqual,
+     *   getOrNull,
+     *   minLength,
+     *   String,
+     * } from "@evolu/common";
      *
      * const NonEmptyString = minLength(1)(String);
      *
@@ -270,9 +306,9 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * // Equivalent because `from.parent` is this Type's deepest `from` operation:
      * const sameValue = getOrNull(NonEmptyString.from.parent("Evolu"));
      *
-     * expect(value).toBe("Evolu");
-     * expect(sameValue).toBe(value);
-     * expect(NonEmptyString.orNull("")).toBeNull();
+     * assertEqual(value, "Evolu");
+     * assertEqual(sameValue, value);
+     * assertEqual(NonEmptyString.orNull(""), null);
      * ```
      */
     readonly orNull: TypeOperationFn<"orNull", Input, Output, never>;
@@ -344,12 +380,18 @@ export interface TypeNode {
     readonly is: (value: unknown) => boolean;
 }
 /**
- * Asserts that a value belongs to a {@link Type} Output domain.
+ * Asserts exact compile-time type equality or that a value belongs to a
+ * {@link Type} Output domain.
  *
- * Use this for internal invariants, not external input. Validate external input
- * with `Type.fromUnknown` so validation failures remain typed values. A failed
- * assertion uses the Type name for its message and preserves the exact Output
- * validation error as the thrown Error's cause.
+ * - `assertType<Expected, Actual>()` requires compiler-identical types without
+ *   evaluating a value.
+ * - `assertType(type, value)` validates and narrows a runtime value to the Type's
+ *   Output.
+ *
+ * Use the runtime form for internal invariants, not external input. Validate
+ * external input with `Type.fromUnknown` so validation failures remain typed
+ * values. A failed runtime assertion uses the Type name for its message and
+ * preserves the exact Output validation error as the thrown Error's cause.
  *
  * ### Example
  *
@@ -362,14 +404,21 @@ export interface TypeNode {
  *
  * const value: unknown = "Evolu";
  * assertType(NonEmptyTrimmedString100, value);
- * expectTypeOf(value).toEqualTypeOf<
- *   string & Brand<"Trimmed"> & Brand<"MinLength1"> & Brand<"MaxLength100">
+ * assertType<
+ *   string &
+ *     Brand<"Trimmed"> &
+ *     Brand<"MinLength1"> &
+ *     Brand<"MaxLength100">,
+ *   typeof value
  * >();
  * ```
  *
  * @group Core
  */
-export declare const assertType: <T extends TypeNode>(type: T, value: unknown) => asserts value is T["Output"];
+export declare function assertType<Expected, Actual>(...error: IsSameType<Expected, Actual> extends true ? [] : [
+    error: CompileTimeError<"assertType", "Expected and actual types must be identical">
+]): void;
+export declare function assertType<T extends TypeNode>(type: T, value: unknown): asserts value is T["Output"];
 /**
  * Creates localized copies of selected {@link Type} declarations.
  *
@@ -395,13 +444,22 @@ export declare const assertType: <T extends TypeNode>(type: T, value: unknown) =
  * every locale an app supports also allows language changes without a network
  * connection.
  *
- * The selected Type map, locale map, and formatter maps must be plain objects
- * with own enumerable string-keyed data properties.
+ * The selected Type map, locale map, and formatter maps must satisfy the
+ * realm-neutral structural heuristic described by {@link isPlainObject} and have
+ * own enumerable string-keyed data properties.
  *
  * ### Example
  *
  * ```ts
- * import { String, localizeTypes, minLength } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   Data,
+ *   assertErr,
+ *   assertType,
+ *   String,
+ *   localizeTypes,
+ *   minLength,
+ * } from "@evolu/common";
  * import { cs } from "@evolu/common/intl";
  *
  * const Label = minLength(1)(String);
@@ -416,13 +474,14 @@ export declare const assertType: <T extends TypeNode>(type: T, value: unknown) =
  *   },
  * );
  *
- * expectTypeOf<typeof typesByLocale.cs.Label>().toEqualTypeOf<
- *   typeof Label
- * >();
+ * assertType<typeof Label, typeof typesByLocale.cs.Label>();
  *
  * const result = typesByLocale.cs.Label.fromUnknown("");
- * expectErr(result, { type: "MinLength1", min: 1, value: "" });
- * expect(typesByLocale.cs.Label.formatError(result.error)).toBe(
+ * assertErr(result);
+ * assertType(Data, result.error);
+ * assertEqual(result.error, { type: "MinLength1", min: 1, value: "" });
+ * assertEqual(
+ *   typesByLocale.cs.Label.formatError(result.error),
  *   "Text nesmí být prázdný.",
  * );
  * ```
@@ -501,7 +560,7 @@ type LocalizedErrorEntry<Error extends TypeError, Seen extends TypeError = never
     readonly type: "DiscriminatedUnion";
     readonly reason: unknown;
 } ? LocalizedDiscriminatedUnionErrorEntry<Error, Seen | Error> : Error extends {
-    readonly type: infer Name extends "Array" | "Tuple" | "Record" | "Set";
+    readonly type: infer Name extends "Array" | "Map" | "Tuple" | "Record" | "Set";
     readonly reason: infer Reason;
 } ? LocalizedErrorEntryValue<Name, Error> | LocalizedIssuesErrorEntry<Reason, Seen | Error> : Error extends {
     readonly type: "Object";
@@ -549,6 +608,8 @@ declare const identityEncodingSymbol: unique symbol;
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   NonEmptyTrimmedString100,
  *   PositiveInt,
  *   object,
@@ -564,8 +625,8 @@ declare const identityEncodingSymbol: unique symbol;
  *
  * const user = User.orThrow({ name: "Ada", age: 37 });
  *
- * expectTypeOf(user).toExtend<User>();
- * expect(user.name).toBe("Ada");
+ * assertType<typeof User.Output, typeof user>();
+ * assertEqual(user.name, "Ada");
  * ```
  *
  * @group Core
@@ -696,7 +757,12 @@ type ConcreteChildTypeNameError = CompileTimeError<"Type", "Name must be one con
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
  *   createType,
+ *   Data,
  *   err,
  *   ok,
  *   type Result,
@@ -714,8 +780,11 @@ type ConcreteChildTypeNameError = CompileTimeError<"Type", "Name must be one con
  *   () => "Expected text.",
  * );
  *
- * expectOk(Text.fromUnknown("Evolu"), "Evolu");
- * expectErr(Text.fromUnknown(42), { type: "Text", value: 42 });
+ * assertOk(Text.fromUnknown("Evolu"), "Evolu");
+ * const invalid = Text.fromUnknown(42);
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, { type: "Text", value: 42 });
  * ```
  *
  * @group Construction
@@ -756,7 +825,15 @@ export declare function createType<Name extends TypeName, ParentType extends Con
  * ### Example
  *
  * ```ts
- * import { Boolean, literal, ok, transform, union } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   Boolean,
+ *   literal,
+ *   ok,
+ *   transform,
+ *   union,
+ * } from "@evolu/common";
  *
  * const BooleanString = union(literal("false"), literal("true"));
  * const BooleanFromString = transform(
@@ -769,8 +846,8 @@ export declare function createType<Name extends TypeName, ParentType extends Con
  *   },
  * );
  *
- * expectOk(BooleanFromString.from.parent("true"), true);
- * expect(BooleanFromString.to(false)).toBe("false");
+ * assertOk(BooleanFromString.from.parent("true"), true);
+ * assertEqual(BooleanFromString.to(false), "false");
  * ```
  *
  * @group Construction
@@ -779,7 +856,60 @@ export declare function transform<Name extends TypeName, ParentType extends Conc
     readonly from: (value: ParentType["Output"]) => Result<OutputType["Input"], never>;
     readonly to: (value: CanonicalInputOf<OutputType>) => ToOutput;
 }): TransformType<ParentType, OutputType, Name, never, ToOutput>;
-/** Creates a fallible transformed Type with its own error formatter. */
+/**
+ * Creates a fallible transformed Type with its own error formatter.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   Data,
+ *   assertErr,
+ *   assertOk,
+ *   Boolean,
+ *   String,
+ *   err,
+ *   ok,
+ *   transform,
+ *   type Result,
+ *   type TypeError,
+ * } from "@evolu/common";
+ *
+ * interface BooleanFromStringError extends TypeError<"BooleanFromString"> {
+ *   readonly value: string;
+ * }
+ *
+ * const BooleanFromString = transform(
+ *   "BooleanFromString",
+ *   String,
+ *   Boolean,
+ *   {
+ *     from: (value): Result<boolean, BooleanFromStringError> =>
+ *       value === "true"
+ *         ? ok(true)
+ *         : value === "false"
+ *           ? ok(false)
+ *           : err({ type: "BooleanFromString", value }),
+ *     to: (value) => (value ? "true" : "false"),
+ *   },
+ *   () => 'Expected "true" or "false".',
+ * );
+ *
+ * assertOk(BooleanFromString.fromUnknown("true"), true);
+ * assertEqual(BooleanFromString.to(false), "false");
+ *
+ * const invalid = BooleanFromString.fromUnknown("yes");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, { type: "BooleanFromString", value: "yes" });
+ * assertEqual(
+ *   BooleanFromString.formatError(invalid.error),
+ *   'Expected "true" or "false".',
+ * );
+ * ```
+ */
 export declare function transform<Name extends TypeName, ParentType extends ConcreteTypeNode, OutputType extends ConcreteTypeNode, ToOutput extends ParentType["Output"], FromError extends {
     readonly type: Name;
     readonly outputError?: never;
@@ -871,16 +1001,20 @@ export interface TypeOfError<Name extends keyof TypeOfOutputByName> extends Type
  * and significant whitespace:
  *
  * ```ts
- * import { String, maxLength, type Brand } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   assertType,
+ *   String,
+ *   maxLength,
+ *   type Brand,
+ * } from "@evolu/common";
  *
  * const WireValue100 = maxLength(100)(String);
  * type WireValue100 = typeof WireValue100.Output;
  *
- * expectTypeOf<WireValue100>().toEqualTypeOf<
- *   string & Brand<"MaxLength100">
- * >();
- * expectOk(WireValue100.fromUnknown(""), "");
- * expectOk(WireValue100.fromUnknown(" value "), " value ");
+ * assertType<string & Brand<"MaxLength100">, WireValue100>();
+ * assertOk(WireValue100.fromUnknown(""), "");
+ * assertOk(WireValue100.fromUnknown(" value "), " value ");
  * ```
  *
  * @group String
@@ -906,7 +1040,12 @@ export declare const String: Type<"String", string, string, TypeOfError<"String"
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
  *   Age,
+ *   Data,
  *   FiniteNumber,
  *   Int,
  *   NonNaNNumber,
@@ -916,36 +1055,41 @@ export declare const String: Type<"String", string, string, TypeOfError<"String"
  * } from "@evolu/common";
  *
  * // Note how every additional constraint accumulates its Brand.
- * expectTypeOf<typeof Number.Output>().toEqualTypeOf<number>();
- * expectTypeOf<typeof NonNaNNumber.Output>().toEqualTypeOf<
- *   number & Brand<"NonNaN">
- * >();
- * expectTypeOf<typeof FiniteNumber.Output>().toEqualTypeOf<
- *   number & Brand<"NonNaN"> & Brand<"Finite">
+ * assertType<number, typeof Number.Output>();
+ * assertType<number & Brand<"NonNaN">, typeof NonNaNNumber.Output>();
+ * assertType<
+ *   number & Brand<"NonNaN"> & Brand<"Finite">,
+ *   typeof FiniteNumber.Output
  * >();
- * expectTypeOf<typeof Int.Output>().toEqualTypeOf<
- *   number & Brand<"NonNaN"> & Brand<"Finite"> & Brand<"Int">
+ * assertType<
+ *   number & Brand<"NonNaN"> & Brand<"Finite"> & Brand<"Int">,
+ *   typeof Int.Output
  * >();
- * expectTypeOf<typeof NonNegativeInt.Output>().toEqualTypeOf<
+ * assertType<
  *   number &
  *     Brand<"NonNaN"> &
  *     Brand<"Finite"> &
  *     Brand<"Int"> &
- *     Brand<"NonNegative">
+ *     Brand<"NonNegative">,
+ *   typeof NonNegativeInt.Output
  * >();
  *
- * expectTypeOf<typeof Age.Output>().toEqualTypeOf<
+ * assertType<
  *   number &
  *     Brand<"NonNaN"> &
  *     Brand<"Finite"> &
  *     Brand<"Int"> &
  *     Brand<"NonNegative"> &
  *     Brand<"LessThan200"> &
- *     Brand<"Age">
+ *     Brand<"Age">,
+ *   typeof Age.Output
  * >();
  *
- * expectOk(Age.fromUnknown(122), 122);
- * expectErr(Age.fromUnknown(200), {
+ * assertOk(Age.fromUnknown(122), 122);
+ * const invalid = Age.fromUnknown(200);
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "LessThan200",
  *   value: 200,
  *   max: 200,
@@ -1062,18 +1206,52 @@ interface ObjectTagOutputByName {
  * ### Example
  *
  * ```ts
- * import { objectTag } from "@evolu/common";
+ * import { assertOk, objectTag } from "@evolu/common";
  *
  * const DateType = objectTag("Date");
- * const date = new globalThis.Date("2025-01-01T00:00:00.000Z");
+ * const date = new Date("2025-01-01T00:00:00.000Z");
  *
- * expectOk(DateType.fromUnknown(date), date);
+ * assertOk(DateType.fromUnknown(date), date);
  * ```
  *
  * @group Base
  */
 export declare function objectTag<Name extends keyof ObjectTagOutputByName>(name: ValidateConcreteTypeName<Name>): Type<Name, ObjectTagOutputByName[Name], ObjectTagOutputByName[Name], ObjectTagError<Name>, null, ObjectTagError<Name>, never, ObjectTagOutputByName[Name]>;
-/** Creates an object-tag Type by refining an existing object Type. */
+/**
+ * Creates an object-tag Type by refining an existing object Type.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertSame,
+ *   assertType,
+ *   instanceOf,
+ *   objectTag,
+ * } from "@evolu/common";
+ *
+ * class TaggedValue {
+ *   readonly [Symbol.toStringTag] = "TaggedValue";
+ * }
+ *
+ * const TaggedValueType = objectTag(
+ *   "TaggedValue",
+ *   instanceOf(TaggedValue),
+ * );
+ * const value = new TaggedValue();
+ * const result = TaggedValueType.fromUnknown(value);
+ *
+ * assertOk(result);
+ * assertSame(result.value, value);
+ * assertType<
+ *   true,
+ *   typeof result.value extends TaggedValue ? true : false
+ * >();
+ * assertEqual(TaggedValueType.expected, "TaggedValue");
+ * ```
+ */
 export declare function objectTag<Name extends TypeName, OutputType extends ConcreteTypeNode & {
     readonly Output: object;
 }>(name: ValidateConcreteTypeName<Name>, outputType: ValidateOutput<OutputType> & ([ChildTypeNameValidationError<"ObjectTag", OutputType>] extends [never] ? unknown : ChildTypeNameValidationError<"ObjectTag", OutputType>)): ObjectTagType<Name, OutputType>;
@@ -1116,7 +1294,7 @@ export declare const ArrayBuffer: Type<"ArrayBuffer", ArrayBuffer, ArrayBuffer,
  * ### Example
  *
  * ```ts
- * import { instanceOf } from "@evolu/common";
+ * import { assertFalse, assertTrue, instanceOf } from "@evolu/common";
  *
  * class User {
  *   readonly name: string;
@@ -1128,8 +1306,8 @@ export declare const ArrayBuffer: Type<"ArrayBuffer", ArrayBuffer, ArrayBuffer,
  *
  * const UserInstance = instanceOf(User);
  *
- * assert(UserInstance.is(new User("Ada")));
- * assert(!UserInstance.is({ name: "Ada" }));
+ * assertTrue(UserInstance.is(new User("Ada")));
+ * assertFalse(UserInstance.is({ name: "Ada" }));
  * ```
  *
  * @group Base
@@ -1179,13 +1357,23 @@ type InstanceConstructorCompileTimeError = CompileTimeError<"Type", "Constructor
  * ### Example
  *
  * ```ts
- * import { literal } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   literal,
+ * } from "@evolu/common";
  *
  * const Ready = literal("ready");
  *
- * expectTypeOf<typeof Ready.Output>().toEqualTypeOf<"ready">();
- * expectOk(Ready.fromUnknown("ready"), "ready");
- * expectErr(Ready.fromUnknown("pending"), {
+ * assertType<"ready", typeof Ready.Output>();
+ * assertOk(Ready.fromUnknown("ready"), "ready");
+ * const invalid = Ready.fromUnknown("pending");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "Literal",
  *   expected: "ready",
  *   value: "pending",
@@ -1260,17 +1448,29 @@ export declare const Null: LiteralType<null>;
  * ### Example
  *
  * ```ts
- * import { Number, String, union } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   Number,
+ *   String,
+ *   union,
+ * } from "@evolu/common";
  *
  * const Status = union("draft", "published");
  * const StatusOrCode = union("draft", "published", Number);
  *
- * expectOk(Status.fromUnknown("draft"), "draft");
- * expectOk(StatusOrCode.fromUnknown(42), 42);
+ * assertOk(Status.fromUnknown("draft"), "draft");
+ * assertOk(StatusOrCode.fromUnknown(42), 42);
  *
  * const TextOrNumber = union(String, Number);
  *
- * expectErr(TextOrNumber.fromUnknown(true, { errors: "all" }), {
+ * const invalid = TextOrNumber.fromUnknown(true, { errors: "all" });
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "Union",
  *   errors: [
  *     {
@@ -1309,11 +1509,11 @@ export declare function union<const Members extends AtLeastTwoReadonlyArray<Type
  * ### Example
  *
  * ```ts
- * import { String, undefinedOr } from "@evolu/common";
+ * import { assertOk, String, undefinedOr } from "@evolu/common";
  *
  * const StringOrUndefined = undefinedOr(String);
  *
- * expectOk(StringOrUndefined.fromUnknown(undefined), undefined);
+ * assertOk(StringOrUndefined.fromUnknown(undefined), undefined);
  * ```
  *
  * @group Unions
@@ -1325,11 +1525,11 @@ export declare const undefinedOr: <ValueType extends TypeNode>(type: ValidateUni
  * ### Example
  *
  * ```ts
- * import { String, nullOr } from "@evolu/common";
+ * import { assertOk, String, nullOr } from "@evolu/common";
  *
  * const NullableString = nullOr(String);
  *
- * expectOk(NullableString.fromUnknown(null), null);
+ * assertOk(NullableString.fromUnknown(null), null);
  * ```
  *
  * @group Unions
@@ -1341,12 +1541,12 @@ export declare const nullOr: <ValueType extends TypeNode>(type: ValidateUnionTyp
  * ### Example
  *
  * ```ts
- * import { String, nullishOr } from "@evolu/common";
+ * import { assertOk, String, nullishOr } from "@evolu/common";
  *
  * const NullishString = nullishOr(String);
  *
- * expectOk(NullishString.fromUnknown(undefined), undefined);
- * expectOk(NullishString.fromUnknown(null), null);
+ * assertOk(NullishString.fromUnknown(undefined), undefined);
+ * assertOk(NullishString.fromUnknown(null), null);
  * ```
  *
  * @group Unions
@@ -1454,7 +1654,16 @@ interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemb
  * the structured data decoded from it:
  *
  * ```ts
- * import { templateLiteralParser, union } from "@evolu/common";
+ * import {
+ *   assertFalse,
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   templateLiteralParser,
+ *   union,
+ * } from "@evolu/common";
  *
  * const Language = union("en", "cs");
  * const Region = union("US", "CZ");
@@ -1464,36 +1673,39 @@ interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemb
  *
  * // Output is the decoded language and region.
  * type SupportedLocale = typeof SupportedLocale.Output;
- * expectTypeOf<SupportedLocale>().toEqualTypeOf<
- *   readonly ["en" | "cs", "US" | "CZ"]
- * >();
+ * assertType<readonly ["en" | "cs", "US" | "CZ"], SupportedLocale>();
  *
  * // The parent Output is the canonical locale string.
  * type SupportedLocaleLiteral = typeof SupportedLocale.parent.Output;
- * expectTypeOf<SupportedLocaleLiteral>().toEqualTypeOf<
- *   "en-US" | "en-CZ" | "cs-US" | "cs-CZ"
+ * assertType<
+ *   "en-US" | "en-CZ" | "cs-US" | "cs-CZ",
+ *   SupportedLocaleLiteral
  * >();
  *
  * // Parse an unknown string into structured data.
  * const result = SupportedLocale.fromUnknown("cs-CZ");
- * expectOk(result, ["cs", "CZ"]);
+ * assertOk(result, ["cs", "CZ"]);
  * const locale = result.value;
- * expectTypeOf(locale).toEqualTypeOf<SupportedLocale>();
- * expectErr(SupportedLocale.fromUnknown("cs/CZ"), {
+ * assertType<SupportedLocale, typeof locale>();
+ * const invalid = SupportedLocale.fromUnknown("cs/CZ");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * const error: Data = invalid.error;
+ * assertEqual(error, {
  *   type: "TemplateLiteral",
  *   value: "cs/CZ",
  * });
  *
  * // Encode structured data into its canonical string.
  * const localeLiteral = SupportedLocale.to(locale);
- * expectTypeOf(localeLiteral).toEqualTypeOf<SupportedLocaleLiteral>();
- * expect(localeLiteral).toBe("cs-CZ");
+ * assertType<SupportedLocaleLiteral, typeof localeLiteral>();
+ * assertEqual(localeLiteral, "cs-CZ");
  *
  * // Validate a string configuration value.
  * const configValue: unknown = "cs-CZ";
- * assert(SupportedLocale.parent.is(configValue));
- * expectTypeOf(configValue).toEqualTypeOf<SupportedLocaleLiteral>();
- * expect(SupportedLocale.parent.is("fr-CZ")).toBe(false);
+ * assertType(SupportedLocale.parent, configValue);
+ * assertType<SupportedLocaleLiteral, typeof configValue>();
+ * assertFalse(SupportedLocale.parent.is("fr-CZ"));
  * ```
  *
  * `SupportedLocale` is structured data for application code.
@@ -1506,6 +1718,8 @@ interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemb
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
  *   NonNegativeDecimalString,
  *   templateLiteralParser,
  * } from "@evolu/common";
@@ -1518,8 +1732,8 @@ interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemb
  * // DecimalText.to requires a validated NonNegativeDecimalString.
  * const zero = NonNegativeDecimalString.orThrow("0");
  *
- * expectOk(DecimalText.fromUnknown("decimal:0"), [zero]);
- * expect(DecimalText.to([zero])).toBe("decimal:0");
+ * assertOk(DecimalText.fromUnknown("decimal:0"), [zero]);
+ * assertEqual(DecimalText.to([zero]), "decimal:0");
  * ```
  *
  * Capture Types (the Type arguments passed to `templateLiteralParser`) can use
@@ -1527,6 +1741,9 @@ interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemb
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   Int64FromInt64String,
  *   templateLiteralParser,
  * } from "@evolu/common";
@@ -1537,24 +1754,29 @@ interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemb
  *
  * // Decode the string into structured data.
  * const result = ItemId.fromUnknown("item-42");
- * expectOk(result, [42n]);
+ * assertOk(result, [42n]);
  * const itemId = result.value;
- * expectTypeOf(itemId).toEqualTypeOf<ItemId>();
+ * assertType<ItemId, typeof itemId>();
  *
  * // Encode the structured data into its canonical string.
  * const itemIdLiteral = ItemId.to(itemId);
- * expectTypeOf(itemIdLiteral).toEqualTypeOf<ItemIdLiteral>();
- * expect(itemIdLiteral).toBe("item-42");
+ * assertType<ItemIdLiteral, typeof itemIdLiteral>();
+ * assertEqual(itemIdLiteral, "item-42");
  *
  * // TypeScript cannot prove from the literal alone that "42" is a valid Int64 encoding.
  * // @ts-expect-error Validate it with ItemId.parent or create it with ItemId.to.
- * const invalidItemIdLiteral: ItemIdLiteral = "item-42";
+ * const _invalidItemIdLiteral: ItemIdLiteral = "item-42";
  * ```
  *
  * Fixed-width captures can be adjacent:
  *
  * ```ts
- * import { templateLiteralParser, union } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   templateLiteralParser,
+ *   union,
+ * } from "@evolu/common";
  *
  * const Digit = union("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");
  * const TwoDigits = templateLiteralParser(Digit, Digit);
@@ -1564,10 +1786,10 @@ interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemb
  * const twoDigits: TwoDigits = ["4", "2"];
  * const twoDigitsLiteral: TwoDigitsLiteral = "42";
  * // @ts-expect-error TwoDigitsLiteral requires exactly two digits.
- * const threeDigitsLiteral: TwoDigitsLiteral = "123";
+ * const _threeDigitsLiteral: TwoDigitsLiteral = "123";
  *
- * expectOk(TwoDigits.from.parent(twoDigitsLiteral), twoDigits);
- * expect(TwoDigits.to(twoDigits)).toBe(twoDigitsLiteral);
+ * assertOk(TwoDigits.from.parent(twoDigitsLiteral), twoDigits);
+ * assertEqual(TwoDigits.to(twoDigits), twoDigitsLiteral);
  * ```
  *
  * TypeScript rejects multiple variable-width captures because their encoded
@@ -1623,17 +1845,24 @@ export interface TemplateLiteralType<Parts extends TemplateLiteralParts> extends
  * ### Example
  *
  * ```ts
- * import { templateLiteral, union } from "@evolu/common";
+ * import {
+ *   assertFalse,
+ *   assertOk,
+ *   assertType,
+ *   templateLiteral,
+ *   union,
+ * } from "@evolu/common";
  *
  * const Language = union("en", "cs");
  * const Region = union("US", "CZ");
  * const Locale = templateLiteral(Language, "-", Region);
  *
- * expectTypeOf<typeof Locale.Output>().toEqualTypeOf<
- *   "en-US" | "en-CZ" | "cs-US" | "cs-CZ"
+ * assertType<
+ *   "en-US" | "en-CZ" | "cs-US" | "cs-CZ",
+ *   typeof Locale.Output
  * >();
- * expectOk(Locale.fromUnknown("cs-CZ"), "cs-CZ");
- * expect(Locale.is("fr-CZ")).toBe(false);
+ * assertOk(Locale.fromUnknown("cs-CZ"), "cs-CZ");
+ * assertFalse(Locale.is("fr-CZ"));
  * ```
  *
  * @group Template literals
@@ -1703,8 +1932,13 @@ type TemplateLiteralStringWidth<Value extends string, Width extends ReadonlyArra
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
  *   BigInt,
  *   brand,
+ *   Data,
  *   err,
  *   ok,
  *   type Brand,
@@ -1723,14 +1957,17 @@ type TemplateLiteralStringWidth<Value extends string, Width extends ReadonlyArra
  * type Int64 = typeof Int64.Output;
  *
  * // Note the Brand.
- * expectTypeOf<Int64>().toEqualTypeOf<bigint & Brand<"Int64">>();
+ * assertType<bigint & Brand<"Int64">, Int64>();
  *
  * interface Int64Error extends TypeError<"Int64"> {
  *   readonly value: bigint;
  * }
  *
- * expectOk(Int64.fromUnknown(42n), 42n);
- * expectErr(Int64.fromUnknown(2n ** 63n), {
+ * assertOk(Int64.fromUnknown(42n), 42n);
+ * const invalid = Int64.fromUnknown(2n ** 63n);
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "Int64",
  *   value: 2n ** 63n,
  * });
@@ -1765,13 +2002,21 @@ export interface BrandType<ParentType extends TypeNode, Name extends TypeName, E
  * ### Example
  *
  * ```ts
- * import { DateIso } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   DateIso,
+ * } from "@evolu/common";
  *
- * expectOk(
- *   DateIso.fromUnknown("2023-01-01T12:00:00.000Z"),
- *   "2023-01-01T12:00:00.000Z",
- * );
- * expectErr(DateIso.fromUnknown("2023-01-01"), {
+ * const value = "2023-01-01T12:00:00.000Z";
+ * assertOk(DateIso.fromUnknown(value), value);
+ * const invalid = DateIso.fromUnknown("2023-01-01");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "DateIso",
  *   value: "2023-01-01",
  * });
@@ -1795,13 +2040,13 @@ export interface DateIsoError extends TypeError<"DateIso"> {
  * ### Example
  *
  * ```ts
- * import { DateIsoFromDate } from "@evolu/common";
+ * import { assertEqual, assertOk, DateIsoFromDate } from "@evolu/common";
  *
- * const date = new globalThis.Date("2025-01-01T12:00:00.000Z");
+ * const date = new Date("2025-01-01T12:00:00.000Z");
  * const result = DateIsoFromDate.fromUnknown(date);
  *
- * expectOk(result, "2025-01-01T12:00:00.000Z");
- * expect(DateIsoFromDate.to(result.value)).toEqual(date);
+ * assertOk(result, "2025-01-01T12:00:00.000Z");
+ * assertEqual(DateIsoFromDate.to(result.value), date);
  * ```
  *
  * @group String
@@ -1857,6 +2102,11 @@ export interface UInt64Error extends TypeError<"UInt64"> {
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
  *   String,
  *   brand,
  *   err,
@@ -1882,14 +2132,17 @@ export interface UInt64Error extends TypeError<"UInt64"> {
  * const TrimmedString = trimmed(String);
  * type TrimmedString = typeof TrimmedString.Output;
  *
- * expectTypeOf<TrimmedString>().toEqualTypeOf<string & Brand<"Trimmed">>();
+ * assertType<string & Brand<"Trimmed">, TrimmedString>();
  *
  * interface TrimmedError extends TypeError<"Trimmed"> {
  *   readonly value: string;
  * }
  *
- * expectOk(TrimmedString.fromUnknown("Evolu"), "Evolu");
- * expectErr(TrimmedString.fromUnknown(" Evolu"), {
+ * assertOk(TrimmedString.fromUnknown("Evolu"), "Evolu");
+ * const invalid = TrimmedString.fromUnknown(" Evolu");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "Trimmed",
  *   value: " Evolu",
  * });
@@ -1916,6 +2169,7 @@ export type BrandFactory<Name extends TypeName, Value, Error extends TypeError<N
  *
  * ```ts
  * import {
+ *   assertType,
  *   Number,
  *   brand,
  *   err,
@@ -1947,10 +2201,8 @@ export type BrandFactory<Name extends TypeName, Value, Error extends TypeError<N
  * const LessThan100 = lessThan(100)(Number);
  * type LessThan100 = typeof LessThan100.Output;
  *
- * expectTypeOf(LessThan100.name).toEqualTypeOf<"LessThan100">();
- * expectTypeOf<LessThan100>().toEqualTypeOf<
- *   number & Brand<"LessThan100">
- * >();
+ * assertType<"LessThan100", typeof LessThan100.name>();
+ * assertType<number & Brand<"LessThan100">, LessThan100>();
  *
  * interface LessThanError<
  *   Max extends number,
@@ -1975,17 +2227,27 @@ type BrandFactoryNumberError = CompileTimeError<"Brand Factory", "Parameter must
  * ### Example
  *
  * ```ts
- * import { String, capitalized, type Brand } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   String,
+ *   capitalized,
+ *   type Brand,
+ * } from "@evolu/common";
  *
  * const CapitalizedString = capitalized(String);
  * type CapitalizedString = typeof CapitalizedString.Output;
  *
- * expectTypeOf<CapitalizedString>().toEqualTypeOf<
- *   string & Brand<"Capitalized">
- * >();
+ * assertType<string & Brand<"Capitalized">, CapitalizedString>();
  *
- * expectOk(CapitalizedString.fromUnknown("Evolu"), "Evolu");
- * expectErr(CapitalizedString.fromUnknown("evolu"), {
+ * assertOk(CapitalizedString.fromUnknown("Evolu"), "Evolu");
+ * const invalid = CapitalizedString.fromUnknown("evolu");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "Capitalized",
  *   value: "evolu",
  * });
@@ -2015,11 +2277,11 @@ export type CapitalizedString = typeof CapitalizedString.Output;
  * ### Example
  *
  * ```ts
- * import { String, trimmed } from "@evolu/common";
+ * import { assertOk, String, trimmed } from "@evolu/common";
  *
  * const Trimmed = trimmed(String);
  *
- * expectOk(Trimmed.fromUnknown("Evolu"), "Evolu");
+ * assertOk(Trimmed.fromUnknown("Evolu"), "Evolu");
  * ```
  *
  * @group String
@@ -2052,9 +2314,9 @@ export type TrimmedString = typeof TrimmedString.Output;
  * ### Example
  *
  * ```ts
- * import { trim } from "@evolu/common";
+ * import { assertEqual, trim } from "@evolu/common";
  *
- * expect(trim("  Evolu  ")).toBe("Evolu");
+ * assertEqual(trim("  Evolu  "), "Evolu");
  * ```
  *
  * @group String
@@ -2066,13 +2328,13 @@ export declare const trim: (value: string) => TrimmedString;
  * ### Example
  *
  * ```ts
- * import { String, array, minLength } from "@evolu/common";
+ * import { assertOk, String, array, minLength } from "@evolu/common";
  *
  * const AtLeastThreeCharacters = minLength(3)(String);
  * const AtLeastTwoItems = minLength(2)(array(String));
  *
- * expectOk(AtLeastThreeCharacters.fromUnknown("abc"), "abc");
- * expectOk(AtLeastTwoItems.fromUnknown(["a", "b"]), ["a", "b"]);
+ * assertOk(AtLeastThreeCharacters.fromUnknown("abc"), "abc");
+ * assertOk(AtLeastTwoItems.fromUnknown(["a", "b"]), ["a", "b"]);
  * ```
  *
  * @group String
@@ -2110,13 +2372,13 @@ export type NonEmptyTrimmedString = typeof NonEmptyTrimmedString.Output;
  * ### Example
  *
  * ```ts
- * import { String, array, maxLength } from "@evolu/common";
+ * import { assertOk, String, array, maxLength } from "@evolu/common";
  *
  * const AtMostThreeCharacters = maxLength(3)(String);
  * const AtMostTwoItems = maxLength(2)(array(String));
  *
- * expectOk(AtMostThreeCharacters.fromUnknown("abc"), "abc");
- * expectOk(AtMostTwoItems.fromUnknown(["a", "b"]), ["a", "b"]);
+ * assertOk(AtMostThreeCharacters.fromUnknown("abc"), "abc");
+ * assertOk(AtMostTwoItems.fromUnknown(["a", "b"]), ["a", "b"]);
  * ```
  *
  * @group String
@@ -2152,13 +2414,13 @@ export type NonEmptyTrimmedString1000 = typeof NonEmptyTrimmedString1000.Output;
  * ### Example
  *
  * ```ts
- * import { String, array, length } from "@evolu/common";
+ * import { assertOk, String, array, length } from "@evolu/common";
  *
  * const ThreeCharacters = length(3)(String);
  * const TwoItems = length(2)(array(String));
  *
- * expectOk(ThreeCharacters.fromUnknown("abc"), "abc");
- * expectOk(TwoItems.fromUnknown(["a", "b"]), ["a", "b"]);
+ * assertOk(ThreeCharacters.fromUnknown("abc"), "abc");
+ * assertOk(TwoItems.fromUnknown(["a", "b"]), ["a", "b"]);
  * ```
  *
  * @group String
@@ -2182,21 +2444,34 @@ export interface LengthError<Exact extends number = number> extends TypeError<`L
  * A non-empty string using the URL-safe alphabet:
  *
  * ```ts
- * import { String, regex, type Brand } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   String,
+ *   regex,
+ *   type Brand,
+ * } from "@evolu/common";
  *
- * const UrlSafeString = regex("UrlSafeString", /^[A-Za-z0-9_-]+$/)(String);
+ * const UrlSafeString = regex(
+ *   "UrlSafeString",
+ *   /^[A-Za-z0-9_-]+$/u,
+ * )(String);
  * type UrlSafeString = typeof UrlSafeString.Output;
  *
- * expectTypeOf<UrlSafeString>().toEqualTypeOf<
- *   string & Brand<"UrlSafeString">
- * >();
+ * assertType<string & Brand<"UrlSafeString">, UrlSafeString>();
  *
- * expectOk(UrlSafeString.fromUnknown("abc-123_DEF"), "abc-123_DEF");
- * expectErr(UrlSafeString.fromUnknown("not safe"), {
+ * assertOk(UrlSafeString.fromUnknown("abc-123_DEF"), "abc-123_DEF");
+ * const invalid = UrlSafeString.fromUnknown("not safe");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "UrlSafeString",
  *   value: "not safe",
  *   source: "^[A-Za-z0-9_-]+$",
- *   flags: "",
+ *   flags: "u",
  * });
  * ```
  *
@@ -2249,9 +2524,10 @@ export interface Base64UrlError extends TypeError<"Base64Url"> {
  * ### Example
  *
  * ```ts
- * import { uint8ArrayToBase64Url } from "@evolu/common";
+ * import { assertEqual, uint8ArrayToBase64Url } from "@evolu/common";
  *
- * expect(uint8ArrayToBase64Url(new Uint8Array([0, 1, 2, 255]))).toBe(
+ * assertEqual(
+ *   uint8ArrayToBase64Url(new Uint8Array([0, 1, 2, 255])),
  *   "AAEC_w",
  * );
  * ```
@@ -2265,11 +2541,16 @@ export declare const uint8ArrayToBase64Url: (bytes: Uint8Array) => Base64Url;
  * ### Example
  *
  * ```ts
- * import { Base64Url, base64UrlToUint8Array } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   Base64Url,
+ *   base64UrlToUint8Array,
+ * } from "@evolu/common";
  *
  * const value = Base64Url.orThrow("AAEC_w");
  *
- * expect(base64UrlToUint8Array(value)).toEqual(
+ * assertEqual(
+ *   base64UrlToUint8Array(value),
  *   new Uint8Array([0, 1, 2, 255]),
  * );
  * ```
@@ -2350,6 +2631,8 @@ export interface IdError extends TypeError<"Id"> {
  *
  * ```ts
  * import {
+ *   assertTrue,
+ *   assertType,
  *   Id,
  *   createId,
  *   createRandomBytes,
@@ -2358,8 +2641,8 @@ export interface IdError extends TypeError<"Id"> {
  *
  * const userId = createId<"User">({ randomBytes: createRandomBytes() });
  *
- * expect(Id.is(userId)).toBe(true);
- * expectTypeOf(userId).toEqualTypeOf<Id & Brand<"User">>();
+ * assertTrue(Id.is(userId));
+ * assertType<Id & Brand<"User">, typeof userId>();
  * ```
  *
  * @group String
@@ -2375,14 +2658,20 @@ export declare const createId: <B extends string = never>(deps: RandomBytesDep,
  * ### Example
  *
  * ```ts
- * import { createIdFromString, type Brand, type Id } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   createIdFromString,
+ *   type Brand,
+ *   type Id,
+ * } from "@evolu/common";
  *
  * const first = createIdFromString("external-user-123");
  * const second = createIdFromString("external-user-123");
  * const todoId = createIdFromString<"Todo">("external-todo-456");
  *
- * expect(first).toBe(second);
- * expectTypeOf(todoId).toEqualTypeOf<Id & Brand<"Todo">>();
+ * assertEqual(first, second);
+ * assertType<Id & Brand<"Todo">, typeof todoId>();
  * ```
  *
  * @group String
@@ -2400,6 +2689,7 @@ export declare const createIdFromString: <B extends string = never>(value: strin
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createIdAsUuidv7,
  *   createRandomBytes,
  *   createTime,
@@ -2412,8 +2702,8 @@ export declare const createIdFromString: <B extends string = never>(value: strin
  * });
  * const bytes = idToIdBytes(value);
  *
- * expect(bytes[6] >> 4).toBe(0x7);
- * expect(bytes[8] & 0xc0).toBe(0x80);
+ * assertEqual(bytes[6] >> 4, 0x7);
+ * assertEqual(bytes[8] & 0xc0, 0x80);
  * ```
  *
  * @group String
@@ -2426,6 +2716,7 @@ export declare const createIdAsUuidv7: <B extends string = never>(deps: RandomBy
  *
  * ```ts
  * import {
+ *   assertType,
  *   createIdFromString,
  *   id,
  *   type Brand,
@@ -2435,7 +2726,7 @@ export declare const createIdAsUuidv7: <B extends string = never>(deps: RandomBy
  * const TodoId = id("Todo");
  * const todoId = TodoId.orThrow(createIdFromString("todo"));
  *
- * expectTypeOf(todoId).toEqualTypeOf<Id & Brand<"Todo">>();
+ * assertType<Id & Brand<"Todo">, typeof todoId>();
  * ```
  *
  * @group String
@@ -2485,11 +2776,15 @@ export declare const idBytesTypeValueLength: NonNegativeInt;
  * ### Example
  *
  * ```ts
- * import { createIdFromString, idToIdBytes } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   createIdFromString,
+ *   idToIdBytes,
+ * } from "@evolu/common";
  *
  * const bytes = idToIdBytes(createIdFromString("todo"));
  *
- * expect(bytes).toHaveLength(16);
+ * assertEqual(bytes.length, 16);
  * ```
  *
  * @group String
@@ -2502,6 +2797,7 @@ export declare const idToIdBytes: (value: Id) => IdBytes;
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createIdFromString,
  *   idBytesToId,
  *   idToIdBytes,
@@ -2509,7 +2805,7 @@ export declare const idToIdBytes: (value: Id) => IdBytes;
  *
  * const value = createIdFromString("todo");
  *
- * expect(idBytesToId(idToIdBytes(value))).toBe(value);
+ * assertEqual(idBytesToId(idToIdBytes(value)), value);
  * ```
  *
  * @group String
@@ -2540,12 +2836,17 @@ export interface Int64StringError extends TypeError<"Int64String"> {
  * ### Example
  *
  * ```ts
- * import { Int64FromInt64String } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   Int64FromInt64String,
+ * } from "@evolu/common";
  *
  * const result = Int64FromInt64String.fromUnknown("9223372036854775807");
  *
- * expectOk(result, 9223372036854775807n);
- * expect(Int64FromInt64String.to(result.value)).toBe(
+ * assertOk(result, 9223372036854775807n);
+ * assertEqual(
+ *   Int64FromInt64String.to(result.value),
  *   "9223372036854775807",
  * );
  * ```
@@ -2559,11 +2860,11 @@ export declare const Int64FromInt64String: TransformType<BrandType<BrandType<Bra
  * ### Example
  *
  * ```ts
- * import { Number, nonNegative } from "@evolu/common";
+ * import { assertOk, Number, nonNegative } from "@evolu/common";
  *
  * const NonNegative = nonNegative(Number);
  *
- * expectOk(NonNegative.fromUnknown(0), 0);
+ * assertOk(NonNegative.fromUnknown(0), 0);
  * ```
  *
  * @group Number
@@ -2590,11 +2891,11 @@ export type NonNegativeNumber = typeof NonNegativeNumber.Output;
  * ### Example
  *
  * ```ts
- * import { Number, positive } from "@evolu/common";
+ * import { assertOk, Number, positive } from "@evolu/common";
  *
  * const Positive = positive(Number);
  *
- * expectOk(Positive.fromUnknown(1), 1);
+ * assertOk(Positive.fromUnknown(1), 1);
  * ```
  *
  * @group Number
@@ -2624,11 +2925,11 @@ export type PositiveNumber = typeof PositiveNumber.Output;
  * ### Example
  *
  * ```ts
- * import { Number, nonPositive } from "@evolu/common";
+ * import { assertOk, Number, nonPositive } from "@evolu/common";
  *
  * const NonPositive = nonPositive(Number);
  *
- * expectOk(NonPositive.fromUnknown(0), 0);
+ * assertOk(NonPositive.fromUnknown(0), 0);
  * ```
  *
  * @group Number
@@ -2655,11 +2956,11 @@ export type NonPositiveNumber = typeof NonPositiveNumber.Output;
  * ### Example
  *
  * ```ts
- * import { Number, negative } from "@evolu/common";
+ * import { assertOk, Number, negative } from "@evolu/common";
  *
  * const Negative = negative(Number);
  *
- * expectOk(Negative.fromUnknown(-1), -1);
+ * assertOk(Negative.fromUnknown(-1), -1);
  * ```
  *
  * @group Number
@@ -2689,11 +2990,11 @@ export type NegativeNumber = typeof NegativeNumber.Output;
  * ### Example
  *
  * ```ts
- * import { Number, nonNaN } from "@evolu/common";
+ * import { assertOk, Number, nonNaN } from "@evolu/common";
  *
  * const NonNaN = nonNaN(Number);
  *
- * expectOk(NonNaN.fromUnknown(Infinity), Infinity);
+ * assertOk(NonNaN.fromUnknown(Infinity), Infinity);
  * ```
  *
  * @group Number
@@ -2725,11 +3026,11 @@ export type NonNaNNumber = typeof NonNaNNumber.Output;
  * ### Example
  *
  * ```ts
- * import { Number, finite } from "@evolu/common";
+ * import { assertOk, Number, finite } from "@evolu/common";
  *
  * const Finite = finite(Number);
  *
- * expectOk(Finite.fromUnknown(42), 42);
+ * assertOk(Finite.fromUnknown(42), 42);
  * ```
  *
  * @group Number
@@ -2773,15 +3074,28 @@ export type PositiveFiniteNumber = typeof PositiveFiniteNumber.Output;
  * ### Example
  *
  * ```ts
- * import { Number, int, type Brand } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   Number,
+ *   int,
+ *   type Brand,
+ * } from "@evolu/common";
  *
  * const Int = int(Number);
  * type Int = typeof Int.Output;
  *
- * expectTypeOf<Int>().toEqualTypeOf<number & Brand<"Int">>();
+ * assertType<number & Brand<"Int">, Int>();
  *
- * expectOk(Int.fromUnknown(42), 42);
- * expectErr(Int.fromUnknown(1.5), { type: "Int", value: 1.5 });
+ * assertOk(Int.fromUnknown(42), 42);
+ * const invalid = Int.fromUnknown(1.5);
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * const error: Data = invalid.error;
+ * assertEqual(error, { type: "Int", value: 1.5 });
  * ```
  *
  * @group Number
@@ -2860,11 +3174,11 @@ export type NegativeInt = typeof NegativeInt.Output;
  * ### Example
  *
  * ```ts
- * import { Number, greaterThan } from "@evolu/common";
+ * import { assertOk, Number, greaterThan } from "@evolu/common";
  *
  * const GreaterThanTen = greaterThan(10)(Number);
  *
- * expectOk(GreaterThanTen.fromUnknown(11), 11);
+ * assertOk(GreaterThanTen.fromUnknown(11), 11);
  * ```
  *
  * @group Number
@@ -2885,11 +3199,11 @@ export interface GreaterThanError<Min extends number = number> extends TypeError
  * ### Example
  *
  * ```ts
- * import { Number, greaterThanOrEqualTo } from "@evolu/common";
+ * import { assertOk, Number, greaterThanOrEqualTo } from "@evolu/common";
  *
  * const AtLeastTen = greaterThanOrEqualTo(10)(Number);
  *
- * expectOk(AtLeastTen.fromUnknown(10), 10);
+ * assertOk(AtLeastTen.fromUnknown(10), 10);
  * ```
  *
  * @group Number
@@ -2910,11 +3224,11 @@ export interface GreaterThanOrEqualToError<Min extends number = number> extends
  * ### Example
  *
  * ```ts
- * import { Number, lessThan } from "@evolu/common";
+ * import { assertOk, Number, lessThan } from "@evolu/common";
  *
  * const LessThanTen = lessThan(10)(Number);
  *
- * expectOk(LessThanTen.fromUnknown(9), 9);
+ * assertOk(LessThanTen.fromUnknown(9), 9);
  * ```
  *
  * @group Number
@@ -2942,11 +3256,11 @@ export type Age = typeof Age.Output;
  * ### Example
  *
  * ```ts
- * import { Number, lessThanOrEqualTo } from "@evolu/common";
+ * import { assertOk, Number, lessThanOrEqualTo } from "@evolu/common";
  *
  * const AtMostTen = lessThanOrEqualTo(10)(Number);
  *
- * expectOk(AtMostTen.fromUnknown(10), 10);
+ * assertOk(AtMostTen.fromUnknown(10), 10);
  * ```
  *
  * @group Number
@@ -2997,13 +3311,23 @@ export type Ratio = typeof Ratio.Output;
  * ### Example
  *
  * ```ts
- * import { DecimalString } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   DecimalString,
+ * } from "@evolu/common";
  *
- * expectOk(DecimalString.fromUnknown("-10.25"), "-10.25");
- * expectOk(DecimalString.fromUnknown("0"), "0");
- * expectOk(DecimalString.fromUnknown("10.25"), "10.25");
+ * assertOk(DecimalString.fromUnknown("-10.25"), "-10.25");
+ * assertOk(DecimalString.fromUnknown("0"), "0");
+ * assertOk(DecimalString.fromUnknown("10.25"), "10.25");
  *
- * expectErr(DecimalString.fromUnknown("10.250"), {
+ * const invalid = DecimalString.fromUnknown("10.250");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "DecimalString",
  *   value: "10.250",
  * });
@@ -3027,11 +3351,15 @@ export interface DecimalStringError extends TypeError<"DecimalString"> {
  * ### Example
  *
  * ```ts
- * import { DecimalString, nonNegativeDecimalString } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   DecimalString,
+ *   nonNegativeDecimalString,
+ * } from "@evolu/common";
  *
  * const NonNegative = nonNegativeDecimalString(DecimalString);
  *
- * expectOk(NonNegative.fromUnknown("0.5"), "0.5");
+ * assertOk(NonNegative.fromUnknown("0.5"), "0.5");
  * ```
  *
  * @group Number
@@ -3058,11 +3386,15 @@ export type NonNegativeDecimalString = typeof NonNegativeDecimalString.Output;
  * ### Example
  *
  * ```ts
- * import { DecimalString, positiveDecimalString } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   DecimalString,
+ *   positiveDecimalString,
+ * } from "@evolu/common";
  *
  * const Positive = positiveDecimalString(DecimalString);
  *
- * expectOk(Positive.fromUnknown("0.5"), "0.5");
+ * assertOk(Positive.fromUnknown("0.5"), "0.5");
  * ```
  *
  * @group Number
@@ -3092,11 +3424,15 @@ export type PositiveDecimalString = typeof PositiveDecimalString.Output;
  * ### Example
  *
  * ```ts
- * import { DecimalString, nonPositiveDecimalString } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   DecimalString,
+ *   nonPositiveDecimalString,
+ * } from "@evolu/common";
  *
  * const NonPositive = nonPositiveDecimalString(DecimalString);
  *
- * expectOk(NonPositive.fromUnknown("-0.5"), "-0.5");
+ * assertOk(NonPositive.fromUnknown("-0.5"), "-0.5");
  * ```
  *
  * @group Number
@@ -3123,11 +3459,15 @@ export type NonPositiveDecimalString = typeof NonPositiveDecimalString.Output;
  * ### Example
  *
  * ```ts
- * import { DecimalString, negativeDecimalString } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   DecimalString,
+ *   negativeDecimalString,
+ * } from "@evolu/common";
  *
  * const Negative = negativeDecimalString(DecimalString);
  *
- * expectOk(Negative.fromUnknown("-0.5"), "-0.5");
+ * assertOk(Negative.fromUnknown("-0.5"), "-0.5");
  * ```
  *
  * @group Number
@@ -3165,16 +3505,29 @@ export type NegativeDecimalString = typeof NegativeDecimalString.Output;
  * ### Example
  *
  * ```ts
- * import { FiniteNumber, multipleOf, type Brand } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   FiniteNumber,
+ *   multipleOf,
+ *   type Brand,
+ * } from "@evolu/common";
  *
  * const Tenths = multipleOf("0.1")(FiniteNumber);
  *
- * expectTypeOf<typeof Tenths.Output>().toEqualTypeOf<
- *   FiniteNumber & Brand<"MultipleOf0.1">
+ * assertType<
+ *   FiniteNumber & Brand<"MultipleOf0.1">,
+ *   typeof Tenths.Output
  * >();
  *
- * expectOk(Tenths.fromUnknown(0.3), 0.3);
- * expectErr(Tenths.fromUnknown(0.31), {
+ * assertOk(Tenths.fromUnknown(0.3), 0.3);
+ * const invalid = Tenths.fromUnknown(0.31);
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "MultipleOf0.1",
  *   value: 0.31,
  *   divisor: "0.1",
@@ -3207,11 +3560,11 @@ type MultipleOfDivisorError = CompileTimeError<"MultipleOf", 'Divisor must be on
  * ### Example
  *
  * ```ts
- * import { Number, between } from "@evolu/common";
+ * import { assertOk, Number, between } from "@evolu/common";
  *
  * const Percentage = between(0, 100)(Number);
  *
- * expectOk(Percentage.fromUnknown(75), 75);
+ * assertOk(Percentage.fromUnknown(75), 75);
  * ```
  *
  * @group Number
@@ -3253,6 +3606,11 @@ export interface BetweenError<Min extends number = number, Max extends number =
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
  *   String,
  *   array,
  *   brand,
@@ -3264,12 +3622,16 @@ export interface BetweenError<Min extends number = number, Max extends number =
  * const UserIds = array(UserId);
  * const result = UserIds.from.parent(["ada", "grace"]);
  *
- * expectTypeOf(result).toEqualTypeOf<
- *   Result<ReadonlyArray<string & Brand<"UserId">>, never>
+ * assertType<
+ *   Result<ReadonlyArray<string & Brand<"UserId">>>,
+ *   typeof result
  * >();
- * expectOk(result, ["ada", "grace"]);
- * expectOk(UserIds.fromUnknown(["ada", "grace"]), ["ada", "grace"]);
- * expectErr(UserIds.fromUnknown("ada"), {
+ * assertOk(result, ["ada", "grace"]);
+ * assertOk(UserIds.fromUnknown(["ada", "grace"]), ["ada", "grace"]);
+ * const invalid = UserIds.fromUnknown("ada");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
  *   type: "Array",
  *   reason: { kind: "NotArray", value: "ada" },
  * });
@@ -3387,20 +3749,20 @@ interface ArrayItemsErrorValue<Error extends TypeError, IncludeStructuralIssues
 /**
  * Set {@link Type} whose every element must match one Type.
  *
- * Direct Sets from this or another realm are accepted. Set subclasses are
- * rejected. A Set must have no own properties; its elements are validated in
- * iteration order. Classification uses the realm-neutral object tag and
- * prototype structure under Evolu Type's trusted JavaScript policy.
+ * Sets from this or another realm are accepted. A Set must have no own
+ * properties; its elements are validated in iteration order. Classification
+ * uses the realm-neutral object tag under Evolu Type's trusted JavaScript
+ * policy.
  *
  * ### Example
  *
  * ```ts
- * import { String, set } from "@evolu/common";
+ * import { assertOk, String, set } from "@evolu/common";
  *
  * const Tags = set(String);
  * const tags = new Set(["local-first", "offline"]);
  *
- * expectOk(Tags.fromUnknown(tags), tags);
+ * assertOk(Tags.fromUnknown(tags), tags);
  * ```
  *
  * @group Collection
@@ -3431,12 +3793,11 @@ type SetNodeError<ElementType extends TypeNode> = [
     ElementType["parent"]
 ] extends [TypeNode] ? SetElementsError<ElementType["Error"]> : SetError<ElementType["Error"]>;
 /**
- * Error returned by {@link set} for a non-Set value, an invalid Set prototype,
- * or invalid Set items.
+ * Error returned by {@link set} for a non-Set value or invalid Set items.
  *
  * @group Collection
  */
-export type SetError<Error extends TypeError = TypeError> = SetNotSetError | SetUnexpectedPrototypeError | SetItemsErrorValue<Error, true>;
+export type SetError<Error extends TypeError = TypeError> = SetNotSetError | SetItemsErrorValue<Error, true>;
 /**
  * Error returned when a {@link set} input is not a Set.
  *
@@ -3448,17 +3809,6 @@ export interface SetNotSetError extends TypeError<"Set"> {
         readonly value: unknown;
     };
 }
-/**
- * An error returned when a {@link set} input is a Set subclass.
- *
- * @group Collection
- */
-export interface SetUnexpectedPrototypeError extends TypeError<"Set"> {
-    readonly reason: {
-        readonly kind: "UnexpectedPrototype";
-        readonly value: ReadonlySet<unknown>;
-    };
-}
 /**
  * An own property found on a Set value.
  *
@@ -3497,6 +3847,133 @@ interface SetItemsErrorValue<Error extends TypeError, IncludeStructuralIssues ex
         readonly issues: NonEmptyReadonlyArray<(true extends IncludeStructuralIssues ? SetStructuralIssue : never) | SetElementIssue<Error>>;
     };
 }
+/**
+ * Map {@link Type} whose keys and values must match their respective Types.
+ *
+ * Maps from this or another realm are accepted. A Map must have no own
+ * properties; its entries are validated in iteration order. When distinct input
+ * keys decode to the same output key, validation fails instead of discarding
+ * one associated value. Classification uses the realm-neutral object tag under
+ * Evolu Type's trusted JavaScript policy.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertOk, PositiveInt, String, map } from "@evolu/common";
+ *
+ * const Scores = map(String, PositiveInt);
+ * const scores = new Map([
+ *   ["Ada", 10],
+ *   ["Grace", 20],
+ * ]);
+ *
+ * assertOk(Scores.fromUnknown(scores), scores);
+ * ```
+ *
+ * @group Collection
+ */
+export declare const map: <KeyType extends ConcreteTypeNode, ValueType extends ConcreteTypeNode>(key: ValidateMapKeyType<KeyType>, value: ValidateMapValueType<ValueType>) => MapType<KeyType, ValueType>;
+/**
+ * The readonly-map {@link Type} returned by {@link map}.
+ *
+ * @group Collection
+ */
+export interface MapType<KeyType extends TypeNode, ValueType extends TypeNode> extends Type<"Map", ReadonlyMap<KeyType["Input"], ValueType["Input"]>, ReadonlyMap<KeyType["Output"], ValueType["Output"]>, MapNodeError<KeyType, ValueType>, MapParent<KeyType, ValueType>, MapError<InferErrors<KeyType>, InferErrors<ValueType>, MapCollisionFor<KeyType>>, never, CanonicalInputSubset<ReadonlyMap<KeyType["Input"], ValueType["Input"]>, ReadonlyMap<CanonicalInputOf<KeyType>, CanonicalInputOf<ValueType>>>, AllTypesUseIdentityEncoding<KeyType | ValueType>> {
+    readonly [reflectedTypesSymbol]?: KeyType | ValueType;
+    readonly key: KeyType;
+    readonly value: ValueType;
+}
+type MapParent<KeyType extends TypeNode, ValueType extends TypeNode> = [
+    KeyType["parent"] | ValueType["parent"]
+] extends [null] ? null : MapType<RootType<KeyType>, RootType<ValueType>>;
+type MapNodeError<KeyType extends TypeNode, ValueType extends TypeNode> = [
+    KeyType["parent"] | ValueType["parent"]
+] extends [null] ? MapError<InferErrors<KeyType>, InferErrors<ValueType>, never> : MapEntriesError<TypeFromError<KeyType>, TypeFromError<ValueType>, MapCollisionFor<KeyType>>;
+type MapCollisionFor<KeyType extends TypeNode> = [KeyType["parent"]] extends [
+    TypeNode
+] ? MapKeyCollisionIssue : never;
+type ValidateMapKeyType<T extends ConcreteTypeNode> = IsUnion<T> extends false ? T : CompileTimeError<"Type", "Map key must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
+type ValidateMapValueType<T extends ConcreteTypeNode> = IsUnion<T> extends false ? T : CompileTimeError<"Type", "Map value must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
+/**
+ * Error returned while validating a {@link map} and its entries.
+ *
+ * @group Collection
+ */
+export type MapError<KeyError extends TypeError = TypeError, ValueError extends TypeError = TypeError, Collision extends MapKeyCollisionIssue = MapKeyCollisionIssue> = MapNotMapError | MapEntriesErrorValue<KeyError, ValueError, Collision | MapExcessPropertyIssue>;
+/**
+ * Error returned when a {@link map} input is not a Map.
+ *
+ * @group Collection
+ */
+export interface MapNotMapError extends TypeError<"Map"> {
+    readonly reason: {
+        readonly kind: "NotMap";
+        readonly value: unknown;
+    };
+}
+/**
+ * An own property found on a Map value.
+ *
+ * @group Collection
+ */
+export interface MapExcessPropertyIssue {
+    readonly kind: "ExcessProperty";
+    readonly key: string | symbol;
+}
+/**
+ * An invalid key and its entry index in a {@link map}.
+ *
+ * @group Collection
+ */
+export type MapKeyIssue<Error extends TypeError> = Error extends TypeError ? {
+    readonly kind: "Key";
+    readonly index: number;
+    readonly key: unknown;
+    readonly error: Error;
+} : never;
+/**
+ * An invalid value and its entry index in a {@link map}.
+ *
+ * @group Collection
+ */
+export type MapValueIssue<Error extends TypeError> = Error extends TypeError ? {
+    readonly kind: "Value";
+    readonly index: number;
+    readonly key: unknown;
+    readonly error: Error;
+} : never;
+/**
+ * Two {@link map} keys that decode to the same output key.
+ *
+ * @group Collection
+ */
+export interface MapKeyCollisionIssue {
+    readonly kind: "Collision";
+    readonly index: number;
+    readonly key: unknown;
+    readonly previousIndex: number;
+    readonly previousKey: unknown;
+    readonly outputKey: unknown;
+}
+type MapStructuralIssue = MapExcessPropertyIssue | MapKeyCollisionIssue;
+/**
+ * An invalid key, value, or structure in a {@link map}.
+ *
+ * @group Collection
+ */
+export type MapIssue<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends MapStructuralIssue = MapKeyCollisionIssue> = MapKeyIssue<KeyError> | MapValueIssue<ValueError> | StructuralIssue;
+/**
+ * Entry errors returned by a {@link map} operation.
+ *
+ * @group Collection
+ */
+export type MapEntriesError<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends MapStructuralIssue = MapKeyCollisionIssue> = [KeyError | ValueError | StructuralIssue] extends [never] ? never : MapEntriesErrorValue<KeyError, ValueError, StructuralIssue>;
+interface MapEntriesErrorValue<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends MapStructuralIssue> extends TypeError<"Map"> {
+    readonly reason: {
+        readonly kind: "Entries";
+        readonly issues: NonEmptyReadonlyArray<MapKeyIssue<KeyError> | MapValueIssue<ValueError> | StructuralIssue>;
+    };
+}
 /**
  * Tuple {@link Type}.
  *
@@ -3514,20 +3991,24 @@ interface SetItemsErrorValue<Error extends TypeError, IncludeStructuralIssues ex
  *
  * A Tuple must be recognized by `Array.isArray`, have exactly the declared
  * length, be dense, and have no own properties other than `length` and the
- * indexed data properties for its elements. Array subclasses, custom-prototype
- * arrays, and foreign-realm arrays are accepted when their own data
- * representation is valid. Sparse arrays, accessor elements, and excess
- * properties are rejected.
+ * indexed data properties for its elements. Foreign-realm arrays are accepted
+ * when their own data representation is valid. Sparse arrays, accessor
+ * elements, and excess properties are rejected.
  *
  * ### Example
  *
  * ```ts
- * import { Int64FromInt64String, String, tuple } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   Int64FromInt64String,
+ *   String,
+ *   tuple,
+ * } from "@evolu/common";
  *
  * const Entry = tuple(String, Int64FromInt64String);
  *
- * expectOk(Entry.fromUnknown(["count", "1"]), ["count", 1n]);
- * expectOk(Entry.from.parent(["count", "1"]), ["count", 1n]);
+ * assertOk(Entry.fromUnknown(["count", "1"]), ["count", 1n]);
+ * assertOk(Entry.from.parent(["count", "1"]), ["count", 1n]);
  * ```
  *
  * @group Collection
@@ -3716,11 +4197,12 @@ type PlainObjectError = ObjectError<Readonly<Record<never, never>>, ObjectProper
  * A {@link Type} for readonly plain objects with unknown property values.
  *
  * `Object` is the runtime counterpart of a `Readonly<Record<string, unknown>>`
- * data boundary. Its realm-neutral prototype rule accepts a `null` prototype or
- * an immediate root prototype whose own prototype is `null`. Every own property
- * must have a string key and be an enumerable data property. It rejects
- * ordinary class instances, deeper prototype chains, accessors, non-enumerable
- * properties, and symbol properties without reading their values.
+ * data boundary. Its prototype rule uses the realm-neutral structural heuristic
+ * described by {@link isPlainObject}. A matching custom root prototype can be
+ * classified as plain; other custom prototypes and class instances are
+ * rejected. Every own property must have a string key and be an enumerable data
+ * property. Accessors, non-enumerable properties, and symbol properties are
+ * rejected without reading their values.
  *
  * Use {@link object} when property names are fixed, {@link record} when keys and
  * values have their own Types, and {@link instanceOf} when an instance belongs
@@ -3746,12 +4228,13 @@ export { _Object as Object };
  * By default, validation returns the first issue. Pass `{ errors: "all" }` to
  * collect issues across the whole Record.
  *
- * A Record must have a `null` prototype or an immediate root prototype whose
- * own prototype is `null`. Ordinary class instances and deeper prototype chains
- * are rejected. Every own property must be an enumerable data property whose
- * key and value satisfy their Types. When decoding or encoding changes an
- * entry, the constructed Record uses a `null` prototype so keys such as
- * `__proto__` remain ordinary data.
+ * A Record must satisfy the realm-neutral structural heuristic described by
+ * {@link isPlainObject}. A matching custom root prototype can be classified as
+ * plain; other custom prototypes and class instances are rejected. Every own
+ * property must be an enumerable data property whose key and value satisfy
+ * their Types. When decoding or encoding changes an entry, the constructed
+ * Record uses a `null` prototype so keys such as `__proto__` remain ordinary
+ * data.
  *
  * If transformed keys collide, validation fails instead of overwriting an
  * entry.
@@ -3760,6 +4243,8 @@ export { _Object as Object };
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   Int64FromInt64String,
  *   String,
  *   record,
@@ -3775,21 +4260,22 @@ export { _Object as Object };
  *   grace: "20",
  * });
  *
- * expectOk(scoresFromUnknown, { ada: 10n, grace: 20n });
+ * assertOk(scoresFromUnknown, { ada: 10n, grace: 20n });
  *
  * // Validate keys and values with their root Types.
  * const scoresInput = ScoresByUser.parent.fromUnknown({
  *   ada: "10",
  *   grace: "20",
  * });
- * expectOk(scoresInput, { ada: "10", grace: "20" });
+ * assertOk(scoresInput, { ada: "10", grace: "20" });
  *
  * // Run the remaining key and value stages.
  * const scoresFromInput = ScoresByUser.from.parent(scoresInput.value);
  *
- * expectOk(scoresFromInput, { ada: 10n, grace: 20n });
- * expectTypeOf(scoresFromInput.value).toEqualTypeOf<
- *   Readonly<Partial<Record<string, Int64>>>
+ * assertOk(scoresFromInput, { ada: 10n, grace: 20n });
+ * assertType<
+ *   Readonly<Partial<Record<string, Int64>>>,
+ *   typeof scoresFromInput.value
  * >();
  * ```
  *
@@ -3798,34 +4284,64 @@ export { _Object as Object };
  * as a Record entry:
  *
  * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertTrue,
+ *   trySync,
+ * } from "@evolu/common";
+ *
  * type Values = Partial<Record<"toString", number>>;
  * const values: Values = {};
  *
  * // TypeScript treats the inherited function as `number | undefined`.
  * const value: number | undefined = values.toString;
+ * const valueType = typeof value;
  *
- * expect(typeof value).toBe("function");
- * expect(() => {
- *   if (value !== undefined) value.toFixed();
- * }).toThrow(TypeError);
+ * assertEqual(valueType, "function");
+ * const called = trySync(
+ *   () => {
+ *     if (value !== undefined) value.toFixed(0);
+ *   },
+ *   (error) => error,
+ * );
+ * assertErr(called);
+ * assertTrue(called.error instanceof TypeError);
  * ```
  *
  * Evolu Record Outputs use the same TypeScript Record representation.
  *
  * ```ts
- * import { Number, literal, record } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertTrue,
+ *   trySync,
+ *   Number,
+ *   literal,
+ *   record,
+ *   type Data,
+ * } from "@evolu/common";
  *
  * const Values = record(literal("toString"), Number);
  * const result = Values.fromUnknown({});
+ * const emptyValues: Data = {};
  *
- * expectOk(result, {});
+ * assertOk(result, emptyValues);
  *
  * const value: number | undefined = result.value.toString;
+ * const valueType = typeof value;
  *
- * expect(typeof value).toBe("function");
- * expect(() => {
- *   if (value !== undefined) value.toFixed();
- * }).toThrow(TypeError);
+ * assertEqual(valueType, "function");
+ * const called = trySync(
+ *   () => {
+ *     if (value !== undefined) value.toFixed(0);
+ *   },
+ *   (error) => error,
+ * );
+ * assertErr(called);
+ * assertTrue(called.error instanceof TypeError);
  * ```
  *
  * In other words, treat Record Outputs as string-keyed data rather than calling
@@ -3992,7 +4508,13 @@ export interface OptionalProperty<T extends TypeNode> {
  * ### Example
  *
  * ```ts
- * import { String, object, optional, undefinedOr } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   String,
+ *   object,
+ *   optional,
+ *   undefinedOr,
+ * } from "@evolu/common";
  *
  * const User = object({
  *   name: String,
@@ -4000,8 +4522,8 @@ export interface OptionalProperty<T extends TypeNode> {
  *   preferredName: optional(undefinedOr(String)),
  * });
  *
- * expectOk(User.fromUnknown({ name: "Ada" }), { name: "Ada" });
- * expectOk(User.fromUnknown({ name: "Ada", preferredName: undefined }), {
+ * assertOk(User.fromUnknown({ name: "Ada" }), { name: "Ada" });
+ * assertOk(User.fromUnknown({ name: "Ada", preferredName: undefined }), {
  *   name: "Ada",
  *   preferredName: undefined,
  * });
@@ -4035,10 +4557,11 @@ type ObjectProperty = ObjectProps[string];
  * required properties nor make optional properties present. This keeps Outputs
  * valid after ordinary object spread restores `Object.prototype`.
  *
- * A `null` prototype or an immediate root prototype whose own prototype is
- * `null` is accepted. Ordinary class instances, deeper prototype chains,
- * accessors, and non-enumerable properties are rejected. Use {@link instanceOf}
- * for class Outputs or {@link transform} to decode instances into plain data.
+ * The prototype must satisfy the realm-neutral structural heuristic described
+ * by {@link isPlainObject}. A matching custom root prototype can be classified
+ * as plain; other custom prototypes, class instances, accessors, and
+ * non-enumerable properties are rejected. Use {@link instanceOf} for class
+ * Outputs or {@link transform} to decode instances into plain data.
  *
  * When decoding changes no property, it preserves the input. When decoding or
  * encoding changes a property, it constructs an object with a `null`
@@ -4051,6 +4574,8 @@ type ObjectProperty = ObjectProps[string];
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   Int64FromInt64String,
  *   String,
  *   object,
@@ -4069,20 +4594,20 @@ type ObjectProperty = ObjectProps[string];
  *   loginCount: "42",
  * });
  *
- * expectOk(userFromUnknown, { name: "Ada", loginCount: 42n });
+ * assertOk(userFromUnknown, { name: "Ada", loginCount: 42n });
  *
  * // Validate the object and root property Types.
  * const userInput = User.parent.fromUnknown({
  *   name: "Ada",
  *   loginCount: "42",
  * });
- * expectOk(userInput, { name: "Ada", loginCount: "42" });
+ * assertOk(userInput, { name: "Ada", loginCount: "42" });
  *
  * // Run the remaining property stages.
  * const userFromInput = User.from.parent(userInput.value);
  *
- * expectOk(userFromInput, { name: "Ada", loginCount: 42n });
- * expectTypeOf(userFromInput.value).toExtend<User>();
+ * assertOk(userFromInput, { name: "Ada", loginCount: 42n });
+ * assertType<typeof User.Output, typeof userFromInput.value>();
  * ```
  *
  * Note that TypeScript does not model an object's runtime prototype. This can
@@ -4090,38 +4615,68 @@ type ObjectProperty = ObjectProps[string];
  * as an object property:
  *
  * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertTrue,
+ *   trySync,
+ * } from "@evolu/common";
+ *
  * interface Values {
  *   readonly toString?: number;
  * }
  *
- * const nullPrototypeValues = globalThis.Object.create(null) as Values;
+ * const nullPrototypeValues = Object.create(null) as Values;
  * const values = { ...nullPrototypeValues };
  *
  * // TypeScript treats the inherited function as `number | undefined`.
  * const value: number | undefined = values.toString;
+ * const valueType = typeof value;
  *
- * expect(typeof value).toBe("function");
- * expect(() => {
- *   if (value !== undefined) value.toFixed();
- * }).toThrow(TypeError);
+ * assertEqual(valueType, "function");
+ * const called = trySync(
+ *   () => {
+ *     if (value !== undefined) value.toFixed(0);
+ *   },
+ *   (error) => error,
+ * );
+ * assertErr(called);
+ * assertTrue(called.error instanceof TypeError);
  * ```
  *
  * Evolu Object Outputs use the same TypeScript object representation.
  *
  * ```ts
- * import { Number, object, optional } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertTrue,
+ *   trySync,
+ *   Number,
+ *   object,
+ *   optional,
+ *   type Data,
+ * } from "@evolu/common";
  *
  * const Values = object({ toString: optional(Number) });
  * const result = Values.fromUnknown({});
+ * const emptyValues: Data = {};
  *
- * expectOk(result, {});
+ * assertOk(result, emptyValues);
  *
  * const value: number | undefined = result.value.toString;
+ * const valueType = typeof value;
  *
- * expect(typeof value).toBe("function");
- * expect(() => {
- *   if (value !== undefined) value.toFixed();
- * }).toThrow(TypeError);
+ * assertEqual(valueType, "function");
+ * const called = trySync(
+ *   () => {
+ *     if (value !== undefined) value.toFixed(0);
+ *   },
+ *   (error) => error,
+ * );
+ * assertErr(called);
+ * assertTrue(called.error instanceof TypeError);
  * ```
  *
  * In other words, treat Object Outputs as data rather than calling inherited
@@ -4130,7 +4685,36 @@ type ObjectProperty = ObjectProps[string];
  * @group Objects
  */
 export declare function object<const Props extends ObjectProps>(props: Props, ...validation: [ObjectValidationError<Props>] extends [never] ? [] : [ValidationFailure<ObjectValidationError<Props>>]): StrictObjectType<Props>;
-/** Creates an Object Type with additional record properties. */
+/**
+ * Creates an Object Type with additional record properties.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertOk,
+ *   assertType,
+ *   String,
+ *   object,
+ *   record,
+ * } from "@evolu/common";
+ *
+ * const RequestHeaders = object(
+ *   { authorization: String },
+ *   record(String, String),
+ * );
+ * const result = RequestHeaders.fromUnknown({
+ *   authorization: "Bearer token",
+ *   "x-request-id": "request-1",
+ * });
+ *
+ * assertOk(result, {
+ *   authorization: "Bearer token",
+ *   "x-request-id": "request-1",
+ * });
+ * assertType<string | undefined, (typeof result.value)["x-request-id"]>();
+ * ```
+ */
 export declare function object<const Props extends ObjectProps, const Rest extends RecordTypeNode & ConcreteTypeNode>(props: Props, record: Rest, ...validation: [
     ObjectValidationError<Props> | ObjectRecordValidationError<Props, Rest>
 ] extends [never] ? [] : [
@@ -4272,12 +4856,10 @@ export interface ObjectNotObjectError extends TypeError<"Object"> {
  * An error returned when an {@link object} input falls outside its supported
  * plain-object prototype boundary.
  *
- * Object Types accept a `null` prototype or a prototype whose own prototype is
- * `null`. This includes ordinary and cross-realm plain objects as well as
- * objects created from an immediate root prototype. Arrays, JavaScript built-in
- * objects, class instances, and objects with deeper custom prototype chains
- * return this error instead of having their prototype or inherited state
- * discarded. `reason.value` is the rejected object.
+ * Object Types use the realm-neutral structural heuristic described by
+ * {@link isPlainObject}. Values that do not satisfy it return this error instead
+ * of having their prototype or inherited state discarded. `reason.value` is the
+ * rejected object.
  *
  * @group Objects
  */
@@ -4354,13 +4936,20 @@ type ObjectRestFromParentError<Rest extends ObjectRecordTypeNode | undefined> =
  * ### Example
  *
  * ```ts
- * import { PositiveInt, String, partial } from "@evolu/common";
+ * import {
+ *   assertFalse,
+ *   assertOk,
+ *   PositiveInt,
+ *   String,
+ *   partial,
+ * } from "@evolu/common";
  *
  * const PartialUser = partial({ name: String, age: PositiveInt });
+ * const emptyPartialUser: typeof PartialUser.Output = {};
  *
- * expectOk(PartialUser.fromUnknown({}), {});
- * expectOk(PartialUser.fromUnknown({ name: "Ada" }), { name: "Ada" });
- * expect(PartialUser.fromUnknown({ age: -1 }).ok).toBe(false);
+ * assertOk(PartialUser.fromUnknown({}), emptyPartialUser);
+ * assertOk(PartialUser.fromUnknown({ name: "Ada" }), { name: "Ada" });
+ * assertFalse(PartialUser.fromUnknown({ age: -1 }).ok);
  * ```
  *
  * @group Objects
@@ -4385,15 +4974,20 @@ export type PartialObjectProps<Props extends ObjectProps> = {
  * ### Example
  *
  * ```ts
- * import { String, nullOr, nullableToOptional } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   String,
+ *   nullOr,
+ *   nullableToOptional,
+ * } from "@evolu/common";
  *
  * const User = nullableToOptional({
  *   name: String,
  *   nickname: nullOr(String),
  * });
  *
- * expectOk(User.fromUnknown({ name: "Ada" }), { name: "Ada" });
- * expectOk(User.fromUnknown({ name: "Ada", nickname: null }), {
+ * assertOk(User.fromUnknown({ name: "Ada" }), { name: "Ada" });
+ * assertOk(User.fromUnknown({ name: "Ada", nickname: null }), {
  *   name: "Ada",
  *   nickname: null,
  * });
@@ -4417,12 +5011,12 @@ export type NullableToOptionalProps<Props extends ObjectProps> = {
  * ### Example
  *
  * ```ts
- * import { String, object, omit } from "@evolu/common";
+ * import { assertOk, String, object, omit } from "@evolu/common";
  *
  * const User = object({ name: String, password: String });
  * const PublicUser = omit(User, "password");
  *
- * expectOk(PublicUser.fromUnknown({ name: "Ada" }), { name: "Ada" });
+ * assertOk(PublicUser.fromUnknown({ name: "Ada" }), { name: "Ada" });
  * ```
  *
  * @group Objects
@@ -4445,6 +5039,7 @@ type OmitKeyConcreteTypeError = CompileTimeError<"Type", "Each omitted key must
  *
  * ```ts
  * import {
+ *   assertOk,
  *   NonNegativeInt,
  *   String,
  *   object,
@@ -4462,8 +5057,8 @@ type OmitKeyConcreteTypeError = CompileTimeError<"Type", "Each omitted key must
  *   value: { timestamp: 42 },
  * });
  *
- * expectOk(validated, { ok: true, value: { timestamp: 42 } });
- * expectOk(validated.value, { timestamp: 42 });
+ * assertOk(validated, { ok: true, value: { timestamp: 42 } });
+ * assertOk(validated.value, { timestamp: 42 });
  * ```
  *
  * @group Results
@@ -4507,24 +5102,84 @@ export type UnknownResult = typeof UnknownResult.Output;
  * ### Example
  *
  * ```ts
- * import { String, typed } from "@evolu/common";
+ * import {
+ *   assertFalse,
+ *   assertOk,
+ *   assertType,
+ *   String,
+ *   discriminatedUnion,
+ *   typed,
+ * } from "@evolu/common";
+ *
+ * const Loading = typed("Loading");
+ * const Loaded = typed("Loaded", { value: String });
+ * const State = discriminatedUnion(Loading, Loaded);
+ *
+ * assertOk(State.fromUnknown({ type: "Loading" }), { type: "Loading" });
+ * assertOk(State.fromUnknown({ type: "Loaded", value: "Evolu" }), {
+ *   type: "Loaded",
+ *   value: "Evolu",
+ * });
+ * assertFalse(Loading.is({ type: "Loading", progress: 1 }));
+ * assertType<
+ *   true,
+ *   typeof Loading.Output extends { readonly type: "Loading" }
+ *     ? true
+ *     : false
+ * >();
+ * ```
+ *
+ * @group Discriminated unions
+ */
+export declare function typed<const Tag extends TypeName>(tag: ValidateTypedTag<Tag>): TypedType<Tag>;
+/**
+ * Creates a Tagged Object Type with declared properties.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertOk, String, typed } from "@evolu/common";
  *
  * const Pending = typed("Pending", {
  *   label: String,
  * });
  *
- * expectOk(Pending.fromUnknown({ type: "Pending", label: "Waiting" }), {
+ * assertOk(Pending.fromUnknown({ type: "Pending", label: "Waiting" }), {
  *   type: "Pending",
  *   label: "Waiting",
  * });
  * ```
- *
- * @group Discriminated unions
  */
-export declare function typed<const Tag extends TypeName>(tag: ValidateTypedTag<Tag>): TypedType<Tag>;
-/** Creates a Tagged Object Type with declared properties. */
 export declare function typed<const Tag extends TypeName, const Props extends ObjectProps>(tag: ValidateTypedTag<Tag>, props: Props, ...validation: [TypedValidationError<Props>] extends [never] ? [] : [ValidationFailure<TypedValidationError<Props>>]): TypedType<Tag, Props>;
-/** Creates a Tagged Object Type with additional record properties. */
+/**
+ * Creates a Tagged Object Type with additional record properties.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertOk,
+ *   assertType,
+ *   String,
+ *   record,
+ *   typed,
+ * } from "@evolu/common";
+ *
+ * const Open = typed("Open", { label: String }, record(String, String));
+ * const result = Open.fromUnknown({
+ *   type: "Open",
+ *   label: "Ready",
+ *   note: "Connected",
+ * });
+ *
+ * assertOk(result, {
+ *   type: "Open",
+ *   label: "Ready",
+ *   note: "Connected",
+ * });
+ * assertType<string | undefined, typeof result.value.note>();
+ * ```
+ */
 export declare function typed<const Tag extends TypeName, const Props extends ObjectProps, const Rest extends RecordTypeNode & ConcreteTypeNode>(tag: ValidateTypedTag<Tag>, props: Props, record: Rest, ...validation: [
     TypedValidationError<Props> | ObjectRecordValidationError<TypedProps<Tag, Props>, Rest>
 ] extends [never] ? [] : [
@@ -4549,7 +5204,14 @@ export declare function typed<const Tag extends TypeName, const Props extends Ob
  * ### 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 extends Typed<"User"> {
  *   readonly id: string;
@@ -4564,8 +5226,8 @@ export declare function typed<const Tag extends TypeName, const Props extends Ob
  *   readonly id: string;
  * }
  *
- * expectOk(getUser("user-1"), { type: "User", id: "user-1" });
- * expectErr(getUser("missing"), { type: "UserNotFound", id: "missing" });
+ * assertOk(getUser("user-1"), { type: "User", id: "user-1" });
+ * assertErr(getUser("missing"), { type: "UserNotFound", id: "missing" });
  * ```
  *
  * @group Discriminated unions
@@ -4584,6 +5246,7 @@ export interface Typed<Tag extends TypeName> {
  *
  * ```ts
  * import {
+ *   assertType,
  *   String,
  *   discriminatedUnion,
  *   typed,
@@ -4597,10 +5260,10 @@ export interface Typed<Tag extends TypeName> {
  *
  * type CreateMessage = ExtractTyped<Message, "Create">;
  *
- * expectTypeOf<CreateMessage>().toEqualTypeOf<typeof Create.Output>();
+ * assertType<typeof Create.Output, CreateMessage>();
  *
  * // @ts-expect-error "Cretae" is not a Message type.
- * type Typo = ExtractTyped<Message, "Cretae">;
+ * type _Typo = ExtractTyped<Message, "Cretae">;
  * ```
  *
  * @group Discriminated unions
@@ -4632,7 +5295,7 @@ type TypedTypePropertyError = CompileTimeError<"Type", 'Additional properties mu
  * ### Example
  *
  * ```ts
- * import { String, nextResult, typed } from "@evolu/common";
+ * import { assertEqual, String, nextResult, typed } from "@evolu/common";
  *
  * const StringNextResult = nextResult(
  *   String,
@@ -4650,19 +5313,21 @@ type TypedTypePropertyError = CompileTimeError<"Type", 'Additional properties mu
  *   return `Error: ${result.error.message}`;
  * };
  *
- * expect(describeNext({ ok: true, value: "item" })).toBe("Value: item");
- * expect(
+ * assertEqual(describeNext({ ok: true, value: "item" }), "Value: item");
+ * assertEqual(
  *   describeNext({
  *     ok: false,
  *     error: { type: "Done", done: "complete" },
  *   }),
- * ).toBe("Done: complete");
- * expect(
+ *   "Done: complete",
+ * );
+ * assertEqual(
  *   describeNext({
  *     ok: false,
  *     error: { type: "ReadFailed", message: "Offline" },
  *   }),
- * ).toBe("Error: Offline");
+ *   "Error: Offline",
+ * );
  * ```
  *
  * @group Results
@@ -4708,13 +5373,18 @@ export type UnknownNextResult = typeof UnknownNextResult.Output;
  * ### Example
  *
  * ```ts
- * import { String, discriminatedUnion, typed } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   String,
+ *   discriminatedUnion,
+ *   typed,
+ * } from "@evolu/common";
  *
  * const Created = typed("Created", { id: String });
  * const Deleted = typed("Deleted", { id: String });
  * const Event = discriminatedUnion(Created, Deleted);
  *
- * expectOk(Event.fromUnknown({ type: "Created", id: "id" }), {
+ * assertOk(Event.fromUnknown({ type: "Created", id: "id" }), {
  *   type: "Created",
  *   id: "id",
  * });
@@ -4730,6 +5400,7 @@ export declare function discriminatedUnion<const Members extends DiscriminatedUn
  *
  * ```ts
  * import {
+ *   assertOk,
  *   Number,
  *   String,
  *   discriminatedUnion,
@@ -4741,11 +5412,11 @@ export declare function discriminatedUnion<const Members extends DiscriminatedUn
  * const Removed = object({ kind: literal("removed"), id: Number });
  * const Event = discriminatedUnion("kind", Added, Removed);
  *
- * expectOk(Event.fromUnknown({ kind: "added", value: "Evolu" }), {
+ * assertOk(Event.fromUnknown({ kind: "added", value: "Evolu" }), {
  *   kind: "added",
  *   value: "Evolu",
  * });
- * expectOk(Event.fromUnknown({ kind: "removed", id: 1 }), {
+ * assertOk(Event.fromUnknown({ kind: "removed", id: 1 }), {
  *   kind: "removed",
  *   id: 1,
  * });
@@ -4887,15 +5558,18 @@ type DiscriminatedUnionDuplicateValueError<Key extends string, Expected extends
  *
  * The definition must return one concrete non-Lazy Type. Use {@link union} for
  * alternatives. Every recursive Lazy reference must be nested behind an
- * {@link object}, {@link array}, {@link tuple}, {@link record}, or {@link set}
- * structural boundary. Union does not guard recursion because it passes the
- * same value to every member. Lazy defers schema construction; it does not make
- * cyclic runtime object graphs or arbitrarily deep values stack-safe.
+ * {@link object}, {@link array}, {@link tuple}, {@link record}, {@link set}, or
+ * {@link map} structural boundary. Union does not guard recursion because it
+ * passes the same value to every member. Lazy defers schema construction; it
+ * does not make cyclic runtime object graphs or arbitrarily deep values
+ * stack-safe.
  *
  * ### Example
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   String,
  *   array,
  *   lazy,
@@ -4925,11 +5599,11 @@ type DiscriminatedUnionDuplicateValueError<Key extends string, Expected extends
  *   children: [{ value: "leaf", children: [] }],
  * });
  *
- * expectOk(result, {
+ * assertOk(result, {
  *   value: "root",
  *   children: [{ value: "leaf", children: [] }],
  * });
- * expectTypeOf(result.value).toEqualTypeOf<Tree>();
+ * assertType<Tree, typeof result.value>();
  * ```
  *
  * @group Recursive
@@ -4959,6 +5633,166 @@ export interface LazyType<in out Input, in out Output, in out FromError extends
 }
 type ValidateLazyTarget<Target extends ConcreteTypeNode> = IsUnion<Target> extends false ? Target : LazyTargetConcreteTypeError;
 type LazyTargetConcreteTypeError = CompileTimeError<"Type", "Lazy Type definition must return one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
+/**
+ * Evolu's recursive platform-independent structured-cloneable data domain.
+ *
+ * Data is intentionally limited to values supported by the structured clone
+ * algorithm, so it can be sent through APIs such as worker `postMessage`. It
+ * includes supported JavaScript primitives and the runtime representations
+ * defined by {@link array}, {@link Object}, {@link set}, {@link map}, {@link Date},
+ * and {@link Uint8Array}. Array elements, Object properties, Set elements, and
+ * Map keys and values must also be Data. Cyclic and shared data graphs are
+ * supported. Raw {@link ArrayBuffer} values are excluded; represent bytes with a
+ * Uint8Array.
+ *
+ * Functions, arbitrary class instances, and other behavioral objects are not
+ * Data. The structural representations follow the corresponding Evolu Type
+ * rules. As with every Type operation, classification assumes trusted
+ * application code or audited dependencies; it is not a security boundary for
+ * adversarial Proxies or forged built-in object tags.
+ *
+ * TypeScript cannot express dense Arrays, exact property descriptors, object
+ * prototypes, or the absence of custom properties on built-ins. Use the runtime
+ * {@link Data} Type when a value crosses an unknown boundary.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertOk, assertSame, assertType, Data } from "@evolu/common";
+ *
+ * const value: unknown = {
+ *   user: { name: "Ada" },
+ *   scores: new Map([["logic", 100]]),
+ *   roles: new Set(["admin"]),
+ * };
+ * const result = Data.fromUnknown(value);
+ *
+ * assertOk(result);
+ * assertSame(result.value, value);
+ * assertType<Data, typeof result.value>();
+ * ```
+ *
+ * @group Base
+ */
+export type Data = undefined | null | string | number | bigint | boolean | ReadonlyArray<Data> | {
+    readonly [key: string]: Data;
+} | ReadonlySet<Data> | ReadonlyMap<Data, Data> | globalThis.Date | globalThis.Uint8Array;
+/**
+ * Returns whether a TypeScript type consists only of {@link Data}.
+ *
+ * Unlike `Value extends Data`, this recursively checks the declared properties
+ * of object types, so ordinary interfaces do not need a string index signature.
+ * This is a compile-time approximation of the Data domain; representation
+ * details such as prototypes and property descriptors still require the runtime
+ * {@link Data} Type.
+ *
+ * Recursive object types are supported.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertType, type IsData } from "@evolu/common";
+ *
+ * interface User {
+ *   readonly name: string;
+ *   readonly roles: ReadonlySet<string>;
+ * }
+ *
+ * interface Service {
+ *   readonly run: () => void;
+ * }
+ *
+ * assertType<true, IsData<User>>();
+ * assertType<false, IsData<Service>>();
+ * ```
+ *
+ * @group Base
+ */
+export type IsData<Value> = IsDataValue<Value, readonly []>;
+type IsDataValue<Value, Seen extends ReadonlyArray<unknown>> = IsAny<Value> extends true ? false : unknown extends Value ? false : [Value] extends [never] ? true : false extends (Value extends unknown ? IsDataMember<Value, Seen> : never) ? false : true;
+type IsAny<Value> = 0 extends 1 & Value ? true : false;
+type IsDataMember<Value, Seen extends ReadonlyArray<unknown>> = IsSameType<Value, object> extends true ? false : IncludesSameType<Seen, Value> extends true ? true : Value extends void | null | string | number | bigint | boolean ? true : Value extends globalThis.Function ? false : Value extends globalThis.Date | globalThis.Uint8Array ? true : Value extends ReadonlyArray<infer Element> ? IsDataValue<Element, readonly [...Seen, Value]> : Value extends ReadonlySet<infer Element> ? IsDataValue<Element, readonly [...Seen, Value]> : Value extends ReadonlyMap<infer Key, infer MapValue> ? IsDataValue<Key | MapValue, readonly [...Seen, Value]> : Value extends object ? Extract<keyof Value, symbol> extends never ? IsDataObject<Value, readonly [...Seen, Value]> : false : false;
+type IsDataObject<Value extends object, Seen extends ReadonlyArray<unknown>> = [
+    keyof Value
+] extends [never] ? false : false extends {
+    [Key in keyof Value]-?: IsDataValue<Value[Key], Seen>;
+}[keyof Value] ? false : true;
+type IncludesSameType<Values extends ReadonlyArray<unknown>, Value> = Values extends readonly [infer First, ...infer Rest] ? IsSameType<First, Value> extends true ? true : IncludesSameType<Rest, Value> : false;
+/**
+ * One issue found while validating a candidate as {@link Data}.
+ *
+ * @group Base
+ */
+export type DataIssue = {
+    readonly kind: "InvalidType";
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly value: unknown;
+} | {
+    readonly kind: "UnexpectedPrototype";
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly container: "Object";
+    readonly value: object;
+} | {
+    readonly kind: "Accessor";
+    readonly path: ReadonlyArray<PropertyKey>;
+} | {
+    readonly kind: "NonEnumerable";
+    readonly path: ReadonlyArray<PropertyKey>;
+} | {
+    readonly kind: "SymbolProperty";
+    readonly path: ReadonlyArray<PropertyKey>;
+} | {
+    readonly kind: "Hole";
+    readonly path: ReadonlyArray<PropertyKey>;
+} | {
+    readonly kind: "InvalidUint8Array";
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly value: globalThis.Uint8Array;
+} | {
+    readonly kind: "ExcessProperty";
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly container: "Array" | "Set" | "Map";
+};
+/**
+ * An error containing one or more issues found while validating a candidate as
+ * {@link Data}.
+ *
+ * @group Base
+ */
+export interface DataError extends TypeError<"Data"> {
+    readonly reason: {
+        readonly kind: "Issues";
+        readonly issues: NonEmptyReadonlyArray<DataIssue>;
+    };
+}
+/**
+ * The root {@link Type} for Evolu {@link Data}.
+ *
+ * @group Base
+ */
+export interface DataType extends Type<"Data", Data, Data, DataError, null, DataError, never, Data> {
+}
+/**
+ * Root Type for {@link Data} values.
+ *
+ * Validation is iterative and preserves the input identity. Cyclic and shared
+ * data graphs are valid.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertOk, assertTrue, Data } from "@evolu/common";
+ *
+ * const value = new Map([["count", 1]]);
+ * const result = Data.fromUnknown(value);
+ *
+ * assertOk(result, value);
+ * assertTrue(Data.is(result.value));
+ * ```
+ *
+ * @group Base
+ */
+export declare const Data: DataType;
 /**
  * A candidate JSON value before exact runtime validation.
  *
@@ -5086,7 +5920,12 @@ export interface JsonError extends TypeError<"Json"> {
  * ### Example
  *
  * ```ts
- * import { JsonValue, type JsonValueInput } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   assertType,
+ *   JsonValue,
+ *   type JsonValueInput,
+ * } from "@evolu/common";
  *
  * const input: JsonValueInput = {
  *   name: "Ada",
@@ -5094,8 +5933,8 @@ export interface JsonError extends TypeError<"Json"> {
  * };
  * const result = JsonValue.fromUnknown(input);
  *
- * expectOk(result, input);
- * expectTypeOf(result.value).toEqualTypeOf<JsonValue>();
+ * assertOk(result, input);
+ * assertType<JsonValue, typeof result.value>();
  * ```
  *
  * @group JSON
@@ -5130,11 +5969,11 @@ export type Json = typeof Json.Output;
  * ### Example
  *
  * ```ts
- * import { Json, jsonToJsonValue } from "@evolu/common";
+ * import { assertEqual, Json, jsonToJsonValue } from "@evolu/common";
  *
  * const value = jsonToJsonValue(Json.orThrow('{"name":"Ada"}'));
  *
- * expect(value).toEqual({ name: "Ada" });
+ * assertEqual(value, { name: "Ada" });
  * ```
  *
  * @group JSON
@@ -5146,11 +5985,15 @@ export declare const jsonToJsonValue: (value: Json) => JsonValue;
  * ### Example
  *
  * ```ts
- * import { jsonValueToJson, type JsonValue } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   jsonValueToJson,
+ *   type JsonValue,
+ * } from "@evolu/common";
  *
  * const value: JsonValue = { name: "Ada" };
  *
- * expect(jsonValueToJson(value)).toBe('{"name":"Ada"}');
+ * assertEqual(jsonValueToJson(value), '{"name":"Ada"}');
  * ```
  *
  * @group JSON
@@ -5165,12 +6008,12 @@ export declare const jsonValueToJson: (value: JsonValue) => Json;
  * ### Example
  *
  * ```ts
- * import { JsonValueFromJson } from "@evolu/common";
+ * import { assertEqual, assertOk, JsonValueFromJson } from "@evolu/common";
  *
  * const result = JsonValueFromJson.fromUnknown('{ "name": "Ada" }');
  *
- * expectOk(result, { name: "Ada" });
- * expect(JsonValueFromJson.to(result.value)).toBe('{"name":"Ada"}');
+ * assertOk(result, { name: "Ada" });
+ * assertEqual(JsonValueFromJson.to(result.value), '{"name":"Ada"}');
  * ```
  *
  * @group JSON
@@ -5188,6 +6031,8 @@ export declare const JsonValueFromJson: TransformType<BrandType<Type<"String", s
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   Age,
  *   NonEmptyTrimmedString100,
  *   json,
@@ -5208,11 +6053,13 @@ export declare const JsonValueFromJson: TransformType<BrandType<Type<"String", s
  * const user = User.orThrow({ name: "Ada", age: 37 });
  * const userJson = userToUserJson(user);
  *
- * expectTypeOf(userJson).toEqualTypeOf<
- *   string & Brand<"Json"> & Brand<"UserJson">
+ * assertType<
+ *   string & Brand<"Json"> & Brand<"UserJson">,
+ *   typeof userJson
  * >();
- * expect(userJson).toBe('{"name":"Ada","age":37}');
- * expect(userJsonToUser(userJson)).toEqual(user);
+ * assertEqual(userJson, '{"name":"Ada","age":37}');
+ * assertEqual(UserJson.orThrow(userJson), userJson);
+ * assertEqual(userJsonToUser(userJson), user);
  * ```
  *
  * The supplied Type must have a JSON-compatible `CanonicalInput`. The branded
@@ -5229,10 +6076,9 @@ type IsJsonTypeCompatible<T extends TypeNode> = IsJsonCompatible<CanonicalInputO
 type IsJsonCompatible<Value, Seen extends ReadonlyArray<unknown> = readonly []> = IsExactlyJsonValue<Value> extends true ? true : false extends JsonCompatibleMember<Value, Seen> ? false : true;
 type IsExactlyJsonValue<Value> = IsSameType<Value, JsonValue>;
 type JsonCompatibleMember<Value, Seen extends ReadonlyArray<unknown>> = Value extends unknown ? IsJsonCompatibilityCycle<Value, Seen> extends true ? true : Value extends string | boolean | null ? true : Value extends number ? JsonNumberCompatible<Value> : Value extends ReadonlyArray<infer Item> ? Exclude<keyof Value, AllowedJsonArrayKeys<Value>> extends never ? IsJsonCompatible<Item, readonly [...Seen, Value]> : false : Value extends globalThis.Function ? false : Value extends object ? JsonObjectCompatible<Value, readonly [...Seen, Value]> : false : never;
-type AllowedJsonArrayKeys<Value extends ReadonlyArray<unknown>> = keyof ReadonlyArray<unknown> | (Value extends globalThis.Array<unknown> ? keyof globalThis.Array<unknown> : never) | JsonTupleIndexKeys<Value>;
-type JsonTupleIndexKeys<Value extends ReadonlyArray<unknown>> = Value extends readonly [...infer Elements] ? Exclude<keyof Elements, keyof globalThis.Array<unknown>> : never;
+type AllowedJsonArrayKeys<Value extends ReadonlyArray<unknown>> = keyof ReadonlyArray<unknown> | (Value extends Array<unknown> ? keyof Array<unknown> : never) | JsonTupleIndexKeys<Value>;
+type JsonTupleIndexKeys<Value extends ReadonlyArray<unknown>> = Value extends readonly [...infer Elements] ? Exclude<keyof Elements, keyof Array<unknown>> : never;
 type IsJsonCompatibilityCycle<Value, Seen extends ReadonlyArray<unknown>> = Seen extends readonly [infer Candidate, ...infer Rest] ? IsSameType<Value, Candidate> extends true ? true : IsJsonCompatibilityCycle<Value, Rest> : false;
-type IsSameType<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => (T extends B ? 1 : 2) ? (<T>() => T extends B ? 1 : 2) extends <T>() => (T extends A ? 1 : 2) ? true : false : false;
 type JsonNumberCompatible<Value extends number> = [Value] extends [FiniteNumber] ? true : [Value] extends [Brand<string>] ? false : number extends Value ? false : true;
 type JsonObjectCompatible<Value extends object, Seen extends ReadonlyArray<unknown>> = [keyof Value] extends [never] ? false : string extends keyof Value ? Exclude<keyof Value, string | number> extends never ? Value extends Readonly<Partial<Record<string, infer Item>>> ? IsJsonCompatible<Item, Seen> : false : false : false extends {
     readonly [Key in keyof Value]-?: Key extends string ? IsJsonCompatible<{} extends Pick<Value, Key> ? Required<Pick<Value, Key>>[Key] : Value[Key], Seen> : false;