@evolu/common 8.5.0 → 8.6.0

package/dist/src/Type.js

@@ -1,6 +1,4 @@
 /**
- * ## Intro
- *
  * Runtime validation with precise TypeScript types and structured errors.
  *
  * Evolu {@link Type} is a pure, synchronous codec for defining semantic domains.
@@ -49,6 +47,11 @@
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   Data,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
  *   Number,
  *   NonEmptyTrimmedString100,
  *   brand,
@@ -73,14 +76,15 @@
  * const Age = brand("Age", lessThan(200)(NonNegativeInt));
  * type Age = typeof Age.Output;
  *
- * expectTypeOf<Age>().toEqualTypeOf<
+ * assertType<
  *   number &
  *     Brand<"NonNaN"> &
  *     Brand<"Finite"> &
  *     Brand<"Int"> &
  *     Brand<"NonNegative"> &
  *     Brand<"LessThan200"> &
- *     Brand<"Age">
+ *     Brand<"Age">,
+ *   Age
  * >();
  *
  * const User = object({
@@ -92,12 +96,16 @@
  * const value: unknown = { name: "Ada", age: 37 };
  * const user = User.fromUnknown(value);
  *
- * expectOk(user, { name: "Ada", age: 37 });
- * expectTypeOf(user.value).toExtend<User>();
+ * assertOk(user, { name: "Ada", age: 37 });
+ * assertType<typeof User.Output, typeof user.value>();
  *
  * const invalidUser = User.fromUnknown({ name: "Ada", age: 37.5 });
  *
- * expectErr(invalidUser, {
+ * assertErr(invalidUser);
+ * // InferErrors includes every structured error User.fromUnknown can return.
+ * assertType<InferErrors<typeof User>, typeof invalidUser.error>();
+ * assertType(Data, invalidUser.error);
+ * assertEqual(invalidUser.error, {
  *   type: "Object",
  *   reason: {
  *     kind: "Properties",
@@ -106,22 +114,26 @@
  *     },
  *   },
  * });
- *
- * // InferErrors includes every structured error User.fromUnknown can return.
- * expectTypeOf(invalidUser.error).toEqualTypeOf<
- *   InferErrors<typeof User>
- * >();
  * ```
  *
  * A Type can format its structured errors into user-facing messages:
  *
  * ```ts
- * import { Age } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertType,
+ *   Data,
+ *   assertErr,
+ *   Age,
+ * } from "@evolu/common";
  *
  * const age = Age.fromUnknown(37.5);
  *
- * expectErr(age, { type: "Int", value: 37.5 });
- * expect(Age.formatError(age.error)).toBe(
+ * assertErr(age);
+ * assertType(Data, age.error);
+ * assertEqual(age.error, { type: "Int", value: 37.5 });
+ * assertEqual(
+ *   Age.formatError(age.error),
  *   "The value 37.5 must be a safe integer.",
  * );
  * ```
@@ -138,6 +150,8 @@
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   NonEmptyTrimmedString100,
  *   NonEmptyTrimmedString1000,
  *   object,
@@ -152,7 +166,7 @@
  *
  * // This is type-checked: Todo.from expects NonEmptyTrimmedString100.
  * const title = NonEmptyTrimmedString100.orThrow("Buy milk");
- * expectOk(Todo.from({ title }), { title });
+ * assertOk(Todo.from({ title }), { title });
  *
  * // Imagine the UI input component is changed to allow longer titles.
  * // TypeScript rejects the mismatch, so users never see a save error
@@ -170,13 +184,14 @@
  * );
  *
  * // No "not a string" or "not trimmed" errors: the input guarantees both.
- * expectTypeOf(validatedTitle).toEqualTypeOf<
+ * assertType<
  *   Result<
  *     NonEmptyTrimmedString100,
  *     MaxLengthError<100> | MinLengthError<1>
- *   >
+ *   >,
+ *   typeof validatedTitle
  * >();
- * expectOk(validatedTitle, "Buy milk");
+ * assertOk(validatedTitle, "Buy milk");
  * ```
  *
  * Evolu includes dozens of predefined Types and Type factories. Use Types such
@@ -203,6 +218,10 @@
  * cannot express. They are correctness checks, not defenses against malicious
  * code.
  *
+ * Evolu does not support subclassing native JavaScript objects. Such subclasses
+ * can be classified as their reported built-in representation, but their
+ * behavior is unspecified.
+ *
  * ## FAQ
  *
  * ### What does a Type represent?
@@ -378,16 +397,19 @@
  * unknown values, {@link object} defines a closed plain-object representation,
  * and {@link record} defines a plain-dictionary representation whose complete
  * set of own properties are its entries. Their realm-neutral plain-object rule
- * accepts a `null` prototype or an immediate root prototype whose own prototype
- * is `null`; ordinary class instances and deeper prototype chains are rejected.
- * Every property must be an enumerable data property; inherited members are not
- * entries, while accessors and hidden properties are invalid instead of being
- * invoked or ignored. {@link array} similarly defines a dense sequence whose
- * only own properties are `length` and its indexed data properties;
- * {@link tuple} applies the same representation rules with a fixed length and a
- * distinct Type for each position. Only an explicit {@link transform} changes
- * the representation. Consequently, `is` tests exact Output membership and `to`
- * stays total for valid Outputs.
+ * uses {@link isPlainObject}: it accepts a `null` prototype or an immediate root
+ * prototype with own `hasOwnProperty` and `isPrototypeOf` properties. A custom
+ * root prototype with the same shape can therefore be classified as plain;
+ * other custom prototypes and class instances are rejected. This heuristic
+ * assumes trusted JavaScript and is not a security boundary. Every property
+ * must be an enumerable data property; inherited members are not entries, while
+ * accessors and hidden properties are invalid instead of being invoked or
+ * ignored. {@link array} similarly defines a dense sequence whose only own
+ * properties are `length` and its indexed data properties; {@link tuple} applies
+ * the same representation rules with a fixed length and a distinct Type for
+ * each position. Only an explicit {@link transform} changes the representation.
+ * Consequently, `is` tests exact Output membership and `to` stays total for
+ * valid Outputs.
  *
  * ### Why is JsonValue stricter than JSON.stringify?
  *
@@ -434,7 +456,7 @@ import { wordlist } from "@scure/bip39/wordlists/english.js";
 import { createMutableArray, } from "./Array.js";
 import { assert, assertNonNullable } from "./Assert.js";
 import { identity } from "./Function.js";
-import { createMutableRecord } from "./Object.js";
+import { createMutableRecord, getObjectKind, isPlainObject } from "./Object.js";
 import { hasNodeBuffer } from "./Platform.js";
 import { err, flatMapResult, getOk, getOrNull, getOrThrow, ok, trySync, } from "./Result.js";
 import { safelyStringifyUnknownValue } from "./String.js";
@@ -471,33 +493,9 @@ const createCollectionRuntimeTypeIssues = (name, issuesKind, defaultFormatter, g
     });
 };
 const formatDefaultRuntimeTypeIssue = (issue) => issue.formatError(issue.error);
-/**
- * Asserts 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.
- *
- * ### Example
- *
- * ```ts
- * import {
- *   NonEmptyTrimmedString100,
- *   assertType,
- *   type Brand,
- * } from "@evolu/common";
- *
- * const value: unknown = "Evolu";
- * assertType(NonEmptyTrimmedString100, value);
- * expectTypeOf(value).toEqualTypeOf<
- *   string & Brand<"Trimmed"> & Brand<"MinLength1"> & Brand<"MaxLength100">
- * >();
- * ```
- *
- * @group Core
- */
-export const assertType = (type, value) => {
+export function assertType(type, value) {
+    if (type === undefined)
+        return;
     // TODO: Make assert prepend "Expected " and accept an optional third cause
     // argument. Then use it here and migrate every other assertion to pass an
     // expectation fragment.
@@ -506,7 +504,7 @@ export const assertType = (type, value) => {
     if (!result.ok) {
         throw new Error(`Expected ${runtimeType.name}.`, { cause: result.error });
     }
-};
+}
 const assertTypeOutput = (name, is, validateOutput, value, options = firstValidationOptions) => {
     if (is(value))
         return;
@@ -539,13 +537,22 @@ const assertTypeOutput = (name, is, validateOutput, value, options = firstValida
  * 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);
@@ -560,13 +567,14 @@ const assertTypeOutput = (name, is, validateOutput, value, options = firstValida
  *   },
  * );
  *
- * 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ý.",
  * );
  * ```
@@ -648,9 +656,7 @@ export const localizeTypes = ((typesByName, formatErrorByTypeByLocale) => {
 });
 const getLocalizationMapKeys = (value) => {
     const errorMessage = "localizeTypes maps must be plain objects with own enumerable string-keyed data properties.";
-    assert(value !== null && typeof value === "object", errorMessage);
-    const prototype = globalThis.Object.getPrototypeOf(value);
-    assert(prototype === null || globalThis.Object.getPrototypeOf(prototype) === null, errorMessage);
+    assert(isPlainObject(value), errorMessage);
     const keys = Reflect.ownKeys(value);
     for (const key of keys) {
         const descriptor = globalThis.Object.getOwnPropertyDescriptor(value, key);
@@ -700,12 +706,11 @@ const localizeTypeReflection = (value, formatIssue, localizedTypeBySource) => {
         value["~evolu/instance"] === "Type") {
         return withFormatError(value, formatIssue, localizedTypeBySource);
     }
-    if (globalThis.Array.isArray(value)) {
+    if (Array.isArray(value)) {
         return value.map((value) => localizeTypeReflection(value, formatIssue, localizedTypeBySource));
     }
-    if (value === null || typeof value !== "object" || !isPlainObject(value)) {
+    if (!isPlainObject(value))
         return value;
-    }
     const localized = globalThis.Object.create(globalThis.Object.getPrototypeOf(value));
     for (const key of Reflect.ownKeys(value)) {
         localized[key] = localizeTypeReflection(value[key], formatIssue, localizedTypeBySource);
@@ -946,16 +951,20 @@ const createTypeOfType = (name) => {
  * 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
@@ -981,7 +990,12 @@ export const String = /*#__PURE__*/ createTypeOfType("String");
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
  *   Age,
+ *   Data,
  *   FiniteNumber,
  *   Int,
  *   NonNaNNumber,
@@ -991,36 +1005,41 @@ export const String = /*#__PURE__*/ createTypeOfType("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,
@@ -1117,7 +1136,7 @@ export const ArrayBuffer = /*#__PURE__*/ objectTag("ArrayBuffer");
  * ### Example
  *
  * ```ts
