@evolu/common 8.4.0 → 8.6.0

package/src/Type.ts

@@ -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?
  *
@@ -432,15 +454,16 @@ import { sha256 } from "@noble/hashes/sha2.js";
 import * as bip39 from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type {
-  AtLeastTwoReadonlyArray,
-  NonEmptyReadonlyArray,
+import {
+  createMutableArray,
+  type AtLeastTwoReadonlyArray,
+  type NonEmptyReadonlyArray,
 } from "./Array.ts";
 import { assert, assertNonNullable } from "./Assert.ts";
 import type { Brand } from "./Brand.ts";
 import type { RandomBytesDep } from "./Crypto.ts";
 import { identity, type Thunk } from "./Function.ts";
-import { createMutableRecord } from "./Object.ts";
+import { createMutableRecord, getObjectKind, isPlainObject } from "./Object.ts";
 import { hasNodeBuffer } from "./Platform.ts";
 import {
   err,
@@ -460,6 +483,7 @@ import {
   isInstance,
   type CompileTimeError,
   type Instance,
+  type IsSameType,
   type IsUnion,
   type Literal,
   type Simplify,
@@ -571,12 +595,12 @@ export interface Type<
    * ### 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: (
@@ -596,12 +620,25 @@ export interface Type<
    * ### 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.",
    * );
    * ```
@@ -618,14 +655,20 @@ export interface Type<
    * ### 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;
@@ -651,6 +694,8 @@ export interface Type<
    *
    * ```ts
    * import {
+   *   assertOk,
+   *   assertType,
    *   flatMapResult,
    *   NonEmptyTrimmedString100,
    *   object,
@@ -683,10 +728,11 @@ export interface Type<
    * 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]
@@ -706,11 +752,15 @@ export interface Type<
    * ### 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]
@@ -736,7 +786,12 @@ export interface Type<
    * ### Example
    *
    * ```ts
-   * import { getOrThrow, minLength, String } from "@evolu/common";
+   * import {
+   *   assertEqual,
+   *   getOrThrow,
+   *   minLength,
+   *   String,
+   * } from "@evolu/common";
    *
    * const NonEmptyString = minLength(1)(String);
    *
@@ -745,8 +800,8 @@ export interface Type<
    * // 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>;
@@ -770,7 +825,12 @@ export interface Type<
    * ### Example
    *
    * ```ts
-   * import { getOrNull, minLength, String } from "@evolu/common";
+   * import {
+   *   assertEqual,
+   *   getOrNull,
+   *   minLength,
+   *   String,
+   * } from "@evolu/common";
    *
    * const NonEmptyString = minLength(1)(String);
    *
@@ -779,9 +839,9 @@ export interface Type<
    * // 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>;
@@ -975,12 +1035,18 @@ const formatDefaultRuntimeTypeIssue: RuntimeFormatTypeIssue = (issue) =>
   issue.formatError(issue.error);
 
 /**
- * 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
  *
@@ -993,17 +1059,37 @@ const formatDefaultRuntimeTypeIssue: RuntimeFormatTypeIssue = (issue) =>
  *
  * 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 const assertType: <T extends TypeNode>(
+export function assertType<Expected, Actual>(
+  ...error: IsSameType<Expected, Actual> extends true
+    ? []
+    : [
+        error: CompileTimeError<
+          "assertType",
+          "Expected and actual types must be identical"
+        >,
+      ]
+): void;
+export function assertType<T extends TypeNode>(
   type: T,
   value: unknown,
-) => asserts value is T["Output"] = (type, value) => {
+): asserts value is T["Output"];
+export function assertType<T extends TypeNode>(
+  type?: T,
+  value?: unknown,
+): void {
+  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.
@@ -1013,7 +1099,7 @@ export const assertType: <T extends TypeNode>(
   if (!result.ok) {
     throw new Error(`Expected ${runtimeType.name}.`, { cause: result.error });
   }
-};
+}
 
 const assertTypeOutput = <Error extends TypeError>(
   name: TypeName,
@@ -1058,13 +1144,22 @@ const assertTypeOutput = <Error extends TypeError>(
  * 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);
@@ -1079,13 +1174,14 @@ const assertTypeOutput = <Error extends TypeError>(
  *   },
  * );
  *
- * 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ý.",
  * );
  * ```
@@ -1199,12 +1295,7 @@ export const localizeTypes = ((
 const getLocalizationMapKeys = (value: unknown): ReadonlyArray<string> => {
   const errorMessage =
     "localizeTypes maps must be plain objects with own enumerable string-keyed data properties.";
-  assert(value !== null && typeof value === "object", errorMessage);
-  const prototype: unknown = 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) {
@@ -1297,14 +1388,12 @@ const localizeTypeReflection = (
       localizedTypeBySource,
     );
   }
-  if (globalThis.Array.isArray(value)) {
+  if (Array.isArray(value)) {
     return (value as ReadonlyArray<unknown>).map((value) =>
       localizeTypeReflection(value, formatIssue, localizedTypeBySource),
     );
   }
-  if (value === null || typeof value !== "object" || !isPlainObject(value)) {
-    return value;
-  }
+  if (!isPlainObject(value)) return value;
 
   const localized = globalThis.Object.create(
     globalThis.Object.getPrototypeOf(value) as object | null,
@@ -1349,9 +1438,8 @@ type ValidateFormatErrorByTypeByLocale<
     ? unknown
     : never;
 
-/* eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style --
-This mapped validation type is cheaper than the equivalent Record. Changes are
-measured by `pnpm bench:type`. */
+// This mapped validation type is cheaper than the equivalent Record. Changes
+// are measured by `pnpm bench:type`.
 type NoNonStringKeys<Value> = {
   readonly [Key in Exclude<keyof Value, string>]: never;
 };
@@ -1390,7 +1478,7 @@ type LocalizedErrorEntry<
           ? LocalizedDiscriminatedUnionErrorEntry<Error, Seen | Error>
           : Error extends {
                 readonly type: infer Name extends
-                  "Array" | "Tuple" | "Record" | "Set";
+                  "Array" | "Map" | "Tuple" | "Record" | "Set";
                 readonly reason: infer Reason;
               }
             ? | LocalizedErrorEntryValue<Name, Error>
@@ -1492,6 +1580,8 @@ declare const identityEncodingSymbol: unique symbol;
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   NonEmptyTrimmedString100,
  *   PositiveInt,
  *   object,
@@ -1507,8 +1597,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
@@ -1847,7 +1937,12 @@ type ConcreteChildTypeNameError = CompileTimeError<
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
  *   createType,
+ *   Data,
  *   err,
  *   ok,
  *   type Result,
@@ -1865,8 +1960,11 @@ type ConcreteChildTypeNameError = CompileTimeError<
  *   () => "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
@@ -1891,6 +1989,7 @@ export function createType<
   parent: ValidateParent<ParentType>,
   fromParent: (
     value: ParentType["Output"],
+    // oxlint-disable-next-line typescript/no-unnecessary-type-arguments -- Explicit defaults in recursive Type declarations are benchmarked to avoid extra compiler work.
   ) => Result<ParentType["Output"], never>,
 ): Type<
   Name,
@@ -2148,7 +2247,15 @@ const createChildType = <
  * ### 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(
@@ -2161,8 +2268,8 @@ const createChildType = <
  *   },
  * );
  *