- * import { instanceOf } from "@evolu/common";
+ * import { assertFalse, assertTrue, instanceOf } from "@evolu/common";
  *
  * class User {
  *   readonly name: string;
@@ -1129,8 +1148,8 @@ export const ArrayBuffer = /*#__PURE__*/ objectTag("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
@@ -1157,13 +1176,23 @@ export const instanceOf = (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",
@@ -1258,11 +1287,11 @@ const createUnionValidation = (members, validateMember) => (value, options = fir
  * ### 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
@@ -1274,11 +1303,11 @@ export const undefinedOr = (type) => union(type, Undefined);
  * ### 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
@@ -1290,20 +1319,18 @@ export const nullOr = (type) => union(type, Null);
  * ### 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
  */
 export const nullishOr = (type) => union(type, Null, Undefined);
-const isRuntimeUnionTypeNode = (type) => type.name === "Union" &&
-    "members" in type &&
-    globalThis.Array.isArray(type.members);
+const isRuntimeUnionTypeNode = (type) => type.name === "Union" && "members" in type && Array.isArray(type.members);
 /**
  * Template literal {@link Type} that parses canonical strings into Tuples.
  *
@@ -1339,7 +1366,16 @@ const isRuntimeUnionTypeNode = (type) => type.name === "Union" &&
  * 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");
@@ -1349,36 +1385,39 @@ const isRuntimeUnionTypeNode = (type) => type.name === "Union" &&
  *
  * // 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.
@@ -1391,6 +1430,8 @@ const isRuntimeUnionTypeNode = (type) => type.name === "Union" &&
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
  *   NonNegativeDecimalString,
  *   templateLiteralParser,
  * } from "@evolu/common";
@@ -1403,8 +1444,8 @@ const isRuntimeUnionTypeNode = (type) => type.name === "Union" &&
  * // 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
@@ -1412,6 +1453,9 @@ const isRuntimeUnionTypeNode = (type) => type.name === "Union" &&
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   Int64FromInt64String,
  *   templateLiteralParser,
  * } from "@evolu/common";
@@ -1422,24 +1466,29 @@ const isRuntimeUnionTypeNode = (type) => type.name === "Union" &&
  *
  * // 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);
@@ -1449,10 +1498,10 @@ const isRuntimeUnionTypeNode = (type) => type.name === "Union" &&
  * 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
@@ -1583,17 +1632,24 @@ const createTemplateLiteralParserType = (templateParts) => {
  * ### 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
@@ -1609,7 +1665,7 @@ const compileTemplateLiteralParser = (parts) => {
         return [part, partFraming.width];
     });
     return (input) => {
-        const inputCodePoints = globalThis.Array.from(input);
+        const inputCodePoints = Array.from(input);
         const variableWidth = inputCodePoints.length - fixedPartsWidth;
         if (variableWidth < 0) {
             return err({ type: "TemplateLiteral", value: input });
@@ -1665,7 +1721,7 @@ const getStringTemplateLiteralFraming = (value) => {
     const firstCodeUnit = value.charCodeAt(0);
     const lastCodeUnit = value.charCodeAt(value.length - 1);
     return {
-        width: globalThis.Array.from(value).length,
+        width: Array.from(value).length,
         canBeEmpty: value.length === 0,
         canStartWithLowSurrogate: firstCodeUnit >= 0xdc00 && firstCodeUnit <= 0xdfff,
         canEndWithHighSurrogate: lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff,
@@ -1719,13 +1775,21 @@ export function brand(name, parent, validate, formatError) {
  * ### 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",
  * });
@@ -1742,13 +1806,13 @@ export const DateIso = /*#__PURE__*/ brand("DateIso", String, (value) => value.l
  * ### 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
@@ -1781,17 +1845,27 @@ export const UInt64 = /*#__PURE__*/ brand("UInt64", BigInt, (value) => globalThi
  * ### 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",
  * });
@@ -1817,11 +1891,11 @@ export const CapitalizedString = /*#__PURE__*/ capitalized(String);
  * ### 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
@@ -1847,9 +1921,9 @@ export const TrimmedString = /*#__PURE__*/ trimmed(String);
  * ### Example
  *
  * ```ts
- * import { trim } from "@evolu/common";
+ * import { assertEqual, trim } from "@evolu/common";
  *
- * expect(trim("  Evolu  ")).toBe("Evolu");
+ * assertEqual(trim("  Evolu  "), "Evolu");
  * ```
  *
  * @group String
@@ -1861,13 +1935,13 @@ export const trim = (value) => value.trim();
  * ### 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
@@ -1900,13 +1974,13 @@ export const NonEmptyTrimmedString = /*#__PURE__*/ minLength(1)(TrimmedString);
  * ### 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
@@ -1936,13 +2010,13 @@ export const NonEmptyTrimmedString1000 = /*#__PURE__*/ maxLength(1000)(NonEmptyT
  * ### 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
@@ -1962,21 +2036,34 @@ export const length = (exact) => (parent) => {
  * 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",
  * });
  * ```
  *
@@ -2021,8 +2108,8 @@ const uint8ArrayToBase64UrlString = (bytes) => {
     if ("toBase64" in uint8ArrayPrototype) {
         return bytes.toBase64(base64UrlOptions);
     }
-    const binaryString = globalThis.Array.from(bytes, (byte) => globalThis.String.fromCodePoint(byte)).join("");
-    const base64 = globalThis.btoa(binaryString);
+    const binaryString = Array.from(bytes, (byte) => globalThis.String.fromCodePoint(byte)).join("");
+    const base64 = btoa(binaryString);
     return base64.replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
 };
 const base64UrlStringToUint8Array = (value) => {
@@ -2037,7 +2124,7 @@ const base64UrlStringToUint8Array = (value) => {
     let base64 = value.replaceAll("-", "+").replaceAll("_", "/");
     while (base64.length % 4 !== 0)
         base64 += "=";
-    const binaryString = globalThis.atob(base64);
+    const binaryString = atob(base64);
     return globalThis.Uint8Array.from(binaryString, (character) => character.charCodeAt(0));
 };
 /**
@@ -2060,9 +2147,10 @@ export const Base64Url = /*#__PURE__*/ brand("Base64Url", String, (value) => {
  * ### 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",
  * );
  * ```
@@ -2076,11 +2164,16 @@ export const uint8ArrayToBase64Url = (bytes) => uint8ArrayToBase64UrlString(byte
  * ### 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]),
  * );
  * ```
@@ -2138,6 +2231,8 @@ export const Id = /*#__PURE__*/ brand("Id", String, (value) => value.length ===
  *
  * ```ts
  * import {
+ *   assertTrue,
+ *   assertType,
  *   Id,
  *   createId,
  *   createRandomBytes,
@@ -2146,8 +2241,8 @@ export const Id = /*#__PURE__*/ brand("Id", String, (value) => value.length ===
  *
  * 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
@@ -2163,14 +2258,20 @@ export const createId = (deps, ..._validation) => uint8ArrayToBase64Url(deps.ran
  * ### 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
@@ -2188,6 +2289,7 @@ export const createIdFromString = (value, ..._validation) => idBytesToId(sha256(
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createIdAsUuidv7,
  *   createRandomBytes,
  *   createTime,
@@ -2200,8 +2302,8 @@ export const createIdFromString = (value, ..._validation) => idBytesToId(sha256(
  * });
  * 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
@@ -2226,6 +2328,7 @@ export const createIdAsUuidv7 = (deps, ..._validation) => {
  *
  * ```ts
  * import {
+ *   assertType,
  *   createIdFromString,
  *   id,
  *   type Brand,
@@ -2235,7 +2338,7 @@ export const createIdAsUuidv7 = (deps, ..._validation) => {
  * const TodoId = id("Todo");
  * const todoId = TodoId.orThrow(createIdFromString("todo"));
  *
- * expectTypeOf(todoId).toEqualTypeOf<Id & Brand<"Todo">>();
+ * assertType<Id & Brand<"Todo">, typeof todoId>();
  * ```
  *
  * @group String
@@ -2265,11 +2368,15 @@ export const idBytesTypeValueLength = 16;
  * ### 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
@@ -2282,6 +2389,7 @@ export const idToIdBytes = (value) => base64UrlToUint8Array(value);
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createIdFromString,
  *   idBytesToId,
  *   idToIdBytes,
@@ -2289,7 +2397,7 @@ export const idToIdBytes = (value) => base64UrlToUint8Array(value);
  *
  * const value = createIdFromString("todo");
  *
- * expect(idBytesToId(idToIdBytes(value))).toBe(value);
+ * assertEqual(idBytesToId(idToIdBytes(value)), value);
  * ```
  *
  * @group String
@@ -2322,12 +2430,17 @@ export const Int64String = /*#__PURE__*/ brand("Int64String", NonEmptyTrimmedStr
  * ### 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",
  * );
  * ```
@@ -2344,11 +2457,11 @@ export const Int64FromInt64String = /*#__PURE__*/ transform("Int64FromInt64Strin
  * ### 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
@@ -2366,11 +2479,11 @@ export const NonNegativeNumber = /*#__PURE__*/ nonNegative(Number);
  * ### 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
@@ -2391,11 +2504,11 @@ export const PositiveNumber = /*#__PURE__*/ positive(NonNegativeNumber);
  * ### 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
@@ -2413,11 +2526,11 @@ export const NonPositiveNumber = /*#__PURE__*/ nonPositive(Number);
  * ### 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
@@ -2438,11 +2551,11 @@ export const NegativeNumber = /*#__PURE__*/ negative(NonPositiveNumber);
  * ### 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
@@ -2467,11 +2580,11 @@ export const NonNaNNumber = /*#__PURE__*/ nonNaN(Number);
  * ### 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
@@ -2506,15 +2619,28 @@ export const PositiveFiniteNumber = /*#__PURE__*/ positive(NonNegativeFiniteNumb
  * ### 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
@@ -2583,11 +2709,11 @@ export const NegativeInt = /*#__PURE__*/ negative(NonPositiveInt);
  * ### 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
@@ -2604,11 +2730,11 @@ export const greaterThan = (min) => (parent) => {
  * ### 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
@@ -2629,11 +2755,11 @@ export const greaterThanOrEqualTo = (min) => (parent) => {
  * ### 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
@@ -2657,11 +2783,11 @@ export const Age = /*#__PURE__*/ brand("Age",
  * ### 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
@@ -2708,13 +2834,23 @@ export const Ratio = /*#__PURE__*/ brand("Ratio",
  * ### 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",
  * });
@@ -2731,11 +2867,15 @@ export const DecimalString = /*#__PURE__*/ brand("DecimalString", String, (value
  * ### 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
@@ -2759,11 +2899,15 @@ export const NonNegativeDecimalString =
  * ### 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
@@ -2789,11 +2933,15 @@ export const PositiveDecimalString = /*#__PURE__*/ positiveDecimalString(NonNega
  * ### 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
@@ -2817,11 +2965,15 @@ export const NonPositiveDecimalString =
  * ### 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
@@ -2855,16 +3007,29 @@ export const NegativeDecimalString = /*#__PURE__*/ negativeDecimalString(NonPosi
  * ### 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",
@@ -2920,11 +3085,11 @@ const decimalStringToParts = (value) => {
  * ### 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
@@ -2966,6 +3131,11 @@ export const between = (min, max) => (parent) => {
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
  *   String,
  *   array,
  *   brand,
@@ -2977,12 +3147,16 @@ export const between = (min, max) => (parent) => {
  * 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" },
  * });
@@ -3130,20 +3304,20 @@ const copyArrayPrefix = (value, endIndex) => {
 /**
  * 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
@@ -3177,68 +3351,44 @@ const createHomogeneousCollectionType = (typeElement, config) => {
     return type;
 };
 const setTypeByElement = /*#__PURE__*/ new WeakMap();
-const validateSetCollection = (value, validateElement, options) => {
-    if (!hasObjectTag(value, "Set")) {
-        return err({
-            type: "Set",
-            reason: { kind: "NotSet", value },
-        });
-    }
-    if (!hasDirectSetPrototype(value)) {
-        return err({
-            type: "Set",
-            reason: {
-                kind: "UnexpectedPrototype",
-                value: value,
-            },
-        });
-    }
-    return validateSetItems(value, validateElement, options, true);
-};
-const encodeSetCollection = (value, encodeElement) => {
-    let changed = false;
-    const output = new globalThis.Set();
-    for (const item of value) {
-        const encoded = encodeElement(item);
-        if (!globalThis.Object.is(encoded, item))
-            changed = true;
-        output.add(encoded);
-    }
-    return changed ? output : value;
-};
-const isSetCollection = (value, isElement) => {
-    if (!hasObjectTag(value, "Set"))
-        return false;
-    if (!hasDirectSetPrototype(value))
-        return false;
-    if (Reflect.ownKeys(value).length !== 0)
-        return false;
-    for (const item of value) {
-        if (!isElement(item))
-            return false;
-    }
-    return true;
-};
-const hasDirectSetPrototype = (value) => {
-    const prototype = globalThis.Object.getPrototypeOf(value);
-    if (prototype === null)
-        return false;
-    const objectPrototype = globalThis.Object.getPrototypeOf(prototype);
-    return (objectPrototype !== null &&
-        globalThis.Object.getPrototypeOf(objectPrototype) === null);
-};
 const setRuntimeConfig = {
     name: "Set",
     typeByElement: setTypeByElement,
-    validate: validateSetCollection,
+    validate: (value, validateElement, options) => {
+        if (!hasObjectTag(value, "Set")) {
+            return err({
+                type: "Set",
+                reason: { kind: "NotSet", value },
+            });
+        }
+        return validateSetItems(value, validateElement, options, true);
+    },
     validateItems: (value, validateElement, options) => validateSetItems(value, validateElement, options, false),
-    encode: encodeSetCollection,
-    is: isSetCollection,
+    encode: (value, encodeElement) => {
+        let changed = false;
+        const output = new Set();
+        for (const item of value) {
+            const encoded = encodeElement(item);
+            if (!globalThis.Object.is(encoded, item))
+                changed = true;
+            output.add(encoded);
+        }
+        return changed ? output : value;
+    },
+    is: (value, isElement) => {
+        if (!hasObjectTag(value, "Set") ||
+            Reflect.ownKeys(value).length !== 0) {
+            return false;
+        }
+        for (const item of value) {
+            if (!isElement(item))
+                return false;
+        }
+        return true;
+    },
     formatError: ((error) => {
         if (error.reason.kind === "NotSet")
             return `A value ${safelyStringifyUnknownValue(error.reason.value)} is not a Set.`;
-        if (error.reason.kind === "UnexpectedPrototype")
-            return "The value is an instance of a Set subclass, but a Set Output must be a direct Set instance.";
         const issue = error.reason.issues[0];
         switch (issue.kind) {
             case "ExcessProperty":
@@ -3251,7 +3401,7 @@ const setRuntimeConfig = {
 const validateSetItems = (value, validate, options, checkStructure) => {
     let issues;
     let changed = false;
-    const output = new globalThis.Set();
+    const output = new Set();
     if (checkStructure) {
         for (const key of Reflect.ownKeys(value)) {
             (issues ??= []).push({ kind: "ExcessProperty", key });
@@ -3284,6 +3434,208 @@ const validateSetItems = (value, validate, options, checkStructure) => {
             },
         });
 };
+/**
+ * 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 const map = (key, value) => {
+    const typeKey = key;
+    const typeValue = value;
+    let typeByValue = mapTypeByValueByKey.get(typeKey);
+    const cached = typeByValue?.get(typeValue);
+    if (cached)
+        return cached;
+    const validate = (input, validateKey, validateValue, options) => {
+        if (!hasObjectTag(input, "Map")) {
+            return err({
+                type: "Map",
+                reason: { kind: "NotMap", value: input },
+            });
+        }
+        return validateMapEntries(input, validateKey, validateValue, options, true);
+    };
+    const fromUnknown = (input, options = firstValidationOptions) => validate(input, typeKey.fromUnknown, typeValue.fromUnknown, options);
+    const validateOutput = (input, options = firstValidationOptions) => validate(input, typeKey[outputValidationSymbol], typeValue[outputValidationSymbol], options);
+    const formatError = (error) => {
+        if (error.reason.kind === "NotMap")
+            return `A value ${safelyStringifyUnknownValue(error.reason.value)} is not a Map.`;
+        const issue = error.reason.issues[0];
+        switch (issue.kind) {
+            case "ExcessProperty":
+                return `An excess Map property ${safelyStringifyUnknownValue(issue.key)} is not allowed.`;
+            case "Collision":
+                return `Map keys at indexes ${issue.previousIndex} and ${issue.index} decode to the same key ${safelyStringifyUnknownValue(issue.outputKey)}.`;
+        }
+    };
+    const rootKey = getTerminalRuntimeNode(typeKey);
+    const rootValue = getTerminalRuntimeNode(typeValue);
+    const parent = rootKey !== typeKey || rootValue !== typeValue
+        ? map(rootKey, rootValue)
+        : null;
+    const fromParent = parent
+        ? (input, options = firstValidationOptions) => validateMapEntries(input, getTerminalRuntimeNode(typeKey[fromSymbol]), getTerminalRuntimeNode(typeValue[fromSymbol]), options, false)
+        : undefined;
+    const from = createFromOperation(fromParent);
+    const encodeKey = typeKey[encoderSymbol];
+    const encodeValue = typeValue[encoderSymbol];
+    const to = encodeKey === identity && encodeValue === identity
+        ? identity
+        : (input) => {
+            const output = new Map();
+            let changed = false;
+            for (const [inputKey, inputValue] of input) {
+                const outputKey = encodeKey(inputKey);
+                const outputValue = encodeValue(inputValue);
+                assert(!output.has(outputKey), "Map key Type encoding must not produce duplicate keys.");
+                output.set(outputKey, outputValue);
+                if (!globalThis.Object.is(inputKey, outputKey) ||
+                    !globalThis.Object.is(inputValue, outputValue)) {
+                    changed = true;
+                }
+            }
+            return changed ? output : input;
+        };
+    const is = (input) => {
+        if (!hasObjectTag(input, "Map")) {
+            return false;
+        }
+        if (Reflect.ownKeys(input).length !== 0)
+            return false;
+        for (const [inputKey, inputValue] of input) {
+            if (!typeKey.is(inputKey) || !typeValue.is(inputValue))
+                return false;
+        }
+        return true;
+    };
+    const getTypeIssues = (error, mode) => {
+        const mapError = error;
+        if (mapError.reason.kind !== "Entries") {
+            return singleRuntimeTypeIssue("Map", error, formatError);
+        }
+        const allIssues = mapError.reason.issues;
+        const issues = mode === "first" ? [allIssues[0]] : allIssues;
+        return issues.flatMap((issue) => {
+            if (issue.kind === "Key" || issue.kind === "Value") {
+                return prependRuntimeTypeIssuePath(issue.index, prependRuntimeTypeIssuePath(issue.kind === "Key" ? "key" : "value", (issue.kind === "Key" ? typeKey : typeValue)[getRuntimeTypeIssuesSymbol](issue.error, mode)));
+            }
+            return singleRuntimeTypeIssue("Map", mode === "first"
+                ? error
+                : {
+                    type: "Map",
+                    reason: { kind: "Entries", issues: [issue] },
+                }, formatError, [issue.kind === "ExcessProperty" ? issue.key : issue.index]);
+        });
+    };
+    const type = createTypeNode("Map", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, { key: typeKey, value: typeValue });
+    if (typeByValue === undefined) {
+        typeByValue = new WeakMap();
+        mapTypeByValueByKey.set(typeKey, typeByValue);
+    }
+    typeByValue.set(typeValue, type);
+    return type;
+};
+const mapTypeByValueByKey = /*#__PURE__*/ new WeakMap();
+const validateMapEntries = (input, validateKey, validateValue, options, checkStructure) => {
+    let issues;
+    const output = new Map();
+    const inputByOutputKey = new Map();
+    let changed = false;
+    if (checkStructure) {
+        for (const key of Reflect.ownKeys(input)) {
+            (issues ??= []).push({ kind: "ExcessProperty", key });
+            if (options.errors === "first")
+                break;
+        }
+    }
+    let index = 0;
+    for (const [inputKey, inputValue] of input) {
+        if (issues !== undefined && options.errors === "first")
+            break;
+        const keyResult = validateKey(inputKey, options);
+        if (!keyResult.ok) {
+            (issues ??= []).push({
+                kind: "Key",
+                index,
+                key: inputKey,
+                error: keyResult.error,
+            });
+            if (options.errors === "first")
+                break;
+        }
+        const valueResult = validateValue(inputValue, options);
+        if (!valueResult.ok) {
+            (issues ??= []).push({
+                kind: "Value",
+                index,
+                key: inputKey,
+                error: valueResult.error,
+            });
+            if (options.errors === "first")
+                break;
+        }
+        if (!keyResult.ok) {
+            index++;
+            continue;
+        }
+        const outputKey = keyResult.value;
+        const previous = inputByOutputKey.get(outputKey);
+        if (previous !== undefined) {
+            (issues ??= []).push({
+                kind: "Collision",
+                index,
+                key: inputKey,
+                previousIndex: previous.index,
+                previousKey: previous.key,
+                outputKey,
+            });
+            if (options.errors === "first")
+                break;
+            index++;
+            continue;
+        }
+        inputByOutputKey.set(outputKey, { index, key: inputKey });
+        if (!valueResult.ok) {
+            index++;
+            continue;
+        }
+        output.set(outputKey, valueResult.value);
+        if (!globalThis.Object.is(inputKey, outputKey) ||
+            !globalThis.Object.is(inputValue, valueResult.value)) {
+            changed = true;
+        }
+        index++;
+    }
+    return issues === undefined
+        ? ok(changed ? output : input)
+        : err({
+            type: "Map",
+            reason: {
+                kind: "Entries",
+                issues: issues,
+            },
+        });
+};
 export function tuple(...elements) {
     return createTupleType(elements);
 }
@@ -3467,11 +3819,12 @@ const formatPlainObjectRootError = (reason) => reason.kind === "NotObject"
  * 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
@@ -3579,10 +3932,6 @@ const _Object = /*#__PURE__*/ createRootType("Object", (value, options = firstVa
 // https://github.com/react/metro/issues/1331
 // https://github.com/expo/expo/issues/31167
 export { _Object as Object };
-const isPlainObject = (value) => {
-    const prototype = globalThis.Object.getPrototypeOf(value);
-    return (prototype === null || globalThis.Object.getPrototypeOf(prototype) === null);
-};
 /**
  * Record {@link Type}.
  *
@@ -3599,12 +3948,13 @@ const isPlainObject = (value) => {
  * 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.
@@ -3613,6 +3963,8 @@ const isPlainObject = (value) => {
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   Int64FromInt64String,
  *   String,
  *   record,
@@ -3628,21 +3980,22 @@ const isPlainObject = (value) => {
  *   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
  * >();
  * ```
  *
@@ -3651,34 +4004,64 @@ const isPlainObject = (value) => {
  * 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
@@ -3865,7 +4248,13 @@ const validateRecordEntries = (input, validateKey, validateValue, options) => {
  * ### Example
  *
  * ```ts
- * import { String, object, optional, undefinedOr } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   String,
+ *   object,
+ *   optional,
+ *   undefinedOr,
+ * } from "@evolu/common";
  *
  * const User = object({
  *   name: String,
@@ -3873,8 +4262,8 @@ const validateRecordEntries = (input, validateKey, validateValue, options) => {
  *   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,
  * });
@@ -4231,13 +4620,20 @@ const createRecordPropertyError = (issue) => ({
  * ### 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
@@ -4264,15 +4660,20 @@ export const partial = (props, ..._validation) => {
  * ### 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,
  * });
@@ -4305,12 +4706,12 @@ export const nullableToOptional = (props, ..._validation) => {
  * ### 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
@@ -4565,7 +4966,7 @@ const lazyTypeNodes = /*#__PURE__*/ new WeakSet();
 const assertLazyReferencesAreGuarded = (type) => {
     for (;;) {
         assert(!lazyTypeNodes.has(type), "A Lazy Type definition must place every Lazy Type behind a structural boundary.");
-        if ("members" in type && globalThis.Array.isArray(type.members)) {
+        if ("members" in type && Array.isArray(type.members)) {
             for (const member of type.members)
                 assertLazyReferencesAreGuarded(member);
         }
@@ -4577,6 +4978,266 @@ const assertLazyReferencesAreGuarded = (type) => {
         type = type.parent;
     }
 };
+const emptyDataPath = 
+/*#__PURE__*/ globalThis.Object.freeze([]);
+const dataPathToArray = (path) => {
+    if (path === null)
+        return emptyDataPath;
+    const keys = [];
+    let node = path;
+    while (node !== null) {
+        keys.push(node.key);
+        node = node.parent;
+    }
+    keys.reverse();
+    return globalThis.Object.freeze(keys);
+};
+const dataChildPath = (parent, key) => ({ parent, key });
+const validateData = (value, options = firstValidationOptions) => {
+    const work = [{ value, path: null }];
+    const visited = new WeakSet();
+    let issues;
+    const addIssue = (issue) => {
+        (issues ??= []).push(issue);
+        return options.errors === "first";
+    };
+    while (work.length > 0) {
+        const current = work.pop();
+        const { path, value } = current;
+        if (value === null ||
+            value === undefined ||
+            typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "bigint" ||
+            typeof value === "boolean") {
+            continue;
+        }
+        if (typeof value !== "object") {
+            if (addIssue({
+                kind: "InvalidType",
+                path: dataPathToArray(path),
+                value,
+            })) {
+                break;
+            }
+            continue;
+        }
+        if (visited.has(value))
+            continue;
+        const children = [];
+        const kind = getObjectKind(value);
+        if (kind === "Array") {
+            const array = value;
+            for (const key of Reflect.ownKeys(array)) {
+                if (key === "length")
+                    continue;
+                if (typeof key === "string") {
+                    const index = globalThis.Number(key) >>> 0;
+                    if (index < array.length && globalThis.String(index) === key) {
+                        continue;
+                    }
+                }
+                if (addIssue({
+                    kind: "ExcessProperty",
+                    path: dataPathToArray(dataChildPath(path, key)),
+                    container: "Array",
+                })) {
+                    break;
+                }
+            }
+            if (issues !== undefined && options.errors === "first")
+                break;
+            for (let index = 0; index < array.length; index++) {
+                const childPath = dataChildPath(path, index);
+                const descriptor = globalThis.Object.getOwnPropertyDescriptor(array, index);
+                if (descriptor === undefined) {
+                    if (addIssue({ kind: "Hole", path: dataPathToArray(childPath) })) {
+                        break;
+                    }
+                    continue;
+                }
+                if (!("value" in descriptor)) {
+                    if (addIssue({ kind: "Accessor", path: dataPathToArray(childPath) })) {
+                        break;
+                    }
+                    continue;
+                }
+                children.push({ value: descriptor.value, path: childPath });
+            }
+        }
+        else if (kind === "Object") {
+            for (const key of Reflect.ownKeys(value)) {
+                const childPath = dataChildPath(path, key);
+                if (typeof key === "symbol") {
+                    if (addIssue({
+                        kind: "SymbolProperty",
+                        path: dataPathToArray(childPath),
+                    })) {
+                        break;
+                    }
+                    continue;
+                }
+                const descriptor = globalThis.Object.getOwnPropertyDescriptor(value, key);
+                if (!("value" in descriptor)) {
+                    if (addIssue({ kind: "Accessor", path: dataPathToArray(childPath) })) {
+                        break;
+                    }
+                    continue;
+                }
+                if (!descriptor.enumerable) {
+                    if (addIssue({
+                        kind: "NonEnumerable",
+                        path: dataPathToArray(childPath),
+                    })) {
+                        break;
+                    }
+                    continue;
+                }
+                children.push({ value: descriptor.value, path: childPath });
+            }
+        }
+        else if (kind === "Date") {
+            visited.add(value);
+            continue;
+        }
+        else if (kind === "Uint8Array") {
+            try {
+                void globalThis.Uint8Array.prototype.values.call(value);
+            }
+            catch {
+                if (addIssue({
+                    kind: "InvalidUint8Array",
+                    path: dataPathToArray(path),
+                    value: value,
+                })) {
+                    break;
+                }
+            }
+            visited.add(value);
+            continue;
+        }
+        else if (kind === "Set") {
+            for (const key of Reflect.ownKeys(value)) {
+                if (addIssue({
+                    kind: "ExcessProperty",
+                    path: dataPathToArray(dataChildPath(path, key)),
+                    container: "Set",
+                })) {
+                    break;
+                }
+            }
+            if (issues !== undefined && options.errors === "first")
+                break;
+            let index = 0;
+            for (const item of value) {
+                children.push({ value: item, path: dataChildPath(path, index++) });
+            }
+        }
+        else if (kind === "Map") {
+            for (const key of Reflect.ownKeys(value)) {
+                if (addIssue({
+                    kind: "ExcessProperty",
+                    path: dataPathToArray(dataChildPath(path, key)),
+                    container: "Map",
+                })) {
+                    break;
+                }
+            }
+            if (issues !== undefined && options.errors === "first")
+                break;
+            let index = 0;
+            for (const [key, item] of value) {
+                const entryPath = dataChildPath(path, index++);
+                children.push({ value: key, path: dataChildPath(entryPath, "key") });
+                children.push({
+                    value: item,
+                    path: dataChildPath(entryPath, "value"),
+                });
+            }
+        }
+        else if (addIssue({
+            kind: "UnexpectedPrototype",
+            path: dataPathToArray(path),
+            container: "Object",
+            value,
+        })) {
+            break;
+        }
+        if (issues !== undefined && options.errors === "first")
+            break;
+        visited.add(value);
+        for (let index = children.length - 1; index >= 0; index--) {
+            work.push(children[index]);
+        }
+    }
+    return issues === undefined
+        ? ok(value)
+        : err({
+            type: "Data",
+            reason: {
+                kind: "Issues",
+                issues: globalThis.Object.freeze(issues),
+            },
+        });
+};
+const getDataRuntimeTypeIssues = (error, mode) => {
+    const dataError = error;
+    const issues = mode === "first"
+        ? [dataError.reason.issues[0]]
+        : dataError.reason.issues;
+    return issues.map((issue) => ({
+        name: "Data",
+        error: mode === "first"
+            ? error
+            : {
+                type: "Data",
+                reason: { kind: "Issues", issues: [issue] },
+            },
+        path: issue.path,
+        formatError: ((error) => {
+            const issue = error.reason.issues[0];
+            switch (issue.kind) {
+                case "InvalidType":
+                    return `A value ${safelyStringifyUnknownValue(issue.value)} is not Data.`;
+                case "UnexpectedPrototype":
+                    return `A Data ${issue.container} has an unexpected prototype.`;
+                case "Accessor":
+                    return "A Data property must be a data property. Materialize accessor values into plain data before using this Type or use a different Type.";
+                case "NonEnumerable":
+                    return "A Data Object property must be enumerable. Remove it or use a different Type.";
+                case "SymbolProperty":
+                    return "A Data Object property key must be a string. Remove the symbol property or use a different Type.";
+                case "Hole":
+                    return "A Data Array element is missing.";
+                case "InvalidUint8Array":
+                    return "A Data Uint8Array must have an attached, in-bounds ArrayBuffer.";
+                case "ExcessProperty":
+                    return `A Data ${issue.container} must not have excess own properties. Remove the property or use a different Type.`;
+            }
+        }),
+    }));
+};
+/**
+ * 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 const Data = /*#__PURE__*/ createTypeNode("Data", null, validateData, (value) => validateData(value).ok, validateData, ok, identity, getDataRuntimeTypeIssues);
 const emptyJsonValuePath = 
 /*#__PURE__*/ globalThis.Object.freeze([]);
 const jsonValuePathToArray = (path) => {
@@ -4635,7 +5296,7 @@ const validateJsonValue = (value, options = firstValidationOptions) => {
             }
             continue;
         }
-        const isArray = globalThis.Array.isArray(value);
+        const isArray = Array.isArray(value);
         if (!isArray && !isPlainObject(value)) {
             if (addIssue({
                 kind: "UnexpectedPrototype",
@@ -4800,7 +5461,7 @@ const getJsonValueRuntimeTypeIssues = (error, mode) => {
         }),
     }));
 };
-const parseJson = (value) => globalThis.JSON.parse(value);
+const parseJson = (value) => JSON.parse(value);
 const jsonToJsonValueResult = (value) => {
     const result = trySync(() => parseJson(value));
     return result.ok && validateJsonValue(result.value).ok
@@ -4824,7 +5485,7 @@ const stringifyJsonValue = (value) => {
         // oxlint-disable-next-line typescript/switch-exhaustiveness-check -- JsonValue excludes the additional runtime types reported by tsgolint.
         switch (typeof value) {
             case "string":
-                chunks.push(globalThis.JSON.stringify(value));
+                chunks.push(JSON.stringify(value));
                 break;
             case "number":
                 chunks.push(globalThis.Object.is(value, -0) ? "-0" : globalThis.String(value));
@@ -4833,7 +5494,7 @@ const stringifyJsonValue = (value) => {
                 chunks.push(value ? "true" : "false");
                 break;
             case "object": {
-                if (globalThis.Array.isArray(value)) {
+                if (Array.isArray(value)) {
                     const array = value;
                     chunks.push("[");
                     work.push({ kind: "Text", value: "]" });
@@ -4854,7 +5515,7 @@ const stringifyJsonValue = (value) => {
                     work.push({ kind: "Text", value: ":" });
                     work.push({
                         kind: "Text",
-                        value: globalThis.JSON.stringify(key),
+                        value: JSON.stringify(key),
                     });
                     if (index > 0)
                         work.push({ kind: "Text", value: "," });
@@ -4871,7 +5532,12 @@ const stringifyJsonValue = (value) => {
  * ### Example
  *
  * ```ts
- * import { JsonValue, type JsonValueInput } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   assertType,
+ *   JsonValue,
+ *   type JsonValueInput,
+ * } from "@evolu/common";
  *
  * const input: JsonValueInput = {
  *   name: "Ada",
@@ -4879,8 +5545,8 @@ const stringifyJsonValue = (value) => {
  * };
  * const result = JsonValue.fromUnknown(input);
  *
- * expectOk(result, input);
- * expectTypeOf(result.value).toEqualTypeOf<JsonValue>();
+ * assertOk(result, input);
+ * assertType<JsonValue, typeof result.value>();
  * ```
  *
  * @group JSON
@@ -4918,11 +5584,11 @@ export const Json = /*#__PURE__*/ brand("Json", String, (value) => {
  * ### 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
@@ -4934,11 +5600,15 @@ export const jsonToJsonValue = (value) => parseJson(value);
  * ### 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
@@ -4953,12 +5623,12 @@ export const jsonValueToJson = (value) => stringifyJsonValue(JsonValue.to(value)
  * ### 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
@@ -4979,6 +5649,8 @@ export const JsonValueFromJson = /*#__PURE__*/ transform("JsonValueFromJson", Js
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   Age,
  *   NonEmptyTrimmedString100,
  *   json,
@@ -4999,11 +5671,13 @@ export const JsonValueFromJson = /*#__PURE__*/ transform("JsonValueFromJson", Js
  * 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