- * 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
@@ -2179,12 +2286,66 @@ export function transform<
   operations: {
     readonly from: (
       value: ParentType["Output"],
+      // oxlint-disable-next-line typescript/no-unnecessary-type-arguments -- Explicit defaults in recursive Type declarations are benchmarked to avoid extra compiler work.
     ) => 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 function transform<
   Name extends TypeName,
   ParentType extends ConcreteTypeNode,
@@ -2473,7 +2634,7 @@ function getTerminalRuntimeNode<Value>(
 ): RuntimeOperation<Value>;
 function getTerminalRuntimeNode(node: RuntimeTypeNode): RuntimeTypeNode;
 function getTerminalRuntimeNode(node: { readonly parent?: unknown }): unknown {
-  while (node.parent) node = node.parent;
+  while (node.parent != null) node = node.parent;
 
   return node;
 }
@@ -2698,16 +2859,20 @@ export interface TypeOfError<
  * 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
@@ -2734,7 +2899,12 @@ export const String = /*#__PURE__*/ createTypeOfType("String");
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
  *   Age,
+ *   Data,
  *   FiniteNumber,
  *   Int,
  *   NonNaNNumber,
@@ -2744,36 +2914,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">
+ * assertType<number, typeof Number.Output>();
+ * assertType<number & Brand<"NonNaN">, typeof NonNaNNumber.Output>();
+ * assertType<
+ *   number & Brand<"NonNaN"> & Brand<"Finite">,
+ *   typeof FiniteNumber.Output
  * >();
- * expectTypeOf<typeof FiniteNumber.Output>().toEqualTypeOf<
- *   number & Brand<"NonNaN"> & Brand<"Finite">
+ * assertType<
+ *   number & Brand<"NonNaN"> & Brand<"Finite"> & Brand<"Int">,
+ *   typeof Int.Output
  * >();
- * expectTypeOf<typeof Int.Output>().toEqualTypeOf<
- *   number & Brand<"NonNaN"> & Brand<"Finite"> & Brand<"Int">
- * >();
- * 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,
@@ -2926,12 +3101,12 @@ 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
@@ -2949,7 +3124,41 @@ export function objectTag<Name extends keyof ObjectTagOutputByName>(
   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 function objectTag<
   Name extends TypeName,
   OutputType extends ConcreteTypeNode & { readonly Output: object },
@@ -3040,7 +3249,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;
@@ -3052,8 +3261,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
@@ -3155,13 +3364,23 @@ type InstanceConstructorCompileTimeError = CompileTimeError<
  * ### 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",
@@ -3318,17 +3537,29 @@ export const Null = /*#__PURE__*/ literal(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: [
  *     {
@@ -3486,11 +3717,11 @@ const createUnionValidation =
  * ### 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
@@ -3505,11 +3736,11 @@ export const undefinedOr = <ValueType extends TypeNode>(
  * ### 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
@@ -3524,12 +3755,12 @@ export const nullOr = <ValueType extends TypeNode>(
  * ### 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
@@ -3604,9 +3835,7 @@ interface RuntimeUnionTypeNode extends RuntimeTypeNode {
 const isRuntimeUnionTypeNode = (
   type: RuntimeTypeNode,
 ): type is RuntimeUnionTypeNode =>
-  type.name === "Union" &&
-  "members" in type &&
-  globalThis.Array.isArray(type.members);
+  type.name === "Union" && "members" in type && Array.isArray(type.members);
 
 /**
  * A root {@link Type} validating the encoded Inputs accepted by {@link union}.
@@ -3767,7 +3996,16 @@ interface UnionErrorValue<
  * 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");
@@ -3777,36 +4015,39 @@ interface UnionErrorValue<
  *
  * // 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.
@@ -3819,6 +4060,8 @@ interface UnionErrorValue<
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
  *   NonNegativeDecimalString,
  *   templateLiteralParser,
  * } from "@evolu/common";
@@ -3831,8 +4074,8 @@ interface UnionErrorValue<
  * // 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
@@ -3840,6 +4083,9 @@ interface UnionErrorValue<
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertOk,
+ *   assertType,
  *   Int64FromInt64String,
  *   templateLiteralParser,
  * } from "@evolu/common";
@@ -3850,24 +4096,29 @@ interface UnionErrorValue<
  *
  * // 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);
@@ -3877,10 +4128,10 @@ interface UnionErrorValue<
  * 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
@@ -4145,6 +4396,7 @@ export interface TemplateLiteralType<
   TypeOfError<"String"> | TemplateLiteralParseError<Parts>,
   never,
   TemplateLiteralStringOutput<Parts>,
+  // oxlint-disable-next-line typescript/no-unnecessary-type-arguments -- TemplateLiteralType explicitly documents every Type invariant, including identity encoding.
   true
 > {
   readonly [templateLiteralSyntaxSymbol]: true;
@@ -4165,17 +4417,24 @@ export interface TemplateLiteralType<
  * ### 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
@@ -4445,7 +4704,7 @@ const compileTemplateLiteralParser = <Parts extends TemplateLiteralParts>(
   });
 
   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 });
@@ -4521,7 +4780,7 @@ const getStringTemplateLiteralFraming = (
   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,
@@ -4606,8 +4865,13 @@ const getTemplateLiteralPartFraming = (
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
  *   BigInt,
  *   brand,
+ *   Data,
  *   err,
  *   ok,
  *   type Brand,
@@ -4626,14 +4890,17 @@ const getTemplateLiteralPartFraming = (
  * 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,
  * });
@@ -4650,6 +4917,7 @@ export function brand<
 >(
   name: ValidateConcreteTypeName<Name>,
   parent: ValidateParent<ParentType>,
+  // oxlint-disable-next-line typescript/no-unnecessary-type-arguments -- Explicit defaults in recursive Type declarations are benchmarked to avoid extra compiler work.
   validate?: (value: ParentType["Output"]) => Result<void, never>,
 ): BrandType<ParentType, Name, never>;
 
@@ -4716,13 +4984,21 @@ export interface BrandType<
  * ### 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",
  * });
@@ -4757,13 +5033,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
@@ -4856,6 +5132,11 @@ export interface UInt64Error extends TypeError<"UInt64"> {
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
  *   String,
  *   brand,
  *   err,
@@ -4881,14 +5162,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",
  * });
@@ -4920,6 +5204,7 @@ export type BrandFactory<
  *
  * ```ts
  * import {
+ *   assertType,
  *   Number,
  *   brand,
  *   err,
@@ -4951,10 +5236,8 @@ export type BrandFactory<
  * 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,
@@ -4989,17 +5272,27 @@ type BrandFactoryNumberError = CompileTimeError<
  * ### 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",
  * });
@@ -5049,11 +5342,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
@@ -5101,9 +5394,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
@@ -5117,13 +5410,13 @@ export 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
@@ -5183,13 +5476,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
@@ -5252,13 +5545,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
@@ -5303,21 +5596,34 @@ export interface LengthError<
  * 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",
  * });
  * ```
  *
@@ -5378,7 +5684,7 @@ export interface RegexError<
  */
 export const UrlSafeString = /*#__PURE__*/ regex(
   "UrlSafeString",
-  /^[A-Za-z0-9_-]+$/,
+  /^[A-Za-z0-9_-]+$/u,
 )(String);
 export type UrlSafeString = typeof UrlSafeString.Output;
 
@@ -5396,12 +5702,12 @@ const uint8ArrayToBase64UrlString = (bytes: Uint8Array): string => {
     return bytes.toBase64(base64UrlOptions);
   }
 
-  const binaryString = globalThis.Array.from(bytes, (byte) =>
+  const binaryString = Array.from(bytes, (byte) =>
     globalThis.String.fromCodePoint(byte),
   ).join("");
-  const base64 = globalThis.btoa(binaryString);
+  const base64 = btoa(binaryString);
 
-  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  return base64.replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
 };
 
 const base64UrlStringToUint8Array = (value: string): Uint8Array => {
@@ -5414,10 +5720,10 @@ const base64UrlStringToUint8Array = (value: string): Uint8Array => {
     return globalThis.Uint8Array.fromBase64(value, base64UrlOptions);
   }
 
-  let base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+  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),
   );
@@ -5461,9 +5767,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",
  * );
  * ```
@@ -5479,11 +5786,16 @@ export 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]),
  * );
  * ```
@@ -5602,6 +5914,8 @@ export interface IdError extends TypeError<"Id"> {
  *
  * ```ts
  * import {
+ *   assertTrue,
+ *   assertType,
  *   Id,
  *   createId,
  *   createRandomBytes,
@@ -5610,8 +5924,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
@@ -5632,14 +5946,20 @@ export const createId = <B extends string = never>(
  * ### 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
@@ -5664,6 +5984,7 @@ export const createIdFromString = <B extends string = never>(
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createIdAsUuidv7,
  *   createRandomBytes,
  *   createTime,
@@ -5676,8 +5997,8 @@ export const createIdFromString = <B extends string = never>(
  * });
  * 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
@@ -5708,6 +6029,7 @@ export const createIdAsUuidv7 = <B extends string = never>(
  *
  * ```ts
  * import {
+ *   assertType,
  *   createIdFromString,
  *   id,
  *   type Brand,
@@ -5717,7 +6039,7 @@ export const createIdAsUuidv7 = <B extends string = never>(
  * const TodoId = id("Todo");
  * const todoId = TodoId.orThrow(createIdFromString("todo"));
  *
- * expectTypeOf(todoId).toEqualTypeOf<Id & Brand<"Todo">>();
+ * assertType<Id & Brand<"Todo">, typeof todoId>();
  * ```
  *
  * @group String
@@ -5756,6 +6078,7 @@ export interface TableId<Table extends TypeName> extends Type<
   TableIdError<Table> | InferErrors<typeof String>,
   ChildCustomFrom<typeof String, Id & Brand<Table>, TableIdError<Table>>,
   CanonicalInputForChild<typeof String, Id & Brand<Table>>,
+  // oxlint-disable-next-line typescript/no-unnecessary-type-arguments -- TableId must track its parent Type's identity encoding instead of hard-coding Type's default.
   IdentityEncodingOf<typeof String>
 > {
   readonly table: Table;
@@ -5830,11 +6153,15 @@ export const idBytesTypeValueLength = 16 as 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
@@ -5849,6 +6176,7 @@ export const idToIdBytes = (value: Id): IdBytes =>
  *
  * ```ts
  * import {
+ *   assertEqual,
  *   createIdFromString,
  *   idBytesToId,
  *   idToIdBytes,
@@ -5856,7 +6184,7 @@ export const idToIdBytes = (value: Id): IdBytes =>
  *
  * const value = createIdFromString("todo");
  *
- * expect(idBytesToId(idToIdBytes(value))).toBe(value);
+ * assertEqual(idBytesToId(idToIdBytes(value)), value);
  * ```
  *
  * @group String
@@ -5877,7 +6205,7 @@ export const Int64String = /*#__PURE__*/ brand(
 
     if (
       value.length > (negative ? 20 : 19) ||
-      !/^(?:0|-?[1-9]\d*)$/.test(value)
+      !/^(?:0|-?[1-9]\d*)$/u.test(value)
     ) {
       return err<Int64StringError>({ type: "Int64String", value });
     }
@@ -5913,12 +6241,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",
  * );
  * ```
@@ -5941,11 +6274,11 @@ export const Int64FromInt64String = /*#__PURE__*/ transform(
  * ### 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
@@ -5987,11 +6320,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
@@ -6034,11 +6367,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
@@ -6080,11 +6413,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
@@ -6127,11 +6460,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
@@ -6175,11 +6508,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
@@ -6240,15 +6573,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
@@ -6348,11 +6694,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
@@ -6394,11 +6740,11 @@ export interface GreaterThanError<
  * ### 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
@@ -6448,11 +6794,11 @@ export interface GreaterThanOrEqualToError<
  * ### 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
@@ -6505,11 +6851,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
@@ -6589,13 +6935,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",
  * });
@@ -6607,7 +6963,7 @@ export const DecimalString = /*#__PURE__*/ brand(
   "DecimalString",
   String,
   (value) =>
-    /^(?:0|-?(?:[1-9]\d*|(?:0|[1-9]\d*)\.\d*[1-9]))$/.test(value)
+    /^(?:0|-?(?:[1-9]\d*|(?:0|[1-9]\d*)\.\d*[1-9]))$/u.test(value)
       ? ok()
       : err<DecimalStringError>({ type: "DecimalString", value }),
   (error) =>
@@ -6630,11 +6986,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
@@ -6682,11 +7042,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
@@ -6738,11 +7102,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
@@ -6790,11 +7158,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
@@ -6854,16 +7226,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",
@@ -7000,11 +7385,11 @@ const decimalStringToParts = (value: string): DecimalParts => {
  * ### 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
@@ -7074,6 +7459,11 @@ export interface BetweenError<
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
  *   String,
  *   array,
  *   brand,
@@ -7085,12 +7475,16 @@ export interface BetweenError<
  * 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" },
  * });
@@ -7494,7 +7888,7 @@ const copyArrayPrefix = (
   value: ReadonlyArray<unknown>,
   endIndex: number,
 ): Array<unknown> => {
-  const output = new Array<unknown>(value.length);
+  const output = createMutableArray<unknown>(value.length);
 
   for (let index = 0; index < endIndex; index++) {
     output[index] = value[index];
@@ -7506,20 +7900,20 @@ const copyArrayPrefix = (
 /**
  * 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
@@ -7608,15 +8002,12 @@ type SetNodeError<ElementType extends TypeNode> = [
   : 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>;
+  SetNotSetError | SetItemsErrorValue<Error, true>;
 
 /**
  * Error returned when a {@link set} input is not a Set.
@@ -7630,18 +8021,6 @@ export interface SetNotSetError extends TypeError<"Set"> {
   };
 }
 
-/**
- * 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.
  *
@@ -7795,91 +8174,54 @@ const createHomogeneousCollectionType = <Collection>(
 
 const setTypeByElement = /*#__PURE__*/ new WeakMap<TypeNode, TypeNode>();
 
-const validateSetCollection = (
-  value: unknown,
-  validateElement: RuntimeOutputValidation,
-  options: ValidationOptions,
-): Result<ReadonlySet<unknown>, SetError> => {
-  if (!hasObjectTag(value, "Set")) {
-    return err({
-      type: "Set",
-      reason: { kind: "NotSet", value },
-    });
-  }
-  if (!hasDirectSetPrototype(value as object)) {
-    return err({
-      type: "Set",
-      reason: {
-        kind: "UnexpectedPrototype",
-        value: value as ReadonlySet<unknown>,
-      },
-    });
-  }
-
-  return validateSetItems(
-    value as ReadonlySet<unknown>,
-    validateElement,
-    options,
-    true,
-  );
-};
-
-const encodeSetCollection = (
-  value: ReadonlySet<unknown>,
-  encodeElement: RuntimeEncoder,
-): ReadonlySet<unknown> => {
-  let changed = false;
-  const output = new globalThis.Set<unknown>();
-
-  for (const item of value) {
-    const encoded = encodeElement(item as never);
-    if (!globalThis.Object.is(encoded, item)) changed = true;
-    output.add(encoded);
-  }
-
-  return changed ? output : value;
-};
-
-const isSetCollection = (
-  value: unknown,
-  isElement: (value: unknown) => boolean,
-): boolean => {
-  if (!hasObjectTag(value, "Set")) return false;
-  if (!hasDirectSetPrototype(value as object)) return false;
-  if (Reflect.ownKeys(value as object).length !== 0) return false;
-  for (const item of value as ReadonlySet<unknown>) {
-    if (!isElement(item)) return false;
-  }
-  return true;
-};
-
-const hasDirectSetPrototype = (value: object): boolean => {
-  const prototype: unknown = globalThis.Object.getPrototypeOf(value);
-  if (prototype === null) return false;
-
-  const objectPrototype: unknown = globalThis.Object.getPrototypeOf(prototype);
-
-  return (
-    objectPrototype !== null &&
-    globalThis.Object.getPrototypeOf(objectPrototype) === null
-  );
-};
-
 const setRuntimeConfig: HomogeneousCollectionRuntimeConfig<
   ReadonlySet<unknown>
 > = {
   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 as ReadonlySet<unknown>,
+      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<unknown>();
+
+    for (const item of value) {
+      const encoded = encodeElement(item as never);
+      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 as object).length !== 0
+    ) {
+      return false;
+    }
+    for (const item of value as ReadonlySet<unknown>) {
+      if (!isElement(item)) return false;
+    }
+    return true;
+  },
   formatError: ((error: SetError) => {
     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":
@@ -7899,7 +8241,7 @@ const validateSetItems = (
   let issues:
     Array<SetStructuralIssue | SetElementIssue<TypeError>> | undefined;
   let changed = false;
-  const output = new globalThis.Set<unknown>();
+  const output = new Set<unknown>();
 
   if (checkStructure) {
     for (const key of Reflect.ownKeys(value)) {
@@ -7936,14 +8278,530 @@ const validateSetItems = (
 };
 
 /**
- * Tuple {@link Type}.
+ * Map {@link Type} whose keys and values must match their respective Types.
  *
- * Use `tuple(First, Second, ...)` for a fixed-length readonly array in which
- * every position has its own Type.
+ * 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.
  *
- * `fromUnknown` validates the Tuple representation and runs every element's
- * complete Type pipeline. By default, it returns the first issue. Pass `{
- * errors: "all" }` to collect issues across the whole Tuple.
+ * ### 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 = <
+  KeyType extends ConcreteTypeNode,
+  ValueType extends ConcreteTypeNode,
+>(
+  key: ValidateMapKeyType<KeyType>,
+  value: ValidateMapValueType<ValueType>,
+): MapType<KeyType, ValueType> => {
+  const typeKey = key as unknown as KeyType & RuntimeTypeNode;
+  const typeValue = value as unknown as ValueType & RuntimeTypeNode;
+
+  let typeByValue = mapTypeByValueByKey.get(typeKey);
+  const cached = typeByValue?.get(typeValue);
+  if (cached) return cached as MapType<KeyType, ValueType>;
+
+  const validate = (
+    input: unknown,
+    validateKey: RuntimeOutputValidation,
+    validateValue: RuntimeOutputValidation,
+    options: ValidationOptions,
+  ): Result<ReadonlyMap<unknown, unknown>, MapError> => {
+    if (!hasObjectTag(input, "Map")) {
+      return err({
+        type: "Map",
+        reason: { kind: "NotMap", value: input },
+      });
+    }
+    return validateMapEntries(
+      input as ReadonlyMap<unknown, unknown>,
+      validateKey,
+      validateValue,
+      options,
+      true,
+    );
+  };
+  const fromUnknown = (
+    input: unknown,
+    options: ValidationOptions = firstValidationOptions,
+  ) => validate(input, typeKey.fromUnknown, typeValue.fromUnknown, options);
+  const validateOutput = (
+    input: unknown,
+    options: ValidationOptions = firstValidationOptions,
+  ) =>
+    validate(
+      input,
+      typeKey[outputValidationSymbol],
+      typeValue[outputValidationSymbol],
+      options,
+    );
+  const formatError: TypeErrorFormatter<MapStructuralError> = (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 as unknown as (
+            key: ConcreteTypeNode,
+            value: ConcreteTypeNode,
+          ) => TypeNode
+        )(
+          rootKey as unknown as ConcreteTypeNode,
+          rootValue as unknown as ConcreteTypeNode,
+        )
+      : null;
+  const fromParent = parent
+    ? (input: never, options: ValidationOptions = firstValidationOptions) =>
+        validateMapEntries(
+          input,
+          getTerminalRuntimeNode(
+            typeKey[fromSymbol],
+          ) as RuntimeOutputValidation,
+          getTerminalRuntimeNode(
+            typeValue[fromSymbol],
+          ) as RuntimeOutputValidation,
+          options,
+          false,
+        )
+    : undefined;
+  const from = createFromOperation(fromParent);
+  const encodeKey = typeKey[encoderSymbol];
+  const encodeValue = typeValue[encoderSymbol];
+  const to: RuntimeEncoder =
+    encodeKey === identity && encodeValue === identity
+      ? identity
+      : (input: ReadonlyMap<unknown, unknown>) => {
+          const output = new Map<unknown, unknown>();
+          let changed = false;
+
+          for (const [inputKey, inputValue] of input) {
+            const outputKey = encodeKey(inputKey as never);
+            const outputValue = encodeValue(inputValue as never);
+
+            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: unknown): boolean => {
+    if (!hasObjectTag(input, "Map")) {
+      return false;
+    }
+    if (Reflect.ownKeys(input as object).length !== 0) return false;
+
+    for (const [inputKey, inputValue] of input as ReadonlyMap<
+      unknown,
+      unknown
+    >) {
+      if (!typeKey.is(inputKey) || !typeValue.is(inputValue)) return false;
+    }
+
+    return true;
+  };
+  const getTypeIssues: RuntimeGetTypeIssues = (error, mode) => {
+    const mapError = error as MapError;
+    if (mapError.reason.kind !== "Entries") {
+      return singleRuntimeTypeIssue(
+        "Map",
+        error,
+        formatError as TypeErrorFormatter<TypeError>,
+      );
+    }
+
+    const allIssues = mapError.reason.issues;
+    const issues = mode === "first" ? ([allIssues[0]] as const) : allIssues;
+
+    return issues.flatMap((issue): ReadonlyArray<RuntimeTypeIssue> => {
+      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] },
+            } as TypeError),
+        formatError as TypeErrorFormatter<TypeError>,
+        [issue.kind === "ExcessProperty" ? issue.key : issue.index],
+      );
+    }) as unknown as NonEmptyReadonlyArray<RuntimeTypeIssue>;
+  };
+  const type = createTypeNode<MapType<KeyType, ValueType>>(
+    "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<
+  TypeNode,
+  WeakMap<TypeNode, TypeNode>
+>();
+
+/**
+ * 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;
+
+type MapStructuralError =
+  MapNotMapError | MapEntriesErrorValue<never, never, MapStructuralIssue>;
+
+/**
+ * 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
+    >;
+  };
+}
+
+const validateMapEntries = (
+  input: ReadonlyMap<unknown, unknown>,
+  validateKey: RuntimeOutputValidation,
+  validateValue: RuntimeOutputValidation,
+  options: ValidationOptions,
+  checkStructure: boolean,
+): Result<
+  ReadonlyMap<unknown, unknown>,
+  MapEntriesErrorValue<TypeError, TypeError, MapStructuralIssue>
+> => {
+  let issues:
+    Array<MapIssue<TypeError, TypeError, MapStructuralIssue>> | undefined;
+  const output = new Map<unknown, unknown>();
+  const inputByOutputKey = new Map<
+    unknown,
+    { readonly index: number; readonly key: unknown }
+  >();
+  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 as unknown as NonEmptyReadonlyArray<
+            MapIssue<TypeError, TypeError, MapStructuralIssue>
+          >,
+        },
+      });
+};
+
+/**
+ * Tuple {@link Type}.
+ *
+ * Use `tuple(First, Second, ...)` for a fixed-length readonly array in which
+ * every position has its own Type.
+ *
+ * `fromUnknown` validates the Tuple representation and runs every element's
+ * complete Type pipeline. By default, it returns the first issue. Pass `{
+ * errors: "all" }` to collect issues across the whole Tuple.
  *
  * `from` accepts the Tuple Output. When any element Type has a parent,
  * `from.parent` accepts a Tuple of root element Outputs and runs all remaining
@@ -7952,20 +8810,24 @@ const validateSetItems = (
  *
  * 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
@@ -8552,11 +9414,12 @@ type PlainObjectError = ObjectError<
  * 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
@@ -8631,7 +9494,7 @@ const _Object: Type<
     }
 
     return errors === undefined
-      ? ok(value as Readonly<Record<string, unknown>>)
+      ? ok(value)
       : err({
           type: "Object",
           reason: { kind: "Properties", errors },
@@ -8692,13 +9555,6 @@ const _Object: Type<
 // https://github.com/expo/expo/issues/31167
 export { _Object as Object };
 
-const isPlainObject = (value: object): boolean => {
-  const prototype: unknown = globalThis.Object.getPrototypeOf(value);
-  return (
-    prototype === null || globalThis.Object.getPrototypeOf(prototype) === null
-  );
-};
-
 /**
  * Record {@link Type}.
  *
@@ -8715,12 +9571,13 @@ const isPlainObject = (value: object): boolean => {
  * 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.
@@ -8729,6 +9586,8 @@ const isPlainObject = (value: object): boolean => {
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   Int64FromInt64String,
  *   String,
  *   record,
@@ -8744,21 +9603,22 @@ const isPlainObject = (value: object): boolean => {
  *   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
  * >();
  * ```
  *
@@ -8767,34 +9627,64 @@ const isPlainObject = (value: object): boolean => {
  * 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
@@ -8832,7 +9722,7 @@ export const record = <
     }
 
     return validateRecordEntries(
-      input as Readonly<Record<string, unknown>>,
+      input,
       validateKey as (
         value: unknown,
         options: ValidationOptions,
@@ -8911,7 +9801,7 @@ export const record = <
     encodeKey === identity && encodeValue === identity
       ? identity
       : (input: Readonly<Record<string, unknown>>) => {
-          const output = createMutableRecord<string, unknown>();
+          const output = createMutableRecord();
           let changed = false;
 
           for (const inputKey of globalThis.Object.keys(input)) {
@@ -9269,7 +10159,7 @@ const validateRecordEntries = (
 > => {
   let issues:
     Array<RecordIssue<TypeError, TypeError, RecordStructuralIssue>> | undefined;
-  const output = createMutableRecord<string, unknown>();
+  const output = createMutableRecord();
   const inputKeyByOutputKey = createMutableRecord<string, string | symbol>();
   let changed = false;
 
@@ -9376,7 +10266,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,
@@ -9384,8 +10280,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,
  * });
@@ -9442,10 +10338,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`
@@ -9458,6 +10355,8 @@ type ObjectProperty = ObjectProps[string];
  *
  * ```ts
  * import {
+ *   assertOk,
+ *   assertType,
  *   Int64FromInt64String,
  *   String,
  *   object,
@@ -9476,20 +10375,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
@@ -9497,38 +10396,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
@@ -9543,7 +10472,36 @@ export function object<const Props extends ObjectProps>(
     : [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 function object<
   const Props extends ObjectProps,
   const Rest extends RecordTypeNode & ConcreteTypeNode,
@@ -10382,12 +11340,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
  */
@@ -10547,13 +11503,20 @@ const createRecordPropertyError = <Error extends TypeError>(
  * ### 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
@@ -10603,15 +11566,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,
  * });
@@ -10675,12 +11643,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
@@ -10746,6 +11714,7 @@ type OmitKeyConcreteTypeError = CompileTimeError<
  *
  * ```ts
  * import {
+ *   assertOk,
  *   NonNegativeInt,
  *   String,
  *   object,
@@ -10763,8 +11732,8 @@ type OmitKeyConcreteTypeError = CompileTimeError<
  *   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
@@ -10831,16 +11800,31 @@ 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 Pending = typed("Pending", {
- *   label: String,
- * });
+ * const Loading = typed("Loading");
+ * const Loaded = typed("Loaded", { value: String });
+ * const State = discriminatedUnion(Loading, Loaded);
  *
- * expectOk(Pending.fromUnknown({ type: "Pending", label: "Waiting" }), {
- *   type: "Pending",
- *   label: "Waiting",
+ * 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
@@ -10849,7 +11833,24 @@ export function typed<const Tag extends TypeName>(
   tag: ValidateTypedTag<Tag>,
 ): TypedType<Tag>;
 
-/** Creates a Tagged Object Type with declared properties. */
+/**
+ * Creates a Tagged Object Type with declared properties.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertOk, String, typed } from "@evolu/common";
+ *
+ * const Pending = typed("Pending", {
+ *   label: String,
+ * });
+ *
+ * assertOk(Pending.fromUnknown({ type: "Pending", label: "Waiting" }), {
+ *   type: "Pending",
+ *   label: "Waiting",
+ * });
+ * ```
+ */
 export function typed<
   const Tag extends TypeName,
   const Props extends ObjectProps,
@@ -10861,7 +11862,35 @@ export function typed<
     : [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 function typed<
   const Tag extends TypeName,
   const Props extends ObjectProps,
@@ -10919,7 +11948,14 @@ export function typed(
  * ### 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;
@@ -10934,8 +11970,8 @@ export function typed(
  *   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
@@ -10955,6 +11991,7 @@ export interface Typed<Tag extends TypeName> {
  *
  * ```ts
  * import {
+ *   assertType,
  *   String,
  *   discriminatedUnion,
  *   typed,
@@ -10968,10 +12005,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
@@ -11029,7 +12066,7 @@ type TypedTypePropertyError = CompileTimeError<
  * ### Example
  *
  * ```ts
- * import { String, nextResult, typed } from "@evolu/common";
+ * import { assertEqual, String, nextResult, typed } from "@evolu/common";
  *
  * const StringNextResult = nextResult(
  *   String,
@@ -11047,19 +12084,21 @@ type TypedTypePropertyError = CompileTimeError<
  *   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
@@ -11135,13 +12174,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",
  * });
@@ -11162,6 +12206,7 @@ export function discriminatedUnion<
  *
  * ```ts
  * import {
+ *   assertOk,
  *   Number,
  *   String,
  *   discriminatedUnion,
@@ -11173,11 +12218,11 @@ export function discriminatedUnion<
  * 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,
  * });
@@ -11224,7 +12269,7 @@ export function discriminatedUnion(
             type: "Object",
             reason: { kind: "UnexpectedPrototype", value },
           })
-        : ok(value as Readonly<Record<string, unknown>>);
+        : ok(value);
 
     if (!objectResult.ok) {
       return err({
@@ -11242,19 +12287,19 @@ export function discriminatedUnion(
         return err({
           type: "DiscriminatedUnion",
           reason: { kind: "PropertyAccess", key, reason: "Inherited" },
-        } satisfies DiscriminatedUnionPropertyAccessError<string>);
+        } satisfies DiscriminatedUnionPropertyAccessError);
       }
       discriminator = undefined;
     } else if (!("value" in descriptor)) {
       return err({
         type: "DiscriminatedUnion",
         reason: { kind: "PropertyAccess", key, reason: "Accessor" },
-      } satisfies DiscriminatedUnionPropertyAccessError<string>);
+      } satisfies DiscriminatedUnionPropertyAccessError);
     } else if (!descriptor.enumerable) {
       return err({
         type: "DiscriminatedUnion",
         reason: { kind: "PropertyAccess", key, reason: "NonEnumerable" },
-      } satisfies DiscriminatedUnionPropertyAccessError<string>);
+      } satisfies DiscriminatedUnionPropertyAccessError);
     } else {
       discriminator = descriptor.value;
     }
@@ -11778,15 +12823,18 @@ type RuntimeDiscriminatedUnionMember = RuntimeObjectTypeNode & {
  *
  * 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,
@@ -11816,11 +12864,11 @@ type RuntimeDiscriminatedUnionMember = RuntimeObjectTypeNode & {
  *   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
@@ -11963,58 +13011,610 @@ export interface LazyType<
   Type<"Lazy", Input, Input, InputError, null, InputError, never, Input>,
   Errors,
   never,
-  CanonicalInput,
-  UsesIdentityEncoding
-> {
-  readonly [lazyTypeSymbol]: true;
-  /** Formats an error returned by any Lazy Type decoding operation. */
-  readonly formatError: TypeErrorFormatter<Errors | FromError>;
+  CanonicalInput,
+  UsesIdentityEncoding
+> {
+  readonly [lazyTypeSymbol]: true;
+  /** Formats an error returned by any Lazy Type decoding operation. */
+  readonly formatError: TypeErrorFormatter<Errors | FromError>;
+}
+
+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."
+>;
+
+type LazyResolution =
+  | { readonly state: "unresolved" }
+  | { readonly state: "resolving" }
+  | ResolvedLazyType
+  | { readonly state: "failed"; readonly error: unknown };
+
+interface ResolvedLazyType {
+  readonly state: "resolved";
+  readonly target: RuntimeTypeNode;
+  readonly targetFromInput: RuntimeOperation<Result<unknown, TypeError>>;
+  readonly root: RuntimeTypeNode;
+}
+
+const lazyTypeNodes = /*#__PURE__*/ new WeakSet<TypeNode>();
+
+const assertLazyReferencesAreGuarded = (type: RuntimeTypeNode): void => {
+  for (;;) {
+    assert(
+      !lazyTypeNodes.has(type),
+      "A Lazy Type definition must place every Lazy Type behind a structural boundary.",
+    );
+
+    if ("members" in type && Array.isArray(type.members)) {
+      for (const member of type.members as ReadonlyArray<RuntimeTypeNode>)
+        assertLazyReferencesAreGuarded(member);
+    }
+
+    if ("output" in type) {
+      assertLazyReferencesAreGuarded(type.output as RuntimeTypeNode);
+    }
+
+    if (!type.parent) return;
+    type = type.parent as RuntimeTypeNode;
+  }
+};
+
+/**
+ * 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
+> {}
+
+interface DataPathNode {
+  readonly parent: DataPathNode | null;
+  readonly key: PropertyKey;
 }
 
-type ValidateLazyTarget<Target extends ConcreteTypeNode> =
-  IsUnion<Target> extends false ? Target : LazyTargetConcreteTypeError;
+interface DataWork {
+  readonly value: unknown;
+  readonly path: DataPathNode | null;
+}
 
-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."
->;
+const emptyDataPath: ReadonlyArray<PropertyKey> =
+  /*#__PURE__*/ globalThis.Object.freeze([]);
 
-type LazyResolution =
-  | { readonly state: "unresolved" }
-  | { readonly state: "resolving" }
-  | ResolvedLazyType
-  | { readonly state: "failed"; readonly error: unknown };
+const dataPathToArray = (
+  path: DataPathNode | null,
+): ReadonlyArray<PropertyKey> => {
+  if (path === null) return emptyDataPath;
 
-interface ResolvedLazyType {
-  readonly state: "resolved";
-  readonly target: RuntimeTypeNode;
-  readonly targetFromInput: RuntimeOperation<Result<unknown, TypeError>>;
-  readonly root: RuntimeTypeNode;
-}
+  const keys: Array<PropertyKey> = [];
+  let node: DataPathNode | null = path;
 
-const lazyTypeNodes = /*#__PURE__*/ new WeakSet<TypeNode>();
+  while (node !== null) {
+    keys.push(node.key);
+    node = node.parent;
+  }
 
-const assertLazyReferencesAreGuarded = (type: RuntimeTypeNode): void => {
-  for (;;) {
-    assert(
-      !lazyTypeNodes.has(type),
-      "A Lazy Type definition must place every Lazy Type behind a structural boundary.",
-    );
+  keys.reverse();
+  return globalThis.Object.freeze(keys);
+};
 
-    if ("members" in type && globalThis.Array.isArray(type.members)) {
-      for (const member of type.members as ReadonlyArray<RuntimeTypeNode>)
-        assertLazyReferencesAreGuarded(member);
+const dataChildPath = (
+  parent: DataPathNode | null,
+  key: PropertyKey,
+): DataPathNode => ({ parent, key });
+
+const validateData = (
+  value: unknown,
+  options: ValidationOptions = firstValidationOptions,
+): Result<Data, DataError> => {
+  const work: Array<DataWork> = [{ value, path: null }];
+  const visited = new WeakSet<object>();
+  let issues: Array<DataIssue> | undefined;
+
+  const addIssue = (issue: DataIssue): boolean => {
+    (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;
 
-    if ("output" in type) {
-      assertLazyReferencesAreGuarded(type.output as RuntimeTypeNode);
+    const children: Array<DataWork> = [];
+    const kind = getObjectKind(value);
+
+    if (kind === "Array") {
+      const array = value as ReadonlyArray<unknown>;
+      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 as globalThis.Uint8Array,
+        );
+      } catch {
+        if (
+          addIssue({
+            kind: "InvalidUint8Array",
+            path: dataPathToArray(path),
+            value: value as globalThis.Uint8Array,
+          })
+        ) {
+          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 as ReadonlySet<unknown>) {
+        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 as ReadonlyMap<unknown, unknown>) {
+        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 (!type.parent) return;
-    type = type.parent as RuntimeTypeNode;
+    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 as Data)
+    : err({
+        type: "Data",
+        reason: {
+          kind: "Issues",
+          issues: globalThis.Object.freeze(
+            issues,
+          ) as unknown as NonEmptyReadonlyArray<DataIssue>,
+        },
+      });
+};
+
+const getDataRuntimeTypeIssues: RuntimeGetTypeIssues = (error, mode) => {
+  const dataError = error as DataError;
+  const issues =
+    mode === "first"
+      ? ([dataError.reason.issues[0]] as const)
+      : 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: DataError) => {
+      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.`;
+      }
+    }) as TypeErrorFormatter<TypeError>,
+  })) as unknown as NonEmptyReadonlyArray<RuntimeTypeIssue>;
 };
 
+/**
+ * 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: DataType = /*#__PURE__*/ createTypeNode<DataType>(
+  "Data",
+  null,
+  validateData,
+  (value) => validateData(value).ok,
+  validateData,
+  ok,
+  identity,
+  getDataRuntimeTypeIssues,
+);
+
 /**
  * A candidate JSON value before exact runtime validation.
  *
@@ -12260,6 +13860,7 @@ const validateJsonValue = (
     }
     if (typeof value === "number") {
       if (!globalThis.Number.isFinite(value)) {
+        // oxlint-disable-next-line unicorn/no-lonely-if -- Keep issue construction separate from the finite-number guard.
         if (
           addIssue({
             kind: "NonFiniteNumber",
@@ -12285,7 +13886,7 @@ const validateJsonValue = (
       continue;
     }
 
-    const isArray = globalThis.Array.isArray(value);
+    const isArray = Array.isArray(value);
 
     if (!isArray && !isPlainObject(value)) {
       if (
@@ -12491,8 +14092,7 @@ const getJsonValueRuntimeTypeIssues: RuntimeGetTypeIssues = (error, mode) => {
   })) as unknown as NonEmptyReadonlyArray<RuntimeTypeIssue>;
 };
 
-const parseJson = (value: string): JsonValue =>
-  globalThis.JSON.parse(value) as JsonValue;
+const parseJson = (value: string): JsonValue => JSON.parse(value) as JsonValue;
 
 const jsonToJsonValueResult = (value: string): Result<JsonValue, JsonError> => {
   const result = trySync((): unknown => parseJson(value));
@@ -12521,9 +14121,10 @@ const stringifyJsonValue = (value: JsonValue): Json => {
       continue;
     }
 
+    // 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(
@@ -12534,7 +14135,7 @@ const stringifyJsonValue = (value: JsonValue): Json => {
         chunks.push(value ? "true" : "false");
         break;
       case "object": {
-        if (globalThis.Array.isArray(value)) {
+        if (Array.isArray(value)) {
           const array = value as JsonArray;
           chunks.push("[");
           work.push({ kind: "Text", value: "]" });
@@ -12557,7 +14158,7 @@ const stringifyJsonValue = (value: JsonValue): Json => {
           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: "," });
         }
@@ -12575,7 +14176,12 @@ const stringifyJsonValue = (value: JsonValue): Json => {
  * ### Example
  *
  * ```ts
- * import { JsonValue, type JsonValueInput } from "@evolu/common";
+ * import {
+ *   assertOk,
+ *   assertType,
+ *   JsonValue,
+ *   type JsonValueInput,
+ * } from "@evolu/common";
  *
  * const input: JsonValueInput = {
  *   name: "Ada",
@@ -12583,8 +14189,8 @@ const stringifyJsonValue = (value: JsonValue): Json => {
  * };
  * const result = JsonValue.fromUnknown(input);
  *
- * expectOk(result, input);
- * expectTypeOf(result.value).toEqualTypeOf<JsonValue>();
+ * assertOk(result, input);
+ * assertType<JsonValue, typeof result.value>();
  * ```
  *
  * @group JSON
@@ -12646,11 +14252,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
@@ -12663,11 +14269,15 @@ export const jsonToJsonValue = (value: Json): JsonValue => 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
@@ -12684,12 +14294,12 @@ export 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
@@ -12716,6 +14326,8 @@ export const JsonValueFromJson = /*#__PURE__*/ transform(
  *
  * ```ts
  * import {
+ *   assertEqual,
+ *   assertType,
  *   Age,
  *   NonEmptyTrimmedString100,
  *   json,
@@ -12736,11 +14348,13 @@ export const JsonValueFromJson = /*#__PURE__*/ transform(
  * 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
@@ -12932,14 +14546,12 @@ type JsonCompatibleMember<
 
 type AllowedJsonArrayKeys<Value extends ReadonlyArray<unknown>> =
   | keyof ReadonlyArray<unknown>
-  | (Value extends globalThis.Array<unknown>
-      ? keyof globalThis.Array<unknown>
-      : never)
+  | (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 globalThis.Array<unknown>>
+    ? Exclude<keyof Elements, keyof Array<unknown>>
     : never;
 
 type IsJsonCompatibilityCycle<
@@ -12951,17 +14563,6 @@ type IsJsonCompatibilityCycle<
     : IsJsonCompatibilityCycle<Value, Rest>
   : false;
 
-/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters -- The
-generic-function comparison distinguishes recursive types that mutual
-assignability cannot. */
-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;
-/* eslint-enable @typescript-eslint/no-unnecessary-type-parameters */
-
 type JsonNumberCompatible<Value extends number> = [Value] extends [FiniteNumber]
   ? true
   : [Value] extends [Brand<string>]