@evolu/common 8.10.0 → 8.11.0

package/dist/src/Type.d.ts

@@ -353,9 +353,6 @@ export interface TypeError<Name extends TypeName = TypeName> {
     readonly type: Name;
 }
 declare const transparentTypeErrorSymbol: unique symbol;
-interface TransparentTypeError {
-    readonly [transparentTypeErrorSymbol]?: true;
-}
 /**
  * A structured error that directly describes a rejected value.
  *
@@ -373,6 +370,39 @@ export interface TypeValueError<Name extends TypeName = TypeName> extends TypeEr
  * @group Core
  */
 export type TypeErrorFormatter<Error extends TypeError> = (error: Error) => string;
+/**
+ * The common structural shape of every {@link Type}, with its specific type
+ * parameters erased.
+ *
+ * @group Core
+ */
+export interface TypeNode {
+    readonly name: TypeName;
+    readonly "~standard": StandardSchemaV1.Props<unknown, unknown>;
+    /** A type-only phantom property that does not exist at runtime. */
+    readonly Input: unknown;
+    /** A type-only phantom property that does not exist at runtime. */
+    readonly CanonicalInput: unknown;
+    /** A type-only phantom property that does not exist at runtime. */
+    readonly Output: unknown;
+    /** A type-only phantom property that does not exist at runtime. */
+    readonly Error: TypeError;
+    readonly [errorsSymbol]: TypeError;
+    readonly [customFromSymbol]: unknown;
+    readonly [identityEncodingSymbol]: boolean;
+    readonly parent: TypeNode | null;
+    readonly fromUnknown: (value: unknown, options?: ValidationOptions) => Result<unknown, TypeError>;
+    readonly is: (value: unknown) => boolean;
+}
+/**
+ * Configures how container {@link Type} operations report errors.
+ *
+ * @group Core
+ */
+export interface ValidationOptions {
+    /** Controls whether container {@link Type} operations return one or all errors. */
+    readonly errors: "first" | "all";
+}
 /**
  * A formatted validation issue located by its path from the root value.
  *
@@ -418,28 +448,16 @@ export interface TypeIssue {
  */
 export declare const typeErrorToIssues: <T extends TypeNode>(type: T, error: InferErrors<NoInfer<T>>) => NonEmptyReadonlyArray<TypeIssue>;
 /**
- * The common structural shape of every {@link Type}, with its specific type
- * parameters erased.
+ * Marks a {@link TypeError} that wraps one nested error in `outputError` or
+ * `error`.
+ *
+ * {@link localizeTypes} requires formatters for the nested error instead of the
+ * wrapper. The marker property exists only in TypeScript.
  *
  * @group Core
  */
-export interface TypeNode {
-    readonly name: TypeName;
-    readonly "~standard": StandardSchemaV1.Props<unknown, unknown>;
-    /** A type-only phantom property that does not exist at runtime. */
-    readonly Input: unknown;
-    /** A type-only phantom property that does not exist at runtime. */
-    readonly CanonicalInput: unknown;
-    /** A type-only phantom property that does not exist at runtime. */
-    readonly Output: unknown;
-    /** A type-only phantom property that does not exist at runtime. */
-    readonly Error: TypeError;
-    readonly [errorsSymbol]: TypeError;
-    readonly [customFromSymbol]: unknown;
-    readonly [identityEncodingSymbol]: boolean;
-    readonly parent: TypeNode | null;
-    readonly fromUnknown: (value: unknown, options?: ValidationOptions) => Result<unknown, TypeError>;
-    readonly is: (value: unknown) => boolean;
+export interface TransparentTypeError {
+    readonly [transparentTypeErrorSymbol]?: true;
 }
 declare const outputValidationSymbolType: unique symbol;
 declare const getRuntimeTypeIssuesSymbolType: unique symbol;
@@ -455,7 +473,7 @@ interface RuntimeTypeIssue {
         readonly issues: NonEmptyReadonlyArray<RuntimeTypeIssue>;
     }>;
 }
-type RuntimeGetTypeIssues = (error: TypeError, mode: ValidationOptions["errors"]) => NonEmptyReadonlyArray<RuntimeTypeIssue>;
+type RuntimeGetTypeIssues = (error: TypeError, mode: ValidationOptions["errors"], path: ReadonlyArray<PropertyKey>) => NonEmptyReadonlyArray<RuntimeTypeIssue>;
 /**
  * Asserts type equality or validates a value with a {@link Type}.
  *
@@ -775,23 +793,30 @@ type DeepestFromOperation<Operation> = Operation extends {
 type NonRootErrors<T extends TypeNode> = T extends {
     readonly parent: infer Parent extends TypeNode;
 } ? T["Error"] | NonRootErrors<Parent> : never;
-interface FromParentOperations<Output, Error extends TypeError, Boundary extends TypeNode> {
+/**
+ * The `.parent` suffixes of a {@link Type} `from` operation.
+ *
+ * Each `.parent` accepts the Output of the next Type toward the root and
+ * returns the errors of every boundary it adds.
+ *
+ * @group Core
+ */
+export interface FromParentOperations<Output, Error extends TypeError, Boundary extends TypeNode> {
     readonly parent: TypeOperationFn<"from", Boundary["Output"], Output, Error> & ([Boundary["parent"]] extends [infer Parent extends TypeNode] ? FromParentOperations<Output, Error | Boundary["Error"], Parent> : unknown);
 }
 type ToOperation<Output, Input, Parent extends TypeNode> = ((value: Output) => Input) & ToParentOperations<Output, Parent>;
-interface ToParentOperations<Output, Boundary extends TypeNode> {
-    readonly parent: ((value: Output) => Boundary["Output"]) & ([Boundary["parent"]] extends [infer Parent extends TypeNode] ? ToParentOperations<Output, Parent> : unknown);
-}
-type TypeOperationFn<Kind extends "from" | "orThrow" | "orNull", Input, Output, Error extends TypeError> = Kind extends "orNull" ? (value: Input) => Output | null : (value: Input, options?: ValidationOptions) => Kind extends "from" ? Result<Output, Error> : Output;
 /**
- * Configures how container {@link Type} operations report errors.
+ * The `.parent` suffixes of a {@link Type} `to` operation.
+ *
+ * Each `.parent` encodes an Output only as far as the Output of the next Type
+ * toward the root.
  *
  * @group Core
  */
-export interface ValidationOptions {
-    /** Controls whether container {@link Type} operations return one or all errors. */
-    readonly errors: "first" | "all";
+export interface ToParentOperations<Output, Boundary extends TypeNode> {
+    readonly parent: ((value: Output) => Boundary["Output"]) & ([Boundary["parent"]] extends [infer Parent extends TypeNode] ? ToParentOperations<Output, Parent> : unknown);
 }
+type TypeOperationFn<Kind extends "from" | "orThrow" | "orNull", Input, Output, Error extends TypeError> = Kind extends "orNull" ? (value: Input) => Output | null : (value: Input, options?: ValidationOptions) => Kind extends "from" ? Result<Output, Error> : Output;
 type ConcreteTypeNode = AnyType;
 declare const validationFailureSymbol: unique symbol;
 interface ValidationFailure<Error> {
@@ -953,6 +978,31 @@ export declare function createType<Name extends TypeName, ParentType extends Con
  * @group Construction
  */
 export declare const createTypeWithError: <Name extends TypeName, T extends ConcreteTypeNode, Error extends TypeError<Name>>(name: Name & ValidateConcreteTypeName<Name>, type: T & ValidateOutput<T> & (IdentityEncodingOf<T> extends true ? unknown : CompileTimeError<"Type", "Source Type must use identity encoding.">), mapError: (error: InferErrors<T>, value: unknown) => Error, formatError: TypeErrorFormatter<NoInfer<Error>>) => Type<Name, T["Output"], T["Output"], Error>;
+/**
+ * The {@link Type} returned by {@link transform}.
+ *
+ * @group Construction
+ */
+export interface TransformType<ParentType extends TypeNode, OutputType extends TypeNode, Name extends TypeName, FromError extends TypeError<Name>, ToOutput extends ParentType["Output"] = ParentType["Output"]> extends Type<Name, ParentType["Input"], OutputType["Output"], TransformError<Name, FromError, TypeFromError<OutputType>>, ParentType, TransformError<Name, FromError, TypeFromError<OutputType>> | InferErrors<ParentType>, ChildCustomFrom<ParentType, OutputType["Output"], TransformError<Name, FromError, TypeFromError<OutputType>>>, CanonicalInputForChild<ParentType, ToOutput>, false> {
+    readonly [reflectedTypesSymbol]?: OutputType;
+    readonly output: OutputType;
+}
+/**
+ * An error produced by {@link transform} while decoding or validating its
+ * output.
+ *
+ * @group Construction
+ */
+export type TransformError<Name extends TypeName, OwnError extends TypeError<Name>, OutputError extends TypeError> = OwnError | ([OutputError] extends [never] ? never : TransformOutputError<Name, OutputError>);
+/**
+ * Wraps an error produced by the output {@link Type} of {@link transform}.
+ *
+ * @group Construction
+ */
+export interface TransformOutputError<Name extends TypeName, OutputError extends TypeError> extends TypeError<Name>, TransparentTypeError {
+    /** The error returned by the output Type. */
+    readonly outputError: OutputError;
+}
 /**
  * Transform {@link Type}.
  *
@@ -1075,31 +1125,6 @@ export declare function transform<Name extends TypeName, ParentType extends Conc
     readonly from: (value: ParentType["Output"]) => Result<OutputType["Input"], FromError>;
     readonly to: (value: CanonicalInputOf<OutputType>) => ToOutput;
 }, formatError: [FromError] extends [never] ? never : TypeErrorFormatter<NoInfer<FromError>>): TransformType<ParentType, OutputType, Name, FromError, ToOutput>;
-/**
- * The {@link Type} returned by {@link transform}.
- *
- * @group Construction
- */
-export interface TransformType<ParentType extends TypeNode, OutputType extends TypeNode, Name extends TypeName, FromError extends TypeError<Name>, ToOutput extends ParentType["Output"] = ParentType["Output"]> extends Type<Name, ParentType["Input"], OutputType["Output"], TransformError<Name, FromError, TypeFromError<OutputType>>, ParentType, TransformError<Name, FromError, TypeFromError<OutputType>> | InferErrors<ParentType>, ChildCustomFrom<ParentType, OutputType["Output"], TransformError<Name, FromError, TypeFromError<OutputType>>>, CanonicalInputForChild<ParentType, ToOutput>, false> {
-    readonly [reflectedTypesSymbol]?: OutputType;
-    readonly output: OutputType;
-}
-/**
- * An error produced by {@link transform} while decoding or validating its
- * output.
- *
- * @group Construction
- */
-export type TransformError<Name extends TypeName, OwnError extends TypeError<Name>, OutputError extends TypeError> = OwnError | ([OutputError] extends [never] ? never : TransformOutputError<Name, OutputError>);
-/**
- * Wraps an error produced by the output {@link Type} of {@link transform}.
- *
- * @group Construction
- */
-export interface TransformOutputError<Name extends TypeName, OutputError extends TypeError> extends TypeError<Name>, TransparentTypeError {
-    /** The error returned by the output Type. */
-    readonly outputError: OutputError;
-}
 type DeepestFromError<Operation> = DeepestFromOperation<Operation> extends (...args: ReadonlyArray<never>) => infer R ? R extends {
     readonly ok: false;
     readonly error: infer Error extends TypeError;
@@ -1114,6 +1139,10 @@ declare const encoderSymbolType: unique symbol;
 declare const fromSymbolType: unique symbol;
 declare const templateLiteralSyntaxSymbolType: unique symbol;
 declare const templateLiteralSyntaxSymbol: typeof templateLiteralSyntaxSymbolType;
+declare const checkSymbolType: unique symbol;
+declare const refinementsSymbolType: unique symbol;
+type RuntimeCheck = (value: unknown, options: ValidationOptions) => TypeError | undefined;
+type Refinement = (value: unknown) => Result<unknown, TypeError>;
 /**
  * Type-erased {@link Type} used to traverse and invoke heterogeneous Type nodes
  * at runtime.
@@ -1130,6 +1159,8 @@ type RuntimeTypeNode = Omit<TypeNode, typeof customFromSymbol> & {
     readonly [fromSymbolType]: RuntimeOperation<Result<unknown, TypeError>>;
     readonly [encoderSymbolType]: RuntimeEncoder;
     readonly [getRuntimeTypeIssuesSymbolType]: RuntimeGetTypeIssues;
+    readonly [checkSymbolType]: RuntimeCheck | undefined;
+    readonly [refinementsSymbolType]: ReadonlyArray<Refinement> | undefined;
     readonly [templateLiteralSyntaxSymbolType]?: true;
 };
 /**
@@ -1138,6 +1169,14 @@ type RuntimeTypeNode = Omit<TypeNode, typeof customFromSymbol> & {
  * @group Base
  */
 export declare const Unknown: Type<"Unknown", unknown, unknown, never, null, never, never, unknown, true>;
+/**
+ * Error returned by {@link Never} for every value.
+ *
+ * @group Base
+ */
+export interface NeverError extends TypeError<"Never"> {
+    readonly value: unknown;
+}
 /**
  * A {@link Type} rejecting every value.
  *
@@ -1145,11 +1184,12 @@ export declare const Unknown: Type<"Unknown", unknown, unknown, never, null, nev
  */
 export declare const Never: Type<"Never", never, never, NeverError, null, NeverError, never, never, true>;
 /**
- * Error returned by {@link Never} for every value.
+ * Error returned when `typeof` does not match the expected JavaScript type.
  *
  * @group Base
  */
-export interface NeverError extends TypeError<"Never"> {
+export interface TypeOfError<Name extends keyof TypeOfOutputByName> extends TypeError<"TypeOf"> {
+    readonly expected: Name;
     readonly value: unknown;
 }
 interface TypeOfOutputByName {
@@ -1160,15 +1200,6 @@ interface TypeOfOutputByName {
     readonly Symbol: symbol;
     readonly Function: globalThis.Function;
 }
-/**
- * Error returned when `typeof` does not match the expected JavaScript type.
- *
- * @group Base
- */
-export interface TypeOfError<Name extends keyof TypeOfOutputByName> extends TypeError<"TypeOf"> {
-    readonly expected: Name;
-    readonly value: unknown;
-}
 /**
  * A JavaScript string {@link Type} without additional constraints.
  *
@@ -1348,15 +1379,6 @@ export declare const Symbol: Type<"Symbol", symbol, symbol, TypeOfError<"Symbol"
  * @group Base
  */
 export declare const Function: Type<"Function", Function, Function, TypeOfError<"Function">, null, TypeOfError<"Function">, never, Function, true>;
-/**
- * A {@link Type} validating Evolu Type declarations.
- *
- * This is useful when a Type itself crosses an unknown boundary or must be
- * asserted with {@link assertType}.
- *
- * @group Core
- */
-export declare const EvoluType: Type<"EvoluType", AnyType, AnyType, EvoluTypeError, null, EvoluTypeError, never, AnyType, true>;
 /**
  * Any concrete {@link Type}, regardless of its particular type parameters.
  *
@@ -1379,6 +1401,15 @@ export interface AnyType extends TypeNode {
  */
 export interface EvoluTypeError extends TypeValueError<"EvoluType"> {
 }
+/**
+ * A {@link Type} validating Evolu Type declarations.
+ *
+ * This is useful when a Type itself crosses an unknown boundary or must be
+ * asserted with {@link assertType}.
+ *
+ * @group Core
+ */
+export declare const EvoluType: Type<"EvoluType", AnyType, AnyType, EvoluTypeError, null, EvoluTypeError, never, AnyType, true>;
 /**
  * Nominal evidence that a value has one object tag.
  *
@@ -1407,11 +1438,6 @@ export interface ObjectTagError<Expected extends TypeName = TypeName> extends Ty
     readonly expected: Expected;
     readonly value: unknown;
 }
-interface ObjectTagOutputByName {
-    readonly Date: globalThis.Date;
-    readonly Uint8Array: globalThis.Uint8Array;
-    readonly ArrayBuffer: globalThis.ArrayBuffer;
-}
 /**
  * Realm-neutral {@link Type} trusting an object's reported tag.
  *
@@ -1481,6 +1507,11 @@ export declare function objectTag<Name extends keyof ObjectTagOutputByName>(name
 export declare function objectTag<Name extends TypeName, OutputType extends ConcreteTypeNode & {
     readonly Output: object;
 }>(name: ValidateConcreteTypeName<Name>, outputType: ValidateOutput<OutputType> & ([ChildTypeNameValidationError<"ObjectTag", OutputType>] extends [never] ? unknown : ChildTypeNameValidationError<"ObjectTag", OutputType>)): ObjectTagType<Name, OutputType>;
+interface ObjectTagOutputByName {
+    readonly Date: globalThis.Date;
+    readonly Uint8Array: globalThis.Uint8Array;
+    readonly ArrayBuffer: globalThis.ArrayBuffer;
+}
 declare const objectTagSymbol: unique symbol;
 /**
  * A realm-neutral JavaScript Date {@link Type} for trusted values.
@@ -1508,6 +1539,30 @@ export declare const Uint8Array: Type<"Uint8Array", Uint8Array<ArrayBufferLike>,
  * @group Base
  */
 export declare const ArrayBuffer: Type<"ArrayBuffer", ArrayBuffer, ArrayBuffer, ObjectTagError<"ArrayBuffer">, null, ObjectTagError<"ArrayBuffer">, never, ArrayBuffer, true>;
+/**
+ * The {@link Type} returned by {@link instanceOf}.
+ *
+ * @group Base
+ */
+export interface InstanceOfType<Constructor extends InstanceConstructor> extends Type<"InstanceOf", InstanceOfOutput<Constructor>, InstanceOfOutput<Constructor>, InstanceOfError, null, InstanceOfError, never, InstanceOfOutput<Constructor>> {
+    readonly constructor: Constructor;
+}
+/**
+ * A JavaScript class constructor accepted by {@link instanceOf}.
+ *
+ * @group Base
+ */
+export type InstanceConstructor<Instance extends object = object> = (abstract new (...args: ReadonlyArray<never>) => Instance) & {
+    readonly name: string;
+};
+/**
+ * Error returned when a value is not an instance of the expected constructor.
+ *
+ * @group Base
+ */
+export interface InstanceOfError extends TypeValueError<"InstanceOf"> {
+    readonly constructorName: string;
+}
 /**
  * Instance {@link Type} for one constructor.
  *
@@ -1539,33 +1594,9 @@ export declare const ArrayBuffer: Type<"ArrayBuffer", ArrayBuffer, ArrayBuffer,
  * @group Base
  */
 export declare const instanceOf: <Constructor extends InstanceConstructor>(constructor: ValidateInstanceConstructor<Constructor>) => InstanceOfType<Constructor>;
-/**
- * A JavaScript class constructor accepted by {@link instanceOf}.
- *
- * @group Base
- */
-export type InstanceConstructor<Instance extends object = object> = (abstract new (...args: ReadonlyArray<never>) => Instance) & {
-    readonly name: string;
-};
-/**
- * The {@link Type} returned by {@link instanceOf}.
- *
- * @group Base
- */
-export interface InstanceOfType<Constructor extends InstanceConstructor> extends Type<"InstanceOf", InstanceOfOutput<Constructor>, InstanceOfOutput<Constructor>, InstanceOfError, null, InstanceOfError, never, InstanceOfOutput<Constructor>> {
-    readonly constructor: Constructor;
-}
 type InstanceOfOutput<Constructor extends InstanceConstructor> = Constructor extends {
     readonly prototype: infer Output extends object;
 } ? Output : InstanceType<Constructor>;
-/**
- * Error returned when a value is not an instance of the expected constructor.
- *
- * @group Base
- */
-export interface InstanceOfError extends TypeValueError<"InstanceOf"> {
-    readonly constructorName: string;
-}
 type ValidateInstanceConstructor<Constructor extends InstanceConstructor> = IsUnion<Constructor> extends false ? "prototype" extends keyof Constructor ? Constructor : InstanceConstructorCompileTimeError : InstanceConstructorCompileTimeError;
 type InstanceConstructorCompileTimeError = CompileTimeError<"Type", "Constructor must preserve one concrete constructor. Create a Union Type from separate Instance Types instead of passing a union or erased constructor.">;
 /**
@@ -1596,6 +1627,24 @@ type InstanceConstructorCompileTimeError = CompileTimeError<"Type", "Constructor
  * @group Unions
  */
 export type ValidateLiteral<Expected extends Literal> = IsUnion<Expected> extends false ? {} extends Readonly<Record<`${Expected}`, never>> ? LiteralCompileTimeError : Expected : LiteralCompileTimeError;
+/**
+ * The {@link Type} returned by {@link literal}.
+ *
+ * @group Unions
+ */
+export interface LiteralType<Expected extends Literal> extends Type<"Literal", WidenLiteral<Expected>, Expected, LiteralError<Expected>, LiteralParent<Expected>, LiteralError<Expected> | LiteralParentErrors<Expected>, never, CanonicalInputSubset<WidenLiteral<Expected>, CanonicalInputForParent<LiteralParent<Expected>, Expected>>, IdentityEncodingForParent<LiteralParent<Expected>>> {
+    readonly [templateLiteralSyntaxSymbol]: true;
+    readonly expected: Expected;
+}
+/**
+ * Error returned when a value does not equal the expected literal.
+ *
+ * @group Unions
+ */
+export interface LiteralError<Expected extends Literal = Literal> extends TypeError<"Literal"> {
+    readonly expected: Expected;
+    readonly value: unknown;
+}
 /**
  * Literal {@link Type}.
  *
@@ -1638,27 +1687,9 @@ export type ValidateLiteral<Expected extends Literal> = IsUnion<Expected> extend
  * @group Unions
  */
 export declare const literal: <const Expected extends Literal>(expected: ValidateLiteral<Expected>) => LiteralType<Expected>;
-/**
- * The {@link Type} returned by {@link literal}.
- *
- * @group Unions
- */
-export interface LiteralType<Expected extends Literal> extends Type<"Literal", WidenLiteral<Expected>, Expected, LiteralError<Expected>, LiteralParent<Expected>, LiteralError<Expected> | LiteralParentErrors<Expected>, never, CanonicalInputSubset<WidenLiteral<Expected>, CanonicalInputForParent<LiteralParent<Expected>, Expected>>, IdentityEncodingForParent<LiteralParent<Expected>>> {
-    readonly [templateLiteralSyntaxSymbol]: true;
-    readonly expected: Expected;
-}
 type LiteralParent<Expected extends Literal> = Expected extends string ? typeof String : Expected extends number ? typeof Number : Expected extends bigint ? typeof BigInt : Expected extends boolean ? typeof Boolean : null;
 type LiteralParentErrors<Expected extends Literal> = LiteralParent<Expected> extends infer Parent extends TypeNode ? InferErrors<Parent> : never;
 type LiteralCompileTimeError = CompileTimeError<"Type", "Expected must be one concrete literal value.">;
-/**
- * Error returned when a value does not equal the expected literal.
- *
- * @group Unions
- */
-export interface LiteralError<Expected extends Literal = Literal> extends TypeError<"Literal"> {
-    readonly expected: Expected;
-    readonly value: unknown;
-}
 /**
  * Literal {@link Type} accepting only `undefined`.
  *
@@ -1672,7 +1703,47 @@ export declare const Undefined: LiteralType<undefined>;
  */
 export declare const Null: LiteralType<null>;
 /**
- * Union {@link Type}.
+ * The {@link Type} returned by {@link union}.
+ *
+ * @group Unions
+ */
+export interface UnionType<Members extends AtLeastTwoReadonlyArray<TypeNode>> extends Type<"Union", Members[number]["Input"], Members[number]["Output"], UnionTypeError<Members>, UnionInputParent<Members>, UnionTypeError<Members>, never, CanonicalInputOf<Members[number]>, AllTypesUseIdentityEncoding<Members[number]>> {
+    readonly [templateLiteralSyntaxSymbol]: true;
+    readonly [reflectedTypesSymbol]?: Members[number];
+    readonly members: Members;
+}
+/**
+ * A root {@link Type} validating the encoded Inputs accepted by {@link union}.
+ *
+ * @group Unions
+ */
+export type UnionInputType<Input, Error extends TypeError> = Type<"Union", Input, Input, Error, null, Error, never, Input>;
+/**
+ * Error returned when every member of a {@link union} rejects an input.
+ *
+ * @group Unions
+ */
+export type UnionError<Error extends TypeError = TypeError, MemberError extends UnionMemberError<Error> = UnionMemberError<Error>> = [Error] extends [never] ? never : UnionErrorValue<Error, MemberError>;
+/**
+ * The shape of {@link UnionError} when at least one {@link union} member can
+ * fail.
+ *
+ * @group Unions
+ */
+export interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemberError<Error> = UnionMemberError<Error>> extends TypeError<"Union"> {
+    readonly errors: NonEmptyReadonlyArray<MemberError>;
+}
+/**
+ * An error returned by one {@link union} member and its index.
+ *
+ * @group Unions
+ */
+export interface UnionMemberError<Error extends TypeError, Index extends number = number> {
+    readonly index: Index;
+    readonly error: Error;
+}
+/**
+ * Union {@link Type}.
  *
  * Use `union(A, B)` when a value may match any one of several Types. Literal
  * values can be passed directly as shorthand for their corresponding
@@ -1819,43 +1890,12 @@ type UnionMemberConcreteTypeError = CompileTimeError<"Type", "Union member must
 type NormalizeUnionMembers<Members extends AtLeastTwoReadonlyArray<TypeNode | Literal>> = {
     readonly [Index in keyof Members]: Members[Index] extends TypeNode ? Members[Index] : Members[Index] extends Literal ? LiteralType<Members[Index]> : never;
 } extends infer Normalized extends AtLeastTwoReadonlyArray<TypeNode> ? Normalized : never;
-/**
- * The {@link Type} returned by {@link union}.
- *
- * @group Unions
- */
-export interface UnionType<Members extends AtLeastTwoReadonlyArray<TypeNode>> extends Type<"Union", Members[number]["Input"], Members[number]["Output"], UnionTypeError<Members>, UnionInputParent<Members>, UnionTypeError<Members>, never, CanonicalInputOf<Members[number]>, AllTypesUseIdentityEncoding<Members[number]>> {
-    readonly [templateLiteralSyntaxSymbol]: true;
-    readonly [reflectedTypesSymbol]?: Members[number];
-    readonly members: Members;
-}
-/**
- * A root {@link Type} validating the encoded Inputs accepted by {@link union}.
- *
- * @group Unions
- */
-export type UnionInputType<Input, Error extends TypeError> = Type<"Union", Input, Input, Error, null, Error, never, Input>;
 type UnionInputParent<Members extends AtLeastTwoReadonlyArray<TypeNode>> = UnionMembersAreLiterals<Members> extends true ? LiteralUnionInputParent<Members> : UnionInputType<Members[number]["Input"], UnionInputTypeError<Members>>;
 type LiteralUnionInputParent<Members extends AtLeastTwoReadonlyArray<TypeNode>, Parents = Members[number]["parent"]> = [Parents] extends [infer Parent extends TypeNode] ? IsUnion<Parent> extends true ? UnionInputType<Members[number]["Input"], UnionInputTypeError<Members>> : UnionInputType<Members[number]["Input"], UnionError<InferErrors<Parent>>> : UnionInputType<Members[number]["Input"], UnionInputTypeError<Members>>;
 type UnionInputTypeError<Members extends AtLeastTwoReadonlyArray<TypeNode>, RootMembers extends TypeNode = RootType<Members[number]>> = IsUnion<RootMembers> extends true ? UnionTypeError<RootUnionMembers<Members>> : UnionError<InferErrors<RootMembers>>;
 type RootUnionMembers<Members extends AtLeastTwoReadonlyArray<TypeNode>> = {
     readonly [Index in keyof Members]: RootType<Members[Index]>;
 } extends infer RootMembers extends AtLeastTwoReadonlyArray<TypeNode> ? RootMembers : never;
-/**
- * Error returned when every member of a {@link union} rejects an input.
- *
- * @group Unions
- */
-export type UnionError<Error extends TypeError = TypeError, MemberError extends UnionMemberError<Error> = UnionMemberError<Error>> = [Error] extends [never] ? never : UnionErrorValue<Error, MemberError>;
-/**
- * An error returned by one {@link union} member and its index.
- *
- * @group Unions
- */
-export interface UnionMemberError<Error extends TypeError, Index extends number = number> {
-    readonly index: Index;
-    readonly error: Error;
-}
 type UnionTypeError<Members extends AtLeastTwoReadonlyArray<TypeNode>> = UnionMembersAreLiterals<Members> extends true ? CorrelatedUnionError<Members> : [Extract<Members[number], InfallibleTypeNode>] extends [never] ? CorrelatedUnionError<Members> : true extends {
     readonly [Index in keyof Members]: [
         InferErrors<Members[Index]>
@@ -1875,8 +1915,24 @@ type UnionMembersAreLiterals<Members extends AtLeastTwoReadonlyArray<TypeNode>>
 type InfallibleTypeNode = TypeNode & {
     readonly [errorsSymbol]: never;
 };
-interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemberError<Error> = UnionMemberError<Error>> extends TypeError<"Union"> {
-    readonly errors: NonEmptyReadonlyArray<MemberError>;
+/**
+ * The parsing {@link Type} returned by {@link templateLiteralParser}.
+ *
+ * @group Template literals
+ */
+export interface TemplateLiteralParserType<Parts extends TemplateLiteralParts> extends Type<"TemplateLiteral", string, TemplateLiteralCaptureTuple<Parts>["Output"], never, TemplateLiteralType<Parts>, InferErrors<TemplateLiteralType<Parts>>, never, TemplateLiteralStringOutput<Parts>, false> {
+    readonly [templateLiteralSyntaxSymbol]: true;
+    readonly [reflectedTypesSymbol]?: TemplateLiteralCaptureTuple<Parts>;
+    readonly output: TemplateLiteralCaptureTuple<Parts>;
+    readonly parts: Parts;
+}
+/**
+ * Error returned when a string does not match a template literal declaration.
+ *
+ * @group Template literals
+ */
+export interface TemplateLiteralError extends TypeError<"TemplateLiteral"> {
+    readonly value: string;
 }
 /**
  * Template literal {@link Type} that parses canonical strings into Tuples.
@@ -2071,17 +2127,6 @@ interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemb
  * @group Template literals
  */
 export declare const templateLiteralParser: <const Parts extends TemplateLiteralParts>(...parts: { readonly [Index in keyof Parts]: ValidateTemplateLiteralPart<Parts[Index]>; } & TemplateLiteralValidation<Parts>) => TemplateLiteralParserType<Parts>;
-/**
- * The parsing {@link Type} returned by {@link templateLiteralParser}.
- *
- * @group Template literals
- */
-export interface TemplateLiteralParserType<Parts extends TemplateLiteralParts> extends Type<"TemplateLiteral", string, TemplateLiteralCaptureTuple<Parts>["Output"], never, TemplateLiteralType<Parts>, InferErrors<TemplateLiteralType<Parts>>, never, TemplateLiteralStringOutput<Parts>, false> {
-    readonly [templateLiteralSyntaxSymbol]: true;
-    readonly [reflectedTypesSymbol]?: TemplateLiteralCaptureTuple<Parts>;
-    readonly output: TemplateLiteralCaptureTuple<Parts>;
-    readonly parts: Parts;
-}
 /**
  * The validating string {@link Type} returned by {@link templateLiteral}.
  *
@@ -2131,16 +2176,17 @@ export declare const templateLiteral: <const Parts extends TemplateLiteralParts>
 type TemplateLiteralParseError<Parts extends TemplateLiteralParts> = TransformError<"TemplateLiteral", TemplateLiteralIsFrameless<Parts> extends true ? never : TemplateLiteralError, TemplateLiteralCaptureTupleError<Parts>>;
 type TemplateLiteralCaptureTupleError<Parts extends TemplateLiteralParts> = TupleElementsError<TemplateLiteralCaptureFromStringError<TemplateLiteralCaptureTypes<Parts>[number]>>;
 type TemplateLiteralCaptureFromStringError<T extends TypeNode> = T extends TypeNode ? string extends RootType<T>["Output"] ? TypeFromError<T> : InferErrors<T> : never;
+declare const templateLiteralStringBrandSymbol: unique symbol;
 /**
- * Error returned when a string does not match a template literal declaration.
+ * Brands the string Output of a {@link templateLiteral} with a transformed
+ * capture Type.
+ *
+ * TypeScript cannot prove from a string literal alone that such a capture is
+ * canonically encoded, so the string must be validated or created with `to`.
  *
  * @group Template literals
  */
-export interface TemplateLiteralError extends TypeError<"TemplateLiteral"> {
-    readonly value: string;
-}
-declare const templateLiteralStringBrandSymbol: unique symbol;
-interface TemplateLiteralStringBrand<Parts extends TemplateLiteralParts> {
+export interface TemplateLiteralStringBrand<Parts extends TemplateLiteralParts> {
     readonly [templateLiteralStringBrandSymbol]: Parts;
 }
 type TemplateLiteralPart = string | TypeNode;
@@ -2166,6 +2212,13 @@ type TemplateLiteralPartsWidth<Parts extends ReadonlyArray<TemplateLiteralPart>,
 type TemplateLiteralPartWidth<Part extends TemplateLiteralPart> = Part extends string ? TemplateLiteralStringWidth<Part> : Part extends TypeNode ? TemplateLiteralTypeWidth<Part> : never;
 type TemplateLiteralIsFrameless<Parts extends ReadonlyArray<TemplateLiteralPart>, HasVariableCapture extends boolean = false> = Parts extends readonly [infer Head, ...infer Tail] ? TemplateLiteralPartWidth<Extract<Head, TemplateLiteralPart>> extends infer Width ? [Width] extends [null] ? HasVariableCapture extends true ? false : TemplateLiteralIsFrameless<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, true> : [Width] extends [readonly []] ? TemplateLiteralIsFrameless<Extract<Tail, ReadonlyArray<TemplateLiteralPart>>, HasVariableCapture> : false : false : HasVariableCapture;
 type TemplateLiteralStringWidth<Value extends string, Width extends ReadonlyArray<unknown> = readonly []> = string extends Value ? null : Value extends "" ? Width : Value extends `${infer _CodePoint}${infer Tail}` ? TemplateLiteralStringWidth<Tail, readonly [...Width, unknown]> : null;
+/**
+ * The {@link Type} returned by {@link brand}.
+ *
+ * @group Construction
+ */
+export interface BrandType<ParentType extends TypeNode, Name extends TypeName, Error extends TypeError> extends Type<Name, ParentType["Input"], ParentType["Output"] & Brand<Name>, Error, ParentType, Error | InferErrors<ParentType>, ChildCustomFrom<ParentType, ParentType["Output"] & Brand<Name>, Error>, CanonicalInputForChild<ParentType, ParentType["Output"] & Brand<Name>>, IdentityEncodingOf<ParentType>> {
+}
 /**
  * Branded {@link Type}.
  *
@@ -2205,6 +2258,10 @@ type TemplateLiteralStringWidth<Value extends string, Width extends ReadonlyArra
  *   type TypeError,
  * } from "@evolu/common";
  *
+ * interface Int64Error extends TypeError<"Int64"> {
+ *   readonly value: bigint;
+ * }
+ *
  * const Int64 = brand(
  *   "Int64",
  *   BigInt,
@@ -2219,10 +2276,6 @@ type TemplateLiteralStringWidth<Value extends string, Width extends ReadonlyArra
  * // Note the Brand.
  * assertType<Int64, bigint & Brand<"Int64">>();
  *
- * interface Int64Error extends TypeError<"Int64"> {
- *   readonly value: bigint;
- * }
- *
  * assertOk(Int64.fromUnknown(42n), 42n);
  *
  * const invalid = Int64.fromUnknown(2n ** 63n);
@@ -2243,11 +2296,12 @@ export declare function brand<Name extends TypeName, ParentType extends Concrete
 /** Creates a validated Brand Type with its own error formatter. */
 export declare function brand<Name extends TypeName, ParentType extends ConcreteTypeNode, Error extends TypeError<NoInfer<Name>>>(name: Name, parent: ValidateBrandParent<Name, ParentType>, validate: (value: ParentType["Output"]) => Result<void, Error>, formatError: TypeErrorFormatter<NoInfer<Error>>): BrandType<ParentType, Name, Error>;
 /**
- * The {@link Type} returned by {@link brand}.
+ * Error returned when a string is not a canonical {@link DateIso}.
  *
- * @group Construction
+ * @group String
  */
-export interface BrandType<ParentType extends TypeNode, Name extends TypeName, Error extends TypeError> extends Type<Name, ParentType["Input"], ParentType["Output"] & Brand<Name>, Error, ParentType, Error | InferErrors<ParentType>, ChildCustomFrom<ParentType, ParentType["Output"] & Brand<Name>, Error>, CanonicalInputForChild<ParentType, ParentType["Output"] & Brand<Name>>, IdentityEncodingOf<ParentType>> {
+export interface DateIsoError extends TypeError<"DateIso"> {
+    readonly value: string;
 }
 /**
  * Canonical ISO date-time {@link String}.
@@ -2289,12 +2343,12 @@ export interface BrandType<ParentType extends TypeNode, Name extends TypeName, E
 export declare const DateIso: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DateIso", DateIsoError>;
 export type DateIso = typeof DateIso.Output;
 /**
- * Error returned when a string is not a canonical {@link DateIso}.
+ * Error returned when a {@link Date} cannot be represented as {@link DateIso}.
  *
  * @group String
  */
-export interface DateIsoError extends TypeError<"DateIso"> {
-    readonly value: string;
+export interface DateIsoFromDateError extends TypeError<"DateIsoFromDate"> {
+    readonly value: globalThis.Date;
 }
 /**
  * Safely transforms a {@link Date} into a canonical {@link DateIso}.
@@ -2315,12 +2369,12 @@ export interface DateIsoError extends TypeError<"DateIso"> {
  */
 export declare const DateIsoFromDate: TransformType<Type<"Date", Date, Date, ObjectTagError<"Date">, null, ObjectTagError<"Date">, never, Date, true>, BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DateIso", DateIsoError>, "DateIsoFromDate", DateIsoFromDateError, Date>;
 /**
- * Error returned when a {@link Date} cannot be represented as {@link DateIso}.
+ * Error returned when a bigint is outside the signed 64-bit {@link Int64} range.
  *
- * @group String
+ * @group Number
  */
-export interface DateIsoFromDateError extends TypeError<"DateIsoFromDate"> {
-    readonly value: globalThis.Date;
+export interface Int64Error extends TypeError<"Int64"> {
+    readonly value: bigint;
 }
 /**
  * Signed 64-bit {@link BigInt}.
@@ -2330,11 +2384,12 @@ export interface DateIsoFromDateError extends TypeError<"DateIsoFromDate"> {
 export declare const Int64: BrandType<Type<"BigInt", bigint, bigint, TypeOfError<"BigInt">, null, TypeOfError<"BigInt">, never, bigint, true>, "Int64", Int64Error>;
 export type Int64 = typeof Int64.Output;
 /**
- * Error returned when a bigint is outside the signed 64-bit {@link Int64} range.
+ * Error returned when a bigint is outside the unsigned 64-bit {@link UInt64}
+ * range.
  *
  * @group Number
  */
-export interface Int64Error extends TypeError<"Int64"> {
+export interface UInt64Error extends TypeError<"UInt64"> {
     readonly value: bigint;
 }
 /**
@@ -2344,15 +2399,6 @@ export interface Int64Error extends TypeError<"Int64"> {
  */
 export declare const UInt64: BrandType<Type<"BigInt", bigint, bigint, TypeOfError<"BigInt">, null, TypeOfError<"BigInt">, never, bigint, true>, "UInt64", UInt64Error>;
 export type UInt64 = typeof UInt64.Output;
-/**
- * Error returned when a bigint is outside the unsigned 64-bit {@link UInt64}
- * range.
- *
- * @group Number
- */
-export interface UInt64Error extends TypeError<"UInt64"> {
-    readonly value: bigint;
-}
 /**
  * Reusable factory for creating a {@link Type} with a {@link Brand}.
  *
@@ -2378,6 +2424,10 @@ export interface UInt64Error extends TypeError<"UInt64"> {
  *   type TypeError,
  * } from "@evolu/common";
  *
+ * interface TrimmedError extends TypeError<"Trimmed"> {
+ *   readonly value: string;
+ * }
+ *
  * const trimmed: BrandFactory<"Trimmed", string, TrimmedError> = (
  *   parent,
  * ) =>
@@ -2396,10 +2446,6 @@ export interface UInt64Error extends TypeError<"UInt64"> {
  *
  * assertType<TrimmedString, string & Brand<"Trimmed">>();
  *
- * interface TrimmedError extends TypeError<"Trimmed"> {
- *   readonly value: string;
- * }
- *
  * assertOk(TrimmedString.fromUnknown("Evolu"), "Evolu");
  *
  * const invalid = TrimmedString.fromUnknown(" Evolu");
@@ -2443,6 +2489,13 @@ export type BrandFactory<Name extends TypeName, Value, Error extends TypeError<N
  *   type ValidateBrandFactoryNumber,
  * } from "@evolu/common";
  *
+ * interface LessThanError<
+ *   Max extends number,
+ * > extends TypeError<`LessThan${Max}`> {
+ *   readonly value: number;
+ *   readonly max: Max;
+ * }
+ *
  * const lessThan =
  *   <Max extends number>(
  *     max: ValidateBrandFactoryNumber<Max>,
@@ -2467,13 +2520,6 @@ export type BrandFactory<Name extends TypeName, Value, Error extends TypeError<N
  * assertType<typeof LessThan100.name, "LessThan100">();
  * assertType<LessThan100, number & Brand<"LessThan100">>();
  *
- * interface LessThanError<
- *   Max extends number,
- * > extends TypeError<`LessThan${Max}`> {
- *   readonly value: number;
- *   readonly max: Max;
- * }
- *
  * // @ts-expect-error Arithmetic expressions widen to number.
  * lessThan(100 - 1)(Number);
  * ```
@@ -2500,6 +2546,15 @@ export interface IdentifierBrandByCasing {
     readonly "kebab-case": "KebabCaseIdentifier";
     readonly CONSTANT_CASE: "ConstantCaseIdentifier";
 }
+/**
+ * Error returned when {@link identifier} rejects a string.
+ *
+ * @group String
+ */
+export interface IdentifierError<Casing extends IdentifierCasing = IdentifierCasing> extends TypeError<IdentifierBrandByCasing[Casing]> {
+    readonly value: string;
+    readonly casing: Casing;
+}
 /**
  * Adds identifier validation in a naming convention to an existing string Type.
  *
@@ -2541,15 +2596,6 @@ export interface IdentifierBrandByCasing {
  * @group String
  */
 export declare const identifier: <Casing extends IdentifierCasing>(casing: Casing) => BrandFactory<IdentifierBrandByCasing[Casing], string, IdentifierError<Casing>>;
-/**
- * Error returned when {@link identifier} rejects a string.
- *
- * @group String
- */
-export interface IdentifierError<Casing extends IdentifierCasing = IdentifierCasing> extends TypeError<IdentifierBrandByCasing[Casing]> {
-    readonly value: string;
-    readonly casing: Casing;
-}
 /**
  * A validated camelCase identifier, such as `http2Port`.
  *
@@ -2797,6 +2843,14 @@ export declare const constantCaseToSnakeCase: (value: ConstantCaseIdentifier) =>
  * @group String
  */
 export declare const constantCaseToKebabCase: (value: ConstantCaseIdentifier) => KebabCaseIdentifier;
+/**
+ * Error returned when {@link capitalized} rejects a string.
+ *
+ * @group String
+ */
+export interface CapitalizedError extends TypeError<"Capitalized"> {
+    readonly value: string;
+}
 /**
  * Adds capitalized text validation to an existing string Type.
  *
@@ -2825,14 +2879,6 @@ export declare const constantCaseToKebabCase: (value: ConstantCaseIdentifier) =>
 export declare const capitalized: <ParentType extends ConcreteTypeNode & {
     readonly Output: string;
 }>(parent: ValidateBrandParent<"Capitalized", ParentType>) => ReturnType<typeof createType<"Capitalized", ParentType, ParentType["Output"] & Capitalize<string>, CapitalizedError>>;
-/**
- * Error returned when {@link capitalized} rejects a string.
- *
- * @group String
- */
-export interface CapitalizedError extends TypeError<"Capitalized"> {
-    readonly value: string;
-}
 /**
  * Validates capitalized text as TypeScript's `Capitalize<string>`.
  *
@@ -2882,6 +2928,14 @@ export type CapitalizedString = typeof CapitalizedString.Output;
  * @group String
  */
 export declare const capitalize: <S extends string>(value: S) => Capitalize<S>;
+/**
+ * Error returned when {@link uncapitalized} rejects a string.
+ *
+ * @group String
+ */
+export interface UncapitalizedError extends TypeError<"Uncapitalized"> {
+    readonly value: string;
+}
 /**
  * Adds uncapitalized text validation to an existing string Type.
  *
@@ -2910,14 +2964,6 @@ export declare const capitalize: <S extends string>(value: S) => Capitalize<S>;
 export declare const uncapitalized: <ParentType extends ConcreteTypeNode & {
     readonly Output: string;
 }>(parent: ValidateBrandParent<"Uncapitalized", ParentType>) => ReturnType<typeof createType<"Uncapitalized", ParentType, ParentType["Output"] & Uncapitalize<string>, UncapitalizedError>>;
-/**
- * Error returned when {@link uncapitalized} rejects a string.
- *
- * @group String
- */
-export interface UncapitalizedError extends TypeError<"Uncapitalized"> {
-    readonly value: string;
-}
 /**
  * Validates uncapitalized text as TypeScript's `Uncapitalize<string>`.
  *
@@ -2962,6 +3008,14 @@ export type UncapitalizedString = typeof UncapitalizedString.Output;
  * @group String
  */
 export declare const uncapitalize: <S extends string>(value: S) => Uncapitalize<S>;
+/**
+ * Error returned when {@link uppercased} rejects a string.
+ *
+ * @group String
+ */
+export interface UppercasedError extends TypeError<"Uppercased"> {
+    readonly value: string;
+}
 /**
  * Adds uppercased text validation to an existing string Type.
  *
@@ -2990,14 +3044,6 @@ export declare const uncapitalize: <S extends string>(value: S) => Uncapitalize<
 export declare const uppercased: <ParentType extends ConcreteTypeNode & {
     readonly Output: string;
 }>(parent: ValidateBrandParent<"Uppercased", ParentType>) => ReturnType<typeof createType<"Uppercased", ParentType, ParentType["Output"] & Uppercase<string>, UppercasedError>>;
-/**
- * Error returned when {@link uppercased} rejects a string.
- *
- * @group String
- */
-export interface UppercasedError extends TypeError<"Uppercased"> {
-    readonly value: string;
-}
 /**
  * Validates uppercased text as TypeScript's `Uppercase<string>`.
  *
@@ -3041,6 +3087,14 @@ export type UppercasedString = typeof UppercasedString.Output;
  * @group String
  */
 export declare const uppercase: <S extends string>(value: S) => Uppercase<S>;
+/**
+ * Error returned when {@link lowercased} rejects a string.
+ *
+ * @group String
+ */
+export interface LowercasedError extends TypeError<"Lowercased"> {
+    readonly value: string;
+}
 /**
  * Adds lowercased text validation to an existing string Type.
  *
@@ -3070,15 +3124,7 @@ export declare const lowercased: <ParentType extends ConcreteTypeNode & {
     readonly Output: string;
 }>(parent: ValidateBrandParent<"Lowercased", ParentType>) => ReturnType<typeof createType<"Lowercased", ParentType, ParentType["Output"] & Lowercase<string>, LowercasedError>>;
 /**
- * Error returned when {@link lowercased} rejects a string.
- *
- * @group String
- */
-export interface LowercasedError extends TypeError<"Lowercased"> {
-    readonly value: string;
-}
-/**
- * Validates lowercased text as TypeScript's `Lowercase<string>`.
+ * Validates lowercased text as TypeScript's `Lowercase<string>`.
  *
  * Checks the whole string using JavaScript's Unicode lowercase mapping. Empty
  * strings and uncased characters, such as digits and emoji, are valid. Use
@@ -3120,6 +3166,14 @@ export type LowercasedString = typeof LowercasedString.Output;
  * @group String
  */
 export declare const lowercase: <S extends string>(value: S) => Lowercase<S>;
+/**
+ * Error returned when {@link trimmed} rejects a string.
+ *
+ * @group String
+ */
+export interface TrimmedError extends TypeError<"Trimmed"> {
+    readonly value: string;
+}
 /**
  * String {@link Brand} without surrounding whitespace.
  *
@@ -3136,14 +3190,6 @@ export declare const lowercase: <S extends string>(value: S) => Lowercase<S>;
  * @group String
  */
 export declare const trimmed: BrandFactory<"Trimmed", string, TrimmedError>;
-/**
- * Error returned when {@link trimmed} rejects a string.
- *
- * @group String
- */
-export interface TrimmedError extends TypeError<"Trimmed"> {
-    readonly value: string;
-}
 /**
  * A {@link String} without surrounding whitespace.
  *
@@ -3171,6 +3217,15 @@ export type TrimmedString = typeof TrimmedString.Output;
  * @group String
  */
 export declare const trim: (value: string) => TrimmedString;
+/**
+ * Error returned when {@link startsWith} rejects a string.
+ *
+ * @group String
+ */
+export interface StartsWithError<Prefix extends string = string> extends TypeError<`StartsWith${Prefix}`> {
+    readonly value: string;
+    readonly prefix: Prefix;
+}
 /**
  * String {@link Brand} requiring an exact, case-sensitive prefix.
  *
@@ -3211,13 +3266,11 @@ export declare const trim: (value: string) => TrimmedString;
  */
 export declare const startsWith: <Prefix extends string>(prefix: Prefix & ValidateLiteral<Prefix>) => BrandFactory<`StartsWith${Prefix}`, string, StartsWithError<Prefix>>;
 /**
- * Error returned when {@link startsWith} rejects a string.
+ * The {@link Type} returned by {@link prefixed}.
  *
  * @group String
  */
-export interface StartsWithError<Prefix extends string = string> extends TypeError<`StartsWith${Prefix}`> {
-    readonly value: string;
-    readonly prefix: Prefix;
+export interface PrefixedType<Prefix extends string, T extends TypeNode> extends TransformType<BrandType<typeof String, `StartsWith${Prefix}`, StartsWithError<Prefix>>, T, `Prefixed${Prefix}`, never> {
 }
 /**
  * Decodes a prefixed string with another {@link Type} and restores the prefix
@@ -3273,14 +3326,16 @@ export declare const prefixed: <Prefix extends string>(prefix: Prefix & Validate
     readonly Input: string;
     readonly CanonicalInput: string;
 }>(type: T & ValidateOutput<T> & (string extends T["Input"] ? unknown : PrefixedInputTypeError)) => PrefixedType<Prefix, T>;
+type PrefixedInputTypeError = CompileTimeError<"Type", "Prefixed Type Input must accept every string.">;
 /**
- * The {@link Type} returned by {@link prefixed}.
+ * Error returned when {@link minLength} rejects a value.
  *
- * @group String
+ * @group Collection
  */
-export interface PrefixedType<Prefix extends string, T extends TypeNode> extends TransformType<BrandType<typeof String, `StartsWith${Prefix}`, StartsWithError<Prefix>>, T, `Prefixed${Prefix}`, never> {
+export interface MinLengthError<Min extends number = number> extends TypeError<`MinLength${Min}`> {
+    readonly value: ValueWithLength;
+    readonly min: Min;
 }
-type PrefixedInputTypeError = CompileTimeError<"Type", "Prefixed Type Input must accept every string.">;
 /**
  * Minimum-length {@link Brand} for values whose `length` is at least `min`.
  *
@@ -3300,15 +3355,6 @@ type PrefixedInputTypeError = CompileTimeError<"Type", "Prefixed Type Input must
  * @group Collection
  */
 export declare const minLength: <Min extends number>(min: ValidateBrandFactoryNumber<Min>) => BrandFactory<`MinLength${Min}`, ValueWithLength, MinLengthError<Min>>;
-/**
- * Error returned when {@link minLength} rejects a value.
- *
- * @group Collection
- */
-export interface MinLengthError<Min extends number = number> extends TypeError<`MinLength${Min}`> {
-    readonly value: ValueWithLength;
-    readonly min: Min;
-}
 /**
  * A non-empty {@link TrimmedString}.
  *
@@ -3325,6 +3371,15 @@ export interface MinLengthError<Min extends number = number> extends TypeError<`
  */
 export declare const NonEmptyTrimmedString: BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>;
 export type NonEmptyTrimmedString = typeof NonEmptyTrimmedString.Output;
+/**
+ * Error returned when {@link maxLength} rejects a value.
+ *
+ * @group Collection
+ */
+export interface MaxLengthError<Max extends number = number> extends TypeError<`MaxLength${Max}`> {
+    readonly value: ValueWithLength;
+    readonly max: Max;
+}
 /**
  * Maximum-length {@link Brand} for values whose `length` is at most `max`.
  *
@@ -3344,15 +3399,6 @@ export type NonEmptyTrimmedString = typeof NonEmptyTrimmedString.Output;
  * @group Collection
  */
 export declare const maxLength: <Max extends number>(max: ValidateBrandFactoryNumber<Max>) => BrandFactory<`MaxLength${Max}`, ValueWithLength, MaxLengthError<Max>>;
-/**
- * Error returned when {@link maxLength} rejects a value.
- *
- * @group Collection
- */
-export interface MaxLengthError<Max extends number = number> extends TypeError<`MaxLength${Max}`> {
-    readonly value: ValueWithLength;
-    readonly max: Max;
-}
 /**
  * A {@link NonEmptyTrimmedString} with at most 100 UTF-16 code units.
  *
@@ -3367,6 +3413,15 @@ export type NonEmptyTrimmedString100 = typeof NonEmptyTrimmedString100.Output;
  */
 export declare const NonEmptyTrimmedString1000: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>, "MaxLength1000", MaxLengthError<1000>>;
 export type NonEmptyTrimmedString1000 = typeof NonEmptyTrimmedString1000.Output;
+/**
+ * Error returned when {@link length} rejects a value.
+ *
+ * @group Collection
+ */
+export interface LengthError<Exact extends number = number> extends TypeError<`Length${Exact}`> {
+    readonly value: ValueWithLength;
+    readonly exact: Exact;
+}
 /**
  * Exact-length {@link Brand} for values whose `length` equals `exact`.
  *
@@ -3387,13 +3442,15 @@ export type NonEmptyTrimmedString1000 = typeof NonEmptyTrimmedString1000.Output;
  */
 export declare const length: <Exact extends number>(exact: ValidateBrandFactoryNumber<Exact>) => BrandFactory<`Length${Exact}`, ValueWithLength, LengthError<Exact>>;
 /**
- * Error returned when {@link length} rejects a value.
+ * Error returned when a string does not match the regular expression supplied
+ * to {@link regex}.
  *
- * @group Collection
+ * @group String
  */
-export interface LengthError<Exact extends number = number> extends TypeError<`Length${Exact}`> {
-    readonly value: ValueWithLength;
-    readonly exact: Exact;
+export interface RegexError<Name extends TypeName = TypeName> extends TypeError<Name> {
+    readonly value: string;
+    readonly source: string;
+    readonly flags: string;
 }
 /**
  * String {@link Brand} constrained by a regular expression.
@@ -3438,17 +3495,6 @@ export interface LengthError<Exact extends number = number> extends TypeError<`L
  * @group String
  */
 export declare const regex: <const Name extends TypeName>(name: ValidateConcreteTypeName<Name>, pattern: RegExp) => BrandFactory<Name, string, RegexError<Name>>;
-/**
- * Error returned when a string does not match the regular expression supplied
- * to {@link regex}.
- *
- * @group String
- */
-export interface RegexError<Name extends TypeName = TypeName> extends TypeError<Name> {
-    readonly value: string;
-    readonly source: string;
-    readonly flags: string;
-}
 /**
  * Non-empty URL-safe {@link String}.
  *
@@ -3460,6 +3506,14 @@ export interface RegexError<Name extends TypeName = TypeName> extends TypeError<
  */
 export declare const UrlSafeString: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "UrlSafeString", RegexError<"UrlSafeString">>;
 export type UrlSafeString = typeof UrlSafeString.Output;
+/**
+ * Error returned when a string is not valid {@link Base64Url} text.
+ *
+ * @group String
+ */
+export interface Base64UrlError extends TypeError<"Base64Url"> {
+    readonly value: string;
+}
 /**
  * Base64Url text without padding.
  *
@@ -3470,14 +3524,6 @@ export type UrlSafeString = typeof UrlSafeString.Output;
  */
 export declare const Base64Url: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Base64Url", Base64UrlError>;
 export type Base64Url = typeof Base64Url.Output;
-/**
- * Error returned when a string is not valid {@link Base64Url} text.
- *
- * @group String
- */
-export interface Base64UrlError extends TypeError<"Base64Url"> {
-    readonly value: string;
-}
 /**
  * Converts bytes to {@link Base64Url}.
  *
@@ -3518,6 +3564,14 @@ export declare const uint8ArrayToBase64Url: (bytes: Uint8Array) => Base64Url;
  * @group String
  */
 export declare const base64UrlToUint8Array: (value: Base64Url) => Uint8Array;
+/**
+ * Error returned when a string is not a valid {@link Name}.
+ *
+ * @group String
+ */
+export interface NameError extends TypeError<"Name"> {
+    readonly value: string;
+}
 /**
  * A non-empty file-system-safe and URL-safe token of at most 64 UTF-16 code
  * units.
@@ -3531,14 +3585,6 @@ export declare const base64UrlToUint8Array: (value: Base64Url) => Uint8Array;
  */
 export declare const Name: BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "UrlSafeString", RegexError<"UrlSafeString">>, "Name", NameError>;
 export type Name = typeof Name.Output;
-/**
- * Error returned when a string is not a valid {@link Name}.
- *
- * @group String
- */
-export interface NameError extends TypeError<"Name"> {
-    readonly value: string;
-}
 /**
  * Stable valid {@link Name} for tests and internal fixtures.
  *
@@ -3552,13 +3598,6 @@ export declare const testName: string & Brand<"UrlSafeString"> & Brand<"Name">;
  */
 export declare const SimplePassword: BrandType<BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MaxLength64", MaxLengthError<64>>, "MinLength8", MinLengthError<8>>, "SimplePassword", never>;
 export type SimplePassword = typeof SimplePassword.Output;
-/**
- * A valid English BIP39 mnemonic.
- *
- * @group String
- */
-export declare const Mnemonic: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>, "Mnemonic", MnemonicError>;
-export type Mnemonic = typeof Mnemonic.Output;
 /**
  * Error returned when a string is not a valid English BIP39 {@link Mnemonic}.
  *
@@ -3567,6 +3606,13 @@ export type Mnemonic = typeof Mnemonic.Output;
 export interface MnemonicError extends TypeError<"Mnemonic"> {
     readonly value: string;
 }
+/**
+ * A valid English BIP39 mnemonic.
+ *
+ * @group String
+ */
+export declare const Mnemonic: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>, "Mnemonic", MnemonicError>;
+export type Mnemonic = typeof Mnemonic.Output;
 /**
  * Evolu Id: 16 bytes encoded as a 22-character {@link Base64Url}.
  *
@@ -3585,14 +3631,6 @@ export interface MnemonicError extends TypeError<"Mnemonic"> {
  */
 export declare const Id: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Id", IdError>;
 export type Id = typeof Id.Output;
-/**
- * Error returned when a string is not a valid {@link Id}.
- *
- * @group String
- */
-export interface IdError extends TypeError<"Id"> {
-    readonly value: string;
-}
 /**
  * Creates a cryptographically random {@link Id}.
  *
@@ -3681,6 +3719,31 @@ export declare const createIdFromString: <B extends string = never>(value: strin
  * @group String
  */
 export declare const createIdAsUuidv7: <B extends string = never>(deps: RandomBytesDep & TimeDep, ..._validation: IdBrandValidation<B>) => CreatedId<B>;
+/**
+ * The {@link Type} returned by {@link id} for one table.
+ *
+ * @group String
+ */
+export interface TableId<Table extends TypeName> extends Type<"TableId", string, Id & Brand<Table>, TableIdError<Table>, typeof String, TableIdError<Table> | InferErrors<typeof String>, ChildCustomFrom<typeof String, Id & Brand<Table>, TableIdError<Table>>, CanonicalInputForChild<typeof String, Id & Brand<Table>>, IdentityEncodingOf<typeof String>> {
+    readonly table: Table;
+}
+/**
+ * Error returned when a string is not a valid {@link Id} for the expected table.
+ *
+ * @group String
+ */
+export interface TableIdError<Table extends TypeName = TypeName> extends TypeError<"TableId"> {
+    readonly table: Table;
+    readonly value: string;
+}
+/**
+ * Error returned when a string is not a valid {@link Id}.
+ *
+ * @group String
+ */
+export interface IdError extends TypeError<"Id"> {
+    readonly value: string;
+}
 /**
  * Table-specific {@link Id} Type.
  *
@@ -3704,23 +3767,6 @@ export declare const createIdAsUuidv7: <B extends string = never>(deps: RandomBy
  * @group String
  */
 export declare const id: <Table extends TypeName>(table: ValidateTableName<Table>) => TableId<Table>;
-/**
- * The {@link Type} returned by {@link id} for one table.
- *
- * @group String
- */
-export interface TableId<Table extends TypeName> extends Type<"TableId", string, Id & Brand<Table>, TableIdError<Table>, typeof String, TableIdError<Table> | InferErrors<typeof String>, ChildCustomFrom<typeof String, Id & Brand<Table>, TableIdError<Table>>, CanonicalInputForChild<typeof String, Id & Brand<Table>>, IdentityEncodingOf<typeof String>> {
-    readonly table: Table;
-}
-/**
- * Error returned when a string is not a valid {@link Id} for the expected table.
- *
- * @group String
- */
-export interface TableIdError<Table extends TypeName = TypeName> extends TypeError<"TableId"> {
-    readonly table: Table;
-    readonly value: string;
-}
 type ValidateTableName<Table extends TypeName> = IsTypeNameUnion<Table> extends false ? {} extends Readonly<Record<Table, never>> ? ConcreteTableNameError : Table : ConcreteTableNameError;
 type ConcreteTableNameError = CompileTimeError<"TableId", "Table name must be one concrete literal, not a union or widened TypeName.">;
 type CreatedId<B extends string> = [B] extends [never] ? Id : Id & Brand<B>;
@@ -3783,13 +3829,6 @@ export declare const idToIdBytes: (value: Id) => IdBytes;
  * @group String
  */
 export declare const idBytesToId: (value: IdBytes) => Id;
-/**
- * Decimal string representation of a signed {@link Int64}.
- *
- * @group Number
- */
-export declare const Int64String: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>, "Int64String", Int64StringError>;
-export type Int64String = typeof Int64String.Output;
 /**
  * Error returned when a string is not a canonical {@link Int64String}.
  *
@@ -3798,6 +3837,13 @@ export type Int64String = typeof Int64String.Output;
 export interface Int64StringError extends TypeError<"Int64String"> {
     readonly value: string;
 }
+/**
+ * Decimal string representation of a signed {@link Int64}.
+ *
+ * @group Number
+ */
+export declare const Int64String: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>, "Int64String", Int64StringError>;
+export type Int64String = typeof Int64String.Output;
 /**
  * Transforms an {@link Int64String} into an {@link Int64}.
  *
@@ -3826,6 +3872,14 @@ export interface Int64StringError extends TypeError<"Int64String"> {
  * @group Number
  */
 export declare const Int64FromInt64String: TransformType<BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Trimmed", TrimmedError>, "MinLength1", MinLengthError<1>>, "Int64String", Int64StringError>, BrandType<Type<"BigInt", bigint, bigint, TypeOfError<"BigInt">, null, TypeOfError<"BigInt">, never, bigint, true>, "Int64", Int64Error>, "Int64FromInt64String", never, string & Brand<"Trimmed"> & Brand<"MinLength1"> & Brand<"Int64String">>;
+/**
+ * Error returned when {@link nonNegative} rejects a number.
+ *
+ * @group Number
+ */
+export interface NonNegativeError extends TypeError<"NonNegative"> {
+    readonly value: number;
+}
 /**
  * Number {@link Brand} requiring a value greater than or equal to zero.
  *
@@ -3843,20 +3897,20 @@ export declare const Int64FromInt64String: TransformType<BrandType<BrandType<Bra
  */
 export declare const nonNegative: BrandFactory<"NonNegative", number, NonNegativeError>;
 /**
- * Error returned when {@link nonNegative} rejects a number.
+ * Non-negative {@link Number}.
  *
  * @group Number
  */
-export interface NonNegativeError extends TypeError<"NonNegative"> {
-    readonly value: number;
-}
+export declare const NonNegativeNumber: BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNegative", NonNegativeError>;
+export type NonNegativeNumber = typeof NonNegativeNumber.Output;
 /**
- * Non-negative {@link Number}.
+ * Error returned when {@link positive} rejects a number.
  *
  * @group Number
  */
-export declare const NonNegativeNumber: BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNegative", NonNegativeError>;
-export type NonNegativeNumber = typeof NonNegativeNumber.Output;
+export interface PositiveError extends TypeError<"Positive"> {
+    readonly value: number;
+}
 /**
  * Number {@link Brand} requiring a value greater than zero.
  *
@@ -3873,14 +3927,6 @@ export type NonNegativeNumber = typeof NonNegativeNumber.Output;
  * @group Number
  */
 export declare const positive: BrandFactory<"Positive", number, PositiveError>;
-/**
- * Error returned when {@link positive} rejects a number.
- *
- * @group Number
- */
-export interface PositiveError extends TypeError<"Positive"> {
-    readonly value: number;
-}
 /**
  * Positive {@link Number}.
  *
@@ -3891,6 +3937,14 @@ export interface PositiveError extends TypeError<"Positive"> {
  */
 export declare const PositiveNumber: BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNegative", NonNegativeError>, "Positive", PositiveError>;
 export type PositiveNumber = typeof PositiveNumber.Output;
+/**
+ * Error returned when {@link nonPositive} rejects a number.
+ *
+ * @group Number
+ */
+export interface NonPositiveError extends TypeError<"NonPositive"> {
+    readonly value: number;
+}
 /**
  * Number {@link Brand} requiring a value less than or equal to zero.
  *
@@ -3908,20 +3962,20 @@ export type PositiveNumber = typeof PositiveNumber.Output;
  */
 export declare const nonPositive: BrandFactory<"NonPositive", number, NonPositiveError>;
 /**
- * Error returned when {@link nonPositive} rejects a number.
+ * Non-positive {@link Number}.
  *
  * @group Number
  */
-export interface NonPositiveError extends TypeError<"NonPositive"> {
-    readonly value: number;
-}
+export declare const NonPositiveNumber: BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonPositive", NonPositiveError>;
+export type NonPositiveNumber = typeof NonPositiveNumber.Output;
 /**
- * Non-positive {@link Number}.
+ * Error returned when {@link negative} rejects a number.
  *
  * @group Number
  */
-export declare const NonPositiveNumber: BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonPositive", NonPositiveError>;
-export type NonPositiveNumber = typeof NonPositiveNumber.Output;
+export interface NegativeError extends TypeError<"Negative"> {
+    readonly value: number;
+}
 /**
  * Number {@link Brand} requiring a value less than zero.
  *
@@ -3938,14 +3992,6 @@ export type NonPositiveNumber = typeof NonPositiveNumber.Output;
  * @group Number
  */
 export declare const negative: BrandFactory<"Negative", number, NegativeError>;
-/**
- * Error returned when {@link negative} rejects a number.
- *
- * @group Number
- */
-export interface NegativeError extends TypeError<"Negative"> {
-    readonly value: number;
-}
 /**
  * Negative {@link Number}.
  *
@@ -3956,6 +4002,14 @@ export interface NegativeError extends TypeError<"Negative"> {
  */
 export declare const NegativeNumber: BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonPositive", NonPositiveError>, "Negative", NegativeError>;
 export type NegativeNumber = typeof NegativeNumber.Output;
+/**
+ * Error returned when {@link nonNaN} rejects `NaN`.
+ *
+ * @group Number
+ */
+export interface NonNaNError extends TypeError<"NonNaN"> {
+    readonly value: number;
+}
 /**
  * Number {@link Brand} requiring a value other than `NaN`.
  *
@@ -3972,14 +4026,6 @@ export type NegativeNumber = typeof NegativeNumber.Output;
  * @group Number
  */
 export declare const nonNaN: BrandFactory<"NonNaN", number, NonNaNError>;
-/**
- * Error returned when {@link nonNaN} rejects `NaN`.
- *
- * @group Number
- */
-export interface NonNaNError extends TypeError<"NonNaN"> {
-    readonly value: number;
-}
 /**
  * {@link Number} other than `NaN`; infinities are allowed.
  *
@@ -3992,6 +4038,14 @@ export interface NonNaNError extends TypeError<"NonNaN"> {
  */
 export declare const NonNaNNumber: BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>;
 export type NonNaNNumber = typeof NonNaNNumber.Output;
+/**
+ * Error returned when {@link finite} rejects a non-finite number.
+ *
+ * @group Number
+ */
+export interface FiniteError extends TypeError<"Finite"> {
+    readonly value: number;
+}
 /**
  * Number {@link Brand} requiring a finite value.
  *
@@ -4008,14 +4062,6 @@ export type NonNaNNumber = typeof NonNaNNumber.Output;
  * @group Number
  */
 export declare const finite: BrandFactory<"Finite", number, FiniteError>;
-/**
- * Error returned when {@link finite} rejects a non-finite number.
- *
- * @group Number
- */
-export interface FiniteError extends TypeError<"Finite"> {
-    readonly value: number;
-}
 /**
  * Finite {@link Number}.
  *
@@ -4037,6 +4083,14 @@ export type NonNegativeFiniteNumber = typeof NonNegativeFiniteNumber.Output;
  */
 export declare const PositiveFiniteNumber: BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "NonNegative", NonNegativeError>, "Positive", PositiveError>;
 export type PositiveFiniteNumber = typeof PositiveFiniteNumber.Output;
+/**
+ * Error returned when {@link int} rejects a number that is not a safe integer.
+ *
+ * @group Number
+ */
+export interface IntError extends TypeError<"Int"> {
+    readonly value: number;
+}
 /**
  * Safe integer {@link Brand}.
  *
@@ -4074,14 +4128,6 @@ export type PositiveFiniteNumber = typeof PositiveFiniteNumber.Output;
  * @group Number
  */
 export declare const int: BrandFactory<"Int", number, IntError>;
-/**
- * Error returned when {@link int} rejects a number that is not a safe integer.
- *
- * @group Number
- */
-export interface IntError extends TypeError<"Int"> {
-    readonly value: number;
-}
 /**
  * Safe integer {@link FiniteNumber}.
  *
@@ -4187,6 +4233,15 @@ export type NonPositiveInt = typeof NonPositiveInt.Output;
  */
 export declare const NegativeInt: BrandType<BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "Int", IntError>, "NonPositive", NonPositiveError>, "Negative", NegativeError>;
 export type NegativeInt = typeof NegativeInt.Output;
+/**
+ * Error returned when {@link greaterThan} rejects a number.
+ *
+ * @group Number
+ */
+export interface GreaterThanError<Min extends number = number> extends TypeError<`GreaterThan${Min}`> {
+    readonly value: number;
+    readonly min: Min;
+}
 /**
  * Number {@link Brand} requiring a value greater than `min`.
  *
@@ -4204,11 +4259,11 @@ export type NegativeInt = typeof NegativeInt.Output;
  */
 export declare const greaterThan: <Min extends number>(min: ValidateBrandFactoryNumber<Min>) => BrandFactory<`GreaterThan${Min}`, number, GreaterThanError<Min>>;
 /**
- * Error returned when {@link greaterThan} rejects a number.
+ * Error returned when {@link greaterThanOrEqualTo} rejects a number.
  *
  * @group Number
  */
-export interface GreaterThanError<Min extends number = number> extends TypeError<`GreaterThan${Min}`> {
+export interface GreaterThanOrEqualToError<Min extends number = number> extends TypeError<`GreaterThanOrEqualTo${Min}`> {
     readonly value: number;
     readonly min: Min;
 }
@@ -4229,13 +4284,13 @@ export interface GreaterThanError<Min extends number = number> extends TypeError
  */
 export declare const greaterThanOrEqualTo: <Min extends number>(min: ValidateBrandFactoryNumber<Min>) => BrandFactory<`GreaterThanOrEqualTo${Min}`, number, GreaterThanOrEqualToError<Min>>;
 /**
- * Error returned when {@link greaterThanOrEqualTo} rejects a number.
+ * Error returned when {@link lessThan} rejects a number.
  *
  * @group Number
  */
-export interface GreaterThanOrEqualToError<Min extends number = number> extends TypeError<`GreaterThanOrEqualTo${Min}`> {
+export interface LessThanError<Max extends number = number> extends TypeError<`LessThan${Max}`> {
     readonly value: number;
-    readonly min: Min;
+    readonly max: Max;
 }
 /**
  * Number {@link Brand} requiring a value less than `max`.
@@ -4254,21 +4309,21 @@ export interface GreaterThanOrEqualToError<Min extends number = number> extends
  */
 export declare const lessThan: <Max extends number>(max: ValidateBrandFactoryNumber<Max>) => BrandFactory<`LessThan${Max}`, number, LessThanError<Max>>;
 /**
- * Error returned when {@link lessThan} rejects a number.
+ * A person's age as a {@link NonNegativeInt} less than 200.
  *
  * @group Number
  */
-export interface LessThanError<Max extends number = number> extends TypeError<`LessThan${Max}`> {
-    readonly value: number;
-    readonly max: Max;
-}
+export declare const Age: BrandType<BrandType<BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "Int", IntError>, "NonNegative", NonNegativeError>, "LessThan200", LessThanError<200>>, "Age", never>;
+export type Age = typeof Age.Output;
 /**
- * A person's age as a {@link NonNegativeInt} less than 200.
+ * Error returned when {@link lessThanOrEqualTo} rejects a number.
  *
  * @group Number
  */
-export declare const Age: BrandType<BrandType<BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "Int", IntError>, "NonNegative", NonNegativeError>, "LessThan200", LessThanError<200>>, "Age", never>;
-export type Age = typeof Age.Output;
+export interface LessThanOrEqualToError<Max extends number = number> extends TypeError<`LessThanOrEqualTo${Max}`> {
+    readonly value: number;
+    readonly max: Max;
+}
 /**
  * Number {@link Brand} requiring a value less than or equal to `max`.
  *
@@ -4285,15 +4340,6 @@ export type Age = typeof Age.Output;
  * @group Number
  */
 export declare const lessThanOrEqualTo: <Max extends number>(max: ValidateBrandFactoryNumber<Max>) => BrandFactory<`LessThanOrEqualTo${Max}`, number, LessThanOrEqualToError<Max>>;
-/**
- * Error returned when {@link lessThanOrEqualTo} rejects a number.
- *
- * @group Number
- */
-export interface LessThanOrEqualToError<Max extends number = number> extends TypeError<`LessThanOrEqualTo${Max}`> {
-    readonly value: number;
-    readonly max: Max;
-}
 /**
  * A TCP or UDP port as an integer from zero through 65535, inclusive.
  *
@@ -4352,6 +4398,14 @@ export declare const PortFromString: TransformType<TransformType<Type<"String",
  */
 export declare const Ratio: BrandType<BrandType<BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "NonNegative", NonNegativeError>, "LessThanOrEqualTo1", LessThanOrEqualToError<1>>, "Ratio", never>;
 export type Ratio = typeof Ratio.Output;
+/**
+ * Error returned when a string is not a canonical {@link DecimalString}.
+ *
+ * @group Number
+ */
+export interface DecimalStringError extends TypeError<"DecimalString"> {
+    readonly value: string;
+}
 /**
  * Canonical string representation of a signed base-10 decimal value.
  *
@@ -4406,11 +4460,11 @@ export type Ratio = typeof Ratio.Output;
 export declare const DecimalString: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>;
 export type DecimalString = typeof DecimalString.Output;
 /**
- * Error returned when a string is not a canonical {@link DecimalString}.
+ * Error returned when {@link nonNegativeDecimalString} rejects a decimal string.
  *
  * @group Number
  */
-export interface DecimalStringError extends TypeError<"DecimalString"> {
+export interface NonNegativeDecimalStringError extends TypeError<"NonNegativeDecimalString"> {
     readonly value: string;
 }
 /**
@@ -4434,20 +4488,20 @@ export interface DecimalStringError extends TypeError<"DecimalString"> {
  */
 export declare const nonNegativeDecimalString: BrandFactory<"NonNegativeDecimalString", DecimalString, NonNegativeDecimalStringError>;
 /**
- * Error returned when {@link nonNegativeDecimalString} rejects a decimal string.
+ * Non-negative {@link DecimalString}.
  *
  * @group Number
  */
-export interface NonNegativeDecimalStringError extends TypeError<"NonNegativeDecimalString"> {
-    readonly value: string;
-}
+export declare const NonNegativeDecimalString: BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonNegativeDecimalString", NonNegativeDecimalStringError>;
+export type NonNegativeDecimalString = typeof NonNegativeDecimalString.Output;
 /**
- * Non-negative {@link DecimalString}.
+ * Error returned when {@link positiveDecimalString} rejects a decimal string.
  *
  * @group Number
  */
-export declare const NonNegativeDecimalString: BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonNegativeDecimalString", NonNegativeDecimalStringError>;
-export type NonNegativeDecimalString = typeof NonNegativeDecimalString.Output;
+export interface PositiveDecimalStringError extends TypeError<"PositiveDecimalString"> {
+    readonly value: string;
+}
 /**
  * {@link DecimalString} Brand requiring a value greater than zero.
  *
@@ -4468,14 +4522,6 @@ export type NonNegativeDecimalString = typeof NonNegativeDecimalString.Output;
  * @group Number
  */
 export declare const positiveDecimalString: BrandFactory<"PositiveDecimalString", DecimalString, PositiveDecimalStringError>;
-/**
- * Error returned when {@link positiveDecimalString} rejects a decimal string.
- *
- * @group Number
- */
-export interface PositiveDecimalStringError extends TypeError<"PositiveDecimalString"> {
-    readonly value: string;
-}
 /**
  * Positive {@link DecimalString}.
  *
@@ -4486,6 +4532,14 @@ export interface PositiveDecimalStringError extends TypeError<"PositiveDecimalSt
  */
 export declare const PositiveDecimalString: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonNegativeDecimalString", NonNegativeDecimalStringError>, "PositiveDecimalString", PositiveDecimalStringError>;
 export type PositiveDecimalString = typeof PositiveDecimalString.Output;
+/**
+ * Error returned when {@link nonPositiveDecimalString} rejects a decimal string.
+ *
+ * @group Number
+ */
+export interface NonPositiveDecimalStringError extends TypeError<"NonPositiveDecimalString"> {
+    readonly value: string;
+}
 /**
  * {@link DecimalString} Brand requiring a value less than or equal to zero.
  *
@@ -4507,20 +4561,20 @@ export type PositiveDecimalString = typeof PositiveDecimalString.Output;
  */
 export declare const nonPositiveDecimalString: BrandFactory<"NonPositiveDecimalString", DecimalString, NonPositiveDecimalStringError>;
 /**
- * Error returned when {@link nonPositiveDecimalString} rejects a decimal string.
+ * Non-positive {@link DecimalString}.
  *
  * @group Number
  */
-export interface NonPositiveDecimalStringError extends TypeError<"NonPositiveDecimalString"> {
-    readonly value: string;
-}
+export declare const NonPositiveDecimalString: BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonPositiveDecimalString", NonPositiveDecimalStringError>;
+export type NonPositiveDecimalString = typeof NonPositiveDecimalString.Output;
 /**
- * Non-positive {@link DecimalString}.
+ * Error returned when {@link negativeDecimalString} rejects a decimal string.
  *
  * @group Number
  */
-export declare const NonPositiveDecimalString: BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonPositiveDecimalString", NonPositiveDecimalStringError>;
-export type NonPositiveDecimalString = typeof NonPositiveDecimalString.Output;
+export interface NegativeDecimalStringError extends TypeError<"NegativeDecimalString"> {
+    readonly value: string;
+}
 /**
  * {@link DecimalString} Brand requiring a value less than zero.
  *
@@ -4541,14 +4595,6 @@ export type NonPositiveDecimalString = typeof NonPositiveDecimalString.Output;
  * @group Number
  */
 export declare const negativeDecimalString: BrandFactory<"NegativeDecimalString", DecimalString, NegativeDecimalStringError>;
-/**
- * Error returned when {@link negativeDecimalString} rejects a decimal string.
- *
- * @group Number
- */
-export interface NegativeDecimalStringError extends TypeError<"NegativeDecimalString"> {
-    readonly value: string;
-}
 /**
  * Negative {@link DecimalString}.
  *
@@ -4559,6 +4605,15 @@ export interface NegativeDecimalStringError extends TypeError<"NegativeDecimalSt
  */
 export declare const NegativeDecimalString: BrandType<BrandType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "DecimalString", DecimalStringError>, "NonPositiveDecimalString", NonPositiveDecimalStringError>, "NegativeDecimalString", NegativeDecimalStringError>;
 export type NegativeDecimalString = typeof NegativeDecimalString.Output;
+/**
+ * Error returned when {@link multipleOf} rejects a number.
+ *
+ * @group Number
+ */
+export interface MultipleOfError<Divisor extends string = string> extends TypeError<`MultipleOf${Divisor}`> {
+    readonly value: number;
+    readonly divisor: Divisor;
+}
 /**
  * Number {@link Brand} requiring an exact decimal multiple of `divisor`.
  *
@@ -4606,15 +4661,6 @@ export type NegativeDecimalString = typeof NegativeDecimalString.Output;
  * @group Number
  */
 export declare const multipleOf: <const Divisor extends string>(divisor: ValidateMultipleOfDivisor<Divisor>) => BrandFactory<`MultipleOf${Divisor}`, number, MultipleOfError<Divisor>>;
-/**
- * Error returned when {@link multipleOf} rejects a number.
- *
- * @group Number
- */
-export interface MultipleOfError<Divisor extends string = string> extends TypeError<`MultipleOf${Divisor}`> {
-    readonly value: number;
-    readonly divisor: Divisor;
-}
 type ValidateMultipleOfDivisor<Divisor extends string> = IsUnion<Divisor> extends false ? string extends Divisor ? InvalidMultipleOfDivisor<Divisor> : IsCanonicalPositiveDecimalString<Divisor> extends true ? Divisor : InvalidMultipleOfDivisor<Divisor> : InvalidMultipleOfDivisor<Divisor>;
 type IsCanonicalPositiveDecimalString<Value extends string> = Value extends `${infer Integer}.${infer Fraction}` ? IsCanonicalNonNegativeIntegerString<Integer> extends true ? IsCanonicalPositiveFractionString<Fraction> : false : IsCanonicalPositiveIntegerString<Value>;
 type IsCanonicalNonNegativeIntegerString<Value extends string> = Value extends "0" ? true : IsCanonicalPositiveIntegerString<Value>;
@@ -4623,6 +4669,16 @@ type IsCanonicalPositiveFractionString<Value extends string> = Value extends `${
 type IsDecimalDigits<Value extends string> = Value extends "" ? true : Value extends `${Digit}${infer Rest}` ? IsDecimalDigits<Rest> : false;
 type InvalidMultipleOfDivisor<Divisor extends string> = Divisor & Readonly<Record<MultipleOfDivisorError, never>>;
 type MultipleOfDivisorError = CompileTimeError<"MultipleOf", 'Divisor must be one canonical positive decimal string literal such as "0.1".'>;
+/**
+ * Error returned when {@link between} rejects a number.
+ *
+ * @group Number
+ */
+export interface BetweenError<Min extends number = number, Max extends number = number> extends TypeError<`Between${Min}-${Max}`> {
+    readonly value: number;
+    readonly min: Min;
+    readonly max: Max;
+}
 /**
  * Number {@link Brand} requiring a value within an inclusive range.
  *
@@ -4640,125 +4696,51 @@ type MultipleOfDivisorError = CompileTimeError<"MultipleOf", 'Divisor must be on
  */
 export declare const between: <Min extends number, Max extends number>(min: ValidateBrandFactoryNumber<Min>, max: ValidateBrandFactoryNumber<Max>) => BrandFactory<`Between${Min}-${Max}`, number, BetweenError<Min, Max>>;
 /**
- * Error returned when {@link between} rejects a number.
+ * The homogeneous readonly-array {@link Type} returned by {@link array}.
  *
- * @group Number
+ * @group Collection
  */
-export interface BetweenError<Min extends number = number, Max extends number = number> extends TypeError<`Between${Min}-${Max}`> {
-    readonly value: number;
-    readonly min: Min;
-    readonly max: Max;
+export interface ArrayType<ElementType extends TypeNode> extends Type<"Array", ReadonlyArray<ElementType["Input"]>, ReadonlyArray<ElementType["Output"]>, ArrayNodeError<ElementType>, ArrayParent<ElementType>, ArrayError<InferErrors<ElementType>>, ArrayCustomFrom<ElementType>, ReadonlyArray<CanonicalInputOf<ElementType>>, AllTypesUseIdentityEncoding<ElementType>> {
+    readonly [reflectedTypesSymbol]?: ElementType;
+    readonly element: ElementType;
 }
 /**
- * Array {@link Type}.
- *
- * Use `array(Element)` for readonly arrays in which every element must match
- * the same Type, such as arrays of IDs or labels.
+ * Error returned by {@link array} for a non-array value or invalid array items.
  *
- * `fromUnknown` validates the array and every element. By default, it returns
- * the first issue. Pass `{ errors: "all" }` to collect issues across the whole
- * array. Element errors identify the failing index.
+ * @group Collection
+ */
+export type ArrayError<Error extends TypeError = TypeError> = ArrayNotArrayError | ArrayItemsErrorValue<Error, true>;
+/**
+ * Error returned when an {@link array} input is not an array.
  *
- * `from` accepts an array of element Outputs. `from.parent` accepts an array of
- * values typed as the element's parent Output. Each operation asserts its
- * selected array and element boundary, then returns errors only from the
- * remaining element stages. Additional suffixes move that boundary toward the
- * element's root Type.
+ * @group Collection
+ */
+export interface ArrayNotArrayError extends TypeError<"Array"> {
+    readonly reason: {
+        readonly kind: "NotArray";
+        readonly value: unknown;
+    };
+}
+/**
+ * An {@link array} error containing structural or element issues.
  *
- * An Array must be recognized by `Array.isArray`, be dense, and have no own
- * properties other than `length` and the indexed data properties from `0`
- * through `length - 1`. 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.
+ * @group Collection
+ */
+export type ArrayItemsError<Error extends TypeError> = ArrayItemsErrorValue<Error, true>;
+/**
+ * The shape of {@link ArrayItemsError} and {@link ArrayElementsError}.
  *
- * ### Example
- *
- * ```ts
- * import {
- *   assertEqual,
- *   assertErr,
- *   assertOk,
- *   assertType,
- *   Data,
- *   String,
- *   array,
- *   brand,
- *   type Brand,
- *   type Result,
- * } from "@evolu/common";
- *
- * const UserId = brand("UserId", String);
- * const UserIds = array(UserId);
- *
- * const result = UserIds.from.parent(["ada", "grace"]);
- *
- * assertType<
- *   typeof result,
- *   Result<ReadonlyArray<string & Brand<"UserId">>>
- * >();
- * 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" },
- * });
- * ```
- *
- * @group Collection
- */
-export declare const array: <ElementType extends ConcreteTypeNode>(element: ValidateElement<ElementType>) => ArrayType<ElementType>;
-/**
- * The homogeneous readonly-array {@link Type} returned by {@link array}.
- *
- * @group Collection
- */
-export interface ArrayType<ElementType extends TypeNode> extends Type<"Array", ReadonlyArray<ElementType["Input"]>, ReadonlyArray<ElementType["Output"]>, ArrayNodeError<ElementType>, ArrayParent<ElementType>, ArrayError<InferErrors<ElementType>>, ArrayCustomFrom<ElementType>, ReadonlyArray<CanonicalInputOf<ElementType>>, AllTypesUseIdentityEncoding<ElementType>> {
-    readonly [reflectedTypesSymbol]?: ElementType;
-    readonly element: ElementType;
-}
-type ArrayCustomFrom<ElementType extends TypeNode> = [
-    ElementType["parent"]
-] extends [TypeNode] ? ArrayFromOperation<ElementType> : never;
-type ArrayFromOperation<ElementType extends TypeNode> = [
-    ElementType["parent"]
-] extends [infer Parent extends TypeNode] ? TypeOperationFn<"from", ReadonlyArray<ElementType["Output"]>, ReadonlyArray<ElementType["Output"]>, never> & ArrayFromParentOperations<ElementType["Output"], ElementType["Error"], Parent> : TypeOperationFn<"from", ReadonlyArray<ElementType["Output"]>, ReadonlyArray<ElementType["Output"]>, never>;
-interface ArrayFromParentOperations<Output, Error extends TypeError, Boundary extends TypeNode> {
-    readonly parent: TypeOperationFn<"from", ReadonlyArray<Boundary["Output"]>, ReadonlyArray<Output>, ArrayElementsError<Error>> & ([Boundary["parent"]] extends [infer Parent extends TypeNode] ? ArrayFromParentOperations<Output, Error | Boundary["Error"], Parent> : unknown);
-}
-type ValidateElement<T extends ConcreteTypeNode> = IsUnion<T> extends false ? T : CompileTimeError<"Type", "Element must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
-type ArrayParent<ElementType extends TypeNode> = [
-    ElementType["parent"]
-] extends [infer ParentElement extends TypeNode] ? ArrayType<ParentElement> : null;
-type ArrayNodeError<ElementType extends TypeNode> = [
-    ElementType["parent"]
-] extends [TypeNode] ? ArrayElementsError<ElementType["Error"]> : ArrayError<ElementType["Error"]>;
-/**
- * Error returned by {@link array} for a non-array value or invalid array items.
- *
- * @group Collection
- */
-export type ArrayError<Error extends TypeError = TypeError> = ArrayNotArrayError | ArrayItemsErrorValue<Error, true>;
-/**
- * Error returned when an {@link array} input is not an array.
+ * Structural issues are included only when `IncludeStructuralIssues` is true
+ * because a typed boundary asserts the array structure.
  *
  * @group Collection
  */
-export interface ArrayNotArrayError extends TypeError<"Array"> {
+export interface ArrayItemsErrorValue<Error extends TypeError, IncludeStructuralIssues extends boolean> extends TypeError<"Array"> {
     readonly reason: {
-        readonly kind: "NotArray";
-        readonly value: unknown;
+        readonly kind: "Items";
+        readonly issues: NonEmptyReadonlyArray<(true extends IncludeStructuralIssues ? ArrayStructuralIssue : never) | ArrayElementIssue<Error>>;
     };
 }
-/**
- * An {@link array} error containing structural or element issues.
- *
- * @group Collection
- */
-export type ArrayItemsError<Error extends TypeError> = ArrayItemsErrorValue<Error, true>;
 /**
  * One structural or element issue found by {@link array}.
  *
@@ -4792,7 +4774,6 @@ export interface ArrayExcessPropertyIssue {
     readonly kind: "ExcessProperty";
     readonly key: string | symbol;
 }
-type ArrayStructuralIssue = ArrayHoleIssue | ArrayAccessorIssue | ArrayExcessPropertyIssue;
 /**
  * An invalid array element and its index.
  *
@@ -4811,34 +4792,93 @@ export type ArrayElementIssue<Error extends TypeError> = Error extends TypeError
 export type ArrayElementsError<Error extends TypeError> = [Error] extends [
     never
 ] ? never : ArrayItemsErrorValue<Error, false>;
-interface ArrayItemsErrorValue<Error extends TypeError, IncludeStructuralIssues extends boolean> extends TypeError<"Array"> {
-    readonly reason: {
-        readonly kind: "Items";
-        readonly issues: NonEmptyReadonlyArray<(true extends IncludeStructuralIssues ? ArrayStructuralIssue : never) | ArrayElementIssue<Error>>;
-    };
-}
 /**
- * Set {@link Type} whose every element must match one Type.
+ * Array {@link Type}.
  *
- * 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.
+ * Use `array(Element)` for readonly arrays in which every element must match
+ * the same Type, such as arrays of IDs or labels.
+ *
+ * `fromUnknown` validates the array and every element. By default, it returns
+ * the first issue. Pass `{ errors: "all" }` to collect issues across the whole
+ * array. Element errors identify the failing index.
+ *
+ * `from` accepts an array of element Outputs. `from.parent` accepts an array of
+ * values typed as the element's parent Output. Each operation asserts its
+ * selected array and element boundary, then returns errors only from the
+ * remaining element stages. Additional suffixes move that boundary toward the
+ * element's root Type.
+ *
+ * An Array must be recognized by `Array.isArray`, be dense, and have no own
+ * properties other than `length` and the indexed data properties from `0`
+ * through `length - 1`. 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.
  *
  * ### Example
  *
  * ```ts
- * import { assertOk, String, set } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   String,
+ *   array,
+ *   brand,
+ *   type Brand,
+ *   type Result,
+ * } from "@evolu/common";
  *
- * const Tags = set(String);
- * const tags = new Set(["local-first", "offline"]);
+ * const UserId = brand("UserId", String);
+ * const UserIds = array(UserId);
  *
- * assertOk(Tags.fromUnknown(tags), tags);
+ * const result = UserIds.from.parent(["ada", "grace"]);
+ *
+ * assertType<
+ *   typeof result,
+ *   Result<ReadonlyArray<string & Brand<"UserId">>>
+ * >();
+ * 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" },
+ * });
  * ```
  *
  * @group Collection
  */
-export declare const set: <ElementType extends ConcreteTypeNode>(element: ValidateElement<ElementType>) => SetType<ElementType>;
+export declare const array: <ElementType extends ConcreteTypeNode>(element: ValidateElement<ElementType>) => ArrayType<ElementType>;
+type ArrayCustomFrom<ElementType extends TypeNode> = [
+    ElementType["parent"]
+] extends [TypeNode] ? ArrayFromOperation<ElementType> : never;
+type ArrayFromOperation<ElementType extends TypeNode> = [
+    ElementType["parent"]
+] extends [infer Parent extends TypeNode] ? TypeOperationFn<"from", ReadonlyArray<ElementType["Output"]>, ReadonlyArray<ElementType["Output"]>, never> & ArrayFromParentOperations<ElementType["Output"], ElementType["Error"], Parent> : TypeOperationFn<"from", ReadonlyArray<ElementType["Output"]>, ReadonlyArray<ElementType["Output"]>, never>;
+/**
+ * The `.parent` suffixes of an {@link ArrayType} `from` operation.
+ *
+ * Each `.parent` accepts an array of the next element Output toward the root
+ * and returns the element errors of every boundary it adds.
+ *
+ * @group Collection
+ */
+export interface ArrayFromParentOperations<Output, Error extends TypeError, Boundary extends TypeNode> {
+    readonly parent: TypeOperationFn<"from", ReadonlyArray<Boundary["Output"]>, ReadonlyArray<Output>, ArrayElementsError<Error>> & ([Boundary["parent"]] extends [infer Parent extends TypeNode] ? ArrayFromParentOperations<Output, Error | Boundary["Error"], Parent> : unknown);
+}
+type ValidateElement<T extends ConcreteTypeNode> = IsUnion<T> extends false ? T : CompileTimeError<"Type", "Element must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
+type ArrayParent<ElementType extends TypeNode> = [
+    ElementType["parent"]
+] extends [infer ParentElement extends TypeNode] ? ArrayType<ParentElement> : null;
+type ArrayNodeError<ElementType extends TypeNode> = [
+    ElementType["parent"]
+] extends [TypeNode] ? ArrayElementsError<ElementType["Error"]> : ArrayError<ElementType["Error"]>;
+type ArrayStructuralIssue = ArrayHoleIssue | ArrayAccessorIssue | ArrayExcessPropertyIssue;
 /**
  * The homogeneous readonly-set {@link Type} returned by {@link set}.
  *
@@ -4848,21 +4888,6 @@ export interface SetType<ElementType extends TypeNode> extends Type<"Set", Reado
     readonly [reflectedTypesSymbol]?: ElementType;
     readonly element: ElementType;
 }
-type SetCustomFrom<ElementType extends TypeNode> = [
-    ElementType["parent"]
-] extends [TypeNode] ? SetFromOperation<ElementType> : never;
-type SetFromOperation<ElementType extends TypeNode> = [
-    ElementType["parent"]
-] extends [infer Parent extends TypeNode] ? TypeOperationFn<"from", ReadonlySet<ElementType["Output"]>, ReadonlySet<ElementType["Output"]>, never> & SetFromParentOperations<ElementType["Output"], ElementType["Error"], Parent> : TypeOperationFn<"from", ReadonlySet<ElementType["Output"]>, ReadonlySet<ElementType["Output"]>, never>;
-interface SetFromParentOperations<Output, Error extends TypeError, Boundary extends TypeNode> {
-    readonly parent: TypeOperationFn<"from", ReadonlySet<Boundary["Output"]>, ReadonlySet<Output>, SetElementsError<Error>> & ([Boundary["parent"]] extends [infer Parent extends TypeNode] ? SetFromParentOperations<Output, Error | Boundary["Error"], Parent> : unknown);
-}
-type SetParent<ElementType extends TypeNode> = [ElementType["parent"]] extends [
-    infer ParentElement extends TypeNode
-] ? SetType<ParentElement> : null;
-type SetNodeError<ElementType extends TypeNode> = [
-    ElementType["parent"]
-] extends [TypeNode] ? SetElementsError<ElementType["Error"]> : SetError<ElementType["Error"]>;
 /**
  * Error returned by {@link set} for a non-Set value or invalid Set items.
  *
@@ -4889,7 +4914,6 @@ export interface SetExcessPropertyIssue {
     readonly kind: "ExcessProperty";
     readonly key: string | symbol;
 }
-type SetStructuralIssue = SetExcessPropertyIssue;
 /**
  * An invalid Set element and its iteration index.
  *
@@ -4907,43 +4931,71 @@ export type SetElementIssue<Error extends TypeError> = Error extends TypeError ?
  */
 export type SetItemsError<Error extends TypeError> = SetItemsErrorValue<Error, true>;
 /**
- * A {@link set} error containing element errors from a typed boundary.
+ * The shape of {@link SetItemsError} and {@link SetElementsError}.
+ *
+ * Structural issues are included only when `IncludeStructuralIssues` is true
+ * because a typed boundary asserts the Set structure.
  *
  * @group Collection
  */
-export type SetElementsError<Error extends TypeError> = [Error] extends [never] ? never : SetItemsErrorValue<Error, false>;
-interface SetItemsErrorValue<Error extends TypeError, IncludeStructuralIssues extends boolean> extends TypeError<"Set"> {
+export interface SetItemsErrorValue<Error extends TypeError, IncludeStructuralIssues extends boolean> extends TypeError<"Set"> {
     readonly reason: {
         readonly kind: "Items";
         readonly issues: NonEmptyReadonlyArray<(true extends IncludeStructuralIssues ? SetStructuralIssue : never) | SetElementIssue<Error>>;
     };
 }
 /**
- * Map {@link Type} whose keys and values must match their respective Types.
+ * A {@link set} error containing element errors from a typed boundary.
  *
- * 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.
+ * @group Collection
+ */
+export type SetElementsError<Error extends TypeError> = [Error] extends [never] ? never : SetItemsErrorValue<Error, false>;
+/**
+ * Set {@link Type} whose every element must match one Type.
+ *
+ * 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 { assertOk, PositiveInt, String, map } from "@evolu/common";
+ * import { assertOk, String, set } from "@evolu/common";
  *
- * const Scores = map(String, PositiveInt);
- * const scores = new Map([
- *   ["Ada", 10],
- *   ["Grace", 20],
- * ]);
+ * const Tags = set(String);
+ * const tags = new Set(["local-first", "offline"]);
  *
- * assertOk(Scores.fromUnknown(scores), scores);
+ * assertOk(Tags.fromUnknown(tags), tags);
  * ```
  *
  * @group Collection
  */
-export declare const map: <KeyType extends ConcreteTypeNode, ValueType extends ConcreteTypeNode>(key: ValidateMapKeyType<KeyType>, value: ValidateMapValueType<ValueType>) => MapType<KeyType, ValueType>;
+export declare const set: <ElementType extends ConcreteTypeNode>(element: ValidateElement<ElementType>) => SetType<ElementType>;
+type SetCustomFrom<ElementType extends TypeNode> = [
+    ElementType["parent"]
+] extends [TypeNode] ? SetFromOperation<ElementType> : never;
+type SetFromOperation<ElementType extends TypeNode> = [
+    ElementType["parent"]
+] extends [infer Parent extends TypeNode] ? TypeOperationFn<"from", ReadonlySet<ElementType["Output"]>, ReadonlySet<ElementType["Output"]>, never> & SetFromParentOperations<ElementType["Output"], ElementType["Error"], Parent> : TypeOperationFn<"from", ReadonlySet<ElementType["Output"]>, ReadonlySet<ElementType["Output"]>, never>;
+/**
+ * The `.parent` suffixes of a {@link SetType} `from` operation.
+ *
+ * Each `.parent` accepts a Set of the next element Output toward the root and
+ * returns the element errors of every boundary it adds.
+ *
+ * @group Collection
+ */
+export interface SetFromParentOperations<Output, Error extends TypeError, Boundary extends TypeNode> {
+    readonly parent: TypeOperationFn<"from", ReadonlySet<Boundary["Output"]>, ReadonlySet<Output>, SetElementsError<Error>> & ([Boundary["parent"]] extends [infer Parent extends TypeNode] ? SetFromParentOperations<Output, Error | Boundary["Error"], Parent> : unknown);
+}
+type SetParent<ElementType extends TypeNode> = [ElementType["parent"]] extends [
+    infer ParentElement extends TypeNode
+] ? SetType<ParentElement> : null;
+type SetNodeError<ElementType extends TypeNode> = [
+    ElementType["parent"]
+] extends [TypeNode] ? SetElementsError<ElementType["Error"]> : SetError<ElementType["Error"]>;
+type SetStructuralIssue = SetExcessPropertyIssue;
 /**
  * The readonly-map {@link Type} returned by {@link map}.
  *
@@ -4954,17 +5006,19 @@ export interface MapType<KeyType extends TypeNode, ValueType extends TypeNode> e
     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.">;
+/**
+ * The parent of a {@link MapType} whose key or value Type has a parent.
+ *
+ * Its key and value are the root Types of the child map's key and value, and it
+ * has no parent itself.
+ *
+ * @group Collection
+ */
+export interface RootMapType<KeyType extends TypeNode, ValueType extends TypeNode> extends Type<"Map", ReadonlyMap<KeyType["Input"], ValueType["Input"]>, ReadonlyMap<KeyType["Output"], ValueType["Output"]>, MapError<InferErrors<KeyType>, InferErrors<ValueType>, never>, null, MapError<InferErrors<KeyType>, InferErrors<ValueType>, never>, 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;
+}
 /**
  * Error returned while validating a {@link map} and its entries.
  *
@@ -5026,7 +5080,6 @@ export interface MapKeyCollisionIssue {
     readonly previousKey: unknown;
     readonly outputKey: unknown;
 }
-type MapStructuralIssue = MapExcessPropertyIssue | MapKeyCollisionIssue;
 /**
  * An invalid key, value, or structure in a {@link map}.
  *
@@ -5039,52 +5092,55 @@ export type MapIssue<KeyError extends TypeError, ValueError extends TypeError, S
  * @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";
+/**
+ * The entry error shape of {@link MapError} and {@link MapEntriesError}.
+ *
+ * @group Collection
+ */
+export interface MapEntriesErrorValue<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends MapStructuralIssue> extends TypeError<"Map"> {
+    readonly reason: {
+        readonly kind: "Entries";
         readonly issues: NonEmptyReadonlyArray<MapKeyIssue<KeyError> | MapValueIssue<ValueError> | StructuralIssue>;
     };
 }
 /**
- * Tuple {@link Type}.
- *
- * 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
- * element stages. This collapsed input boundary keeps a Tuple to at most one
- * `.parent` suffix even when its element Types have different pipeline depths.
+ * Map {@link Type} whose keys and values must match their respective Types.
  *
- * 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. Foreign-realm arrays are accepted
- * when their own data representation is valid. Sparse arrays, accessor
- * elements, and excess properties are rejected.
+ * Maps from this or another realm are accepted. A Map must have no own
+ * properties; its entries are validated in iteration order. When distinct input
+ * keys decode to the same output key, validation fails instead of discarding
+ * one associated value. Classification uses the realm-neutral object tag under
+ * Evolu Type's trusted JavaScript policy.
  *
  * ### Example
  *
  * ```ts
- * import {
- *   assertOk,
- *   Int64FromInt64String,
- *   String,
- *   tuple,
- * } from "@evolu/common";
+ * import { assertOk, PositiveInt, String, map } from "@evolu/common";
  *
- * const Entry = tuple(String, Int64FromInt64String);
+ * const Scores = map(String, PositiveInt);
+ * const scores = new Map([
+ *   ["Ada", 10],
+ *   ["Grace", 20],
+ * ]);
  *
- * assertOk(Entry.fromUnknown(["count", "1"]), ["count", 1n]);
- * assertOk(Entry.from.parent(["count", "1"]), ["count", 1n]);
+ * assertOk(Scores.fromUnknown(scores), scores);
  * ```
  *
  * @group Collection
  */
-export declare function tuple<const Elements extends TupleElements>(...elements: Elements & TupleValidation<Elements>): TupleType<Elements>;
+export declare const map: <KeyType extends ConcreteTypeNode, ValueType extends ConcreteTypeNode>(key: ValidateMapKeyType<KeyType>, value: ValidateMapValueType<ValueType>) => MapType<KeyType, ValueType>;
+type MapParent<KeyType extends TypeNode, ValueType extends TypeNode> = [
+    KeyType["parent"] | ValueType["parent"]
+] extends [null] ? null : RootMapType<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.">;
+type MapStructuralIssue = MapExcessPropertyIssue | MapKeyCollisionIssue;
 /**
  * The fixed-length heterogeneous {@link Type} returned by {@link tuple}.
  *
@@ -5098,29 +5154,18 @@ export interface TupleType<Elements extends TupleElements> extends Type<"Tuple",
     readonly [reflectedTypesSymbol]?: Elements[number];
     readonly elements: Elements;
 }
-type TupleElements = NonEmptyReadonlyArray<TypeNode>;
-type TupleShape<Elements extends TupleElements, Field extends "Input" | "Output" | "CanonicalInput"> = {
-    readonly [Index in keyof Elements]: Elements[Index] extends TypeNode ? Field extends "CanonicalInput" ? CanonicalInputOf<Elements[Index]> : Elements[Index][Field] : never;
-};
-type TupleParents<Elements extends TupleElements> = Elements[number]["parent"];
-type TupleFromErrors<Elements extends TupleElements> = {
-    readonly [Index in keyof Elements]: Elements[Index] extends TypeNode ? TypeFromError<Elements[Index]> : never;
-}[number];
-type RootTupleElements<Elements extends TupleElements> = {
-    readonly [Index in keyof Elements]: Elements[Index] extends TypeNode ? RootType<Elements[Index]> : never;
-};
-type RootTupleType<Elements extends TupleElements> = Type<"Tuple", TupleShape<Elements, "Input">, TupleShape<Elements, "Output">, TupleError<Elements[number]["Error"]>, null, TupleError<Elements[number]["Error"]>, never, TupleShape<Elements, "CanonicalInput">, AllTypesUseIdentityEncoding<Elements[number]>> & {
+/**
+ * The parent of a {@link TupleType} whose elements have parents.
+ *
+ * Its elements are the root Types of the child tuple's elements, and it has no
+ * parent itself.
+ *
+ * @group Collection
+ */
+export interface RootTupleType<Elements extends TupleElements> extends Type<"Tuple", TupleShape<Elements, "Input">, TupleShape<Elements, "Output">, TupleError<Elements[number]["Error"]>, null, TupleError<Elements[number]["Error"]>, never, TupleShape<Elements, "CanonicalInput">, AllTypesUseIdentityEncoding<Elements[number]>> {
     readonly [reflectedTypesSymbol]?: Elements[number];
     readonly elements: Elements;
-};
-type TupleValidation<Elements extends TupleElements> = [
-    ValidateTupleElements<Elements>
-] extends [never] ? unknown : readonly [ValidationFailure<ValidateTupleElements<Elements>>];
-type ValidateTupleElements<Elements extends TupleElements> = number extends Elements["length"] ? TupleElementsTupleError : IsUnion<Elements["length"]> extends false ? {
-    readonly [Index in keyof Elements & `${number}`]: IsUnion<Elements[Index]> extends false ? Elements[Index] extends ConcreteTypeNode ? never : TupleElementConcreteTypeError : TupleElementConcreteTypeError;
-}[keyof Elements & `${number}`] : TupleElementsTupleError;
-type TupleElementsTupleError = CompileTimeError<"Type", "Elements must use one concrete finite non-empty tuple of Types.">;
-type TupleElementConcreteTypeError = CompileTimeError<"Type", "Element must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
+}
 /**
  * An error returned while validating a {@link tuple}.
  *
@@ -5156,6 +5201,20 @@ export interface TupleInvalidLengthError extends TypeError<"Tuple"> {
  * @group Collection
  */
 export type TupleItemsError<Error extends TypeError> = TupleItemsErrorValue<Error, true>;
+/**
+ * The shape of {@link TupleItemsError} and {@link TupleElementsError}.
+ *
+ * Structural issues are included only when `IncludeStructuralIssues` is true
+ * because a typed boundary asserts the tuple structure.
+ *
+ * @group Collection
+ */
+export interface TupleItemsErrorValue<Error extends TypeError, IncludeStructuralIssues extends boolean> extends TypeError<"Tuple"> {
+    readonly reason: {
+        readonly kind: "Items";
+        readonly issues: NonEmptyReadonlyArray<(true extends IncludeStructuralIssues ? TupleStructuralIssue : never) | TupleElementIssue<Error>>;
+    };
+}
 /**
  * One structural or element issue found in a {@link tuple}.
  *
@@ -5189,7 +5248,6 @@ export interface TupleExcessPropertyIssue {
     readonly kind: "ExcessProperty";
     readonly key: string | symbol;
 }
-type TupleStructuralIssue = TupleHoleIssue | TupleAccessorIssue | TupleExcessPropertyIssue;
 /**
  * An error returned by one element Type in a {@link tuple}.
  *
@@ -5208,12 +5266,66 @@ export type TupleElementIssue<Error extends TypeError> = Error extends TypeError
 export type TupleElementsError<Error extends TypeError> = [Error] extends [
     never
 ] ? never : TupleItemsErrorValue<Error, false>;
-interface TupleItemsErrorValue<Error extends TypeError, IncludeStructuralIssues extends boolean> extends TypeError<"Tuple"> {
-    readonly reason: {
-        readonly kind: "Items";
-        readonly issues: NonEmptyReadonlyArray<(true extends IncludeStructuralIssues ? TupleStructuralIssue : never) | TupleElementIssue<Error>>;
-    };
-}
+/**
+ * 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
+ * element stages. This collapsed input boundary keeps a Tuple to at most one
+ * `.parent` suffix even when its element Types have different pipeline depths.
+ *
+ * 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. Foreign-realm arrays are accepted
+ * when their own data representation is valid. Sparse arrays, accessor
+ * elements, and excess properties are rejected.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertOk,
+ *   Int64FromInt64String,
+ *   String,
+ *   tuple,
+ * } from "@evolu/common";
+ *
+ * const Entry = tuple(String, Int64FromInt64String);
+ *
+ * assertOk(Entry.fromUnknown(["count", "1"]), ["count", 1n]);
+ * assertOk(Entry.from.parent(["count", "1"]), ["count", 1n]);
+ * ```
+ *
+ * @group Collection
+ */
+export declare function tuple<const Elements extends TupleElements>(...elements: Elements & TupleValidation<Elements>): TupleType<Elements>;
+type TupleElements = NonEmptyReadonlyArray<TypeNode>;
+type TupleShape<Elements extends TupleElements, Field extends "Input" | "Output" | "CanonicalInput"> = {
+    readonly [Index in keyof Elements]: Elements[Index] extends TypeNode ? Field extends "CanonicalInput" ? CanonicalInputOf<Elements[Index]> : Elements[Index][Field] : never;
+};
+type TupleParents<Elements extends TupleElements> = Elements[number]["parent"];
+type TupleFromErrors<Elements extends TupleElements> = {
+    readonly [Index in keyof Elements]: Elements[Index] extends TypeNode ? TypeFromError<Elements[Index]> : never;
+}[number];
+type RootTupleElements<Elements extends TupleElements> = {
+    readonly [Index in keyof Elements]: Elements[Index] extends TypeNode ? RootType<Elements[Index]> : never;
+};
+type TupleValidation<Elements extends TupleElements> = [
+    ValidateTupleElements<Elements>
+] extends [never] ? unknown : readonly [ValidationFailure<ValidateTupleElements<Elements>>];
+type ValidateTupleElements<Elements extends TupleElements> = number extends Elements["length"] ? TupleElementsTupleError : IsUnion<Elements["length"]> extends false ? {
+    readonly [Index in keyof Elements & `${number}`]: IsUnion<Elements[Index]> extends false ? Elements[Index] extends ConcreteTypeNode ? never : TupleElementConcreteTypeError : TupleElementConcreteTypeError;
+}[keyof Elements & `${number}`] : TupleElementsTupleError;
+type TupleElementsTupleError = CompileTimeError<"Type", "Elements must use one concrete finite non-empty tuple of Types.">;
+type TupleElementConcreteTypeError = CompileTimeError<"Type", "Element must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
+type TupleStructuralIssue = TupleHoleIssue | TupleAccessorIssue | TupleExcessPropertyIssue;
 /**
  * Decimal integer string from `"0"` to `"9"`.
  *
@@ -5323,52 +5435,185 @@ type PlainObjectError = ObjectError<Readonly<Record<never, never>>, ObjectProper
 declare const _Object: Type<"Object", Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, PlainObjectError, null, PlainObjectError, never, Readonly<Record<string, unknown>>>;
 export { _Object as Object };
 /**
- * Record {@link Type}.
+ * The {@link Type} returned by {@link record}.
  *
- * Use `record(Key, Value)` for readonly Records with dynamic string keys, such
- * as scores by user ID or settings by name. Use {@link object} when property
- * names are fixed.
+ * @group Objects
+ */
+export interface RecordType<KeyType extends TypeNode, ValueType extends TypeNode> extends Type<"Record", RecordShape<KeyType, ValueType, "Input">, RecordShape<KeyType, ValueType, "Output">, RecordNodeError<KeyType, ValueType>, RecordParent<KeyType, ValueType>, RecordError<InferErrors<KeyType>, InferErrors<ValueType>, RecordCollisionFor<KeyType>>, never, CanonicalInputSubset<RecordShape<KeyType, ValueType, "Input">, RecordShape<KeyType, ValueType, "CanonicalInput">>, AllTypesUseIdentityEncoding<KeyType | ValueType>> {
+    readonly [reflectedTypesSymbol]?: KeyType | ValueType;
+    readonly key: KeyType;
+    readonly value: ValueType;
+}
+/**
+ * The parent of a {@link RecordType} whose key or value Type has a parent.
  *
- * `fromUnknown` validates the Record and runs the complete `Key` and `Value`
- * pipelines. `from` accepts the Record Output. When either entry Type has a
- * parent, `from.parent` accepts a Record of their root Outputs and runs their
- * remaining stages. This collapsed input boundary keeps a Record to at most one
- * `.parent` suffix.
+ * Its key and value are the root Types of the child record's key and value, and
+ * it has no parent itself.
  *
- * By default, validation returns the first issue. Pass `{ errors: "all" }` to
- * collect issues across the whole Record.
+ * @group Objects
+ */
+export interface RootRecordType<KeyType extends TypeNode, ValueType extends TypeNode> extends Type<"Record", RecordShape<KeyType, ValueType, "Input">, RecordShape<KeyType, ValueType, "Output">, RecordError<InferErrors<KeyType>, InferErrors<ValueType>, never>, null, RecordError<InferErrors<KeyType>, InferErrors<ValueType>, never>, never, CanonicalInputSubset<RecordShape<KeyType, ValueType, "Input">, RecordShape<KeyType, ValueType, "CanonicalInput">>, AllTypesUseIdentityEncoding<KeyType | ValueType>> {
+    readonly [reflectedTypesSymbol]?: KeyType | ValueType;
+    readonly key: KeyType;
+    readonly value: ValueType;
+}
+/**
+ * Error returned while validating a {@link record} and its entries.
  *
- * 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.
+ * @group Objects
+ */
+export type RecordError<KeyError extends TypeError = TypeError, ValueError extends TypeError = TypeError, Collision extends RecordCollisionIssue = RecordCollisionIssue> = RecordNotRecordError | RecordNotPlainRecordError | RecordEntriesErrorValue<KeyError, ValueError, Collision | RecordAccessorIssue | RecordNonEnumerableIssue>;
+/**
+ * Error returned when a {@link record} input is not an object.
  *
- * If transformed keys collide, validation fails instead of overwriting an
- * entry.
+ * @group Objects
+ */
+export interface RecordNotRecordError extends TypeError<"Record"> {
+    readonly reason: {
+        readonly kind: "NotRecord";
+        readonly value: unknown;
+    };
+}
+/**
+ * Error returned when a {@link record} input is not a plain object.
  *
- * ### Example
+ * @group Objects
+ */
+export interface RecordNotPlainRecordError extends TypeError<"Record"> {
+    readonly reason: {
+        readonly kind: "NotPlainRecord";
+        readonly value: object;
+    };
+}
+/**
+ * Entry errors returned by a {@link record} operation.
  *
- * ```ts
- * import {
- *   assertOk,
- *   assertType,
- *   Int64FromInt64String,
- *   String,
- *   record,
- *   type Int64,
- * } from "@evolu/common";
+ * Property structure is omitted by default because typed operations assert
+ * enumerable own data properties. {@link RecordError} includes structural issues
+ * at the unknown-input boundary.
  *
- * const ScoresByUser = record(String, Int64FromInt64String);
- * type ScoresByUser = typeof ScoresByUser.Output;
+ * @group Objects
+ */
+export type RecordEntriesError<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends RecordStructuralIssue = RecordCollisionIssue> = [KeyError | ValueError | StructuralIssue] extends [never] ? never : RecordEntriesErrorValue<KeyError, ValueError, StructuralIssue>;
+/**
+ * The entry error shape of {@link RecordError} and {@link RecordEntriesError}.
  *
- * // Validate an unknown value.
- * const scoresFromUnknown = ScoresByUser.fromUnknown({
- *   ada: "10",
- *   grace: "20",
- * });
+ * @group Objects
+ */
+export interface RecordEntriesErrorValue<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends RecordStructuralIssue> extends TypeError<"Record"> {
+    readonly reason: {
+        readonly kind: "Entries";
+        readonly issues: NonEmptyReadonlyArray<RecordKeyIssue<KeyError> | RecordValueIssue<ValueError> | StructuralIssue>;
+    };
+}
+/**
+ * An invalid key, value, or property structure in a {@link record}.
+ *
+ * @group Objects
+ */
+export type RecordIssue<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends RecordStructuralIssue = RecordCollisionIssue> = RecordKeyIssue<KeyError> | RecordValueIssue<ValueError> | StructuralIssue;
+/**
+ * A property-structure issue returned by {@link record}.
+ *
+ * @group Objects
+ */
+export type RecordStructuralIssue = RecordAccessorIssue | RecordCollisionIssue | RecordNonEnumerableIssue;
+/**
+ * An accessor property rejected by {@link record}.
+ *
+ * @group Objects
+ */
+export interface RecordAccessorIssue {
+    readonly kind: "Accessor";
+    readonly key: string | symbol;
+}
+/**
+ * A non-enumerable property rejected by {@link record}.
+ *
+ * @group Objects
+ */
+export interface RecordNonEnumerableIssue {
+    readonly kind: "NonEnumerable";
+    readonly key: string | symbol;
+}
+/**
+ * An invalid key and its source property key in a {@link record}.
+ *
+ * @group Objects
+ */
+export type RecordKeyIssue<Error extends TypeError> = Error extends TypeError ? {
+    readonly kind: "Key";
+    readonly key: string | symbol;
+    readonly error: Error;
+} : never;
+/**
+ * An invalid value and its property key in a {@link record}.
+ *
+ * @group Objects
+ */
+export type RecordValueIssue<Error extends TypeError> = Error extends TypeError ? {
+    readonly kind: "Value";
+    readonly key: string | symbol;
+    readonly error: Error;
+} : never;
+/**
+ * Two {@link record} keys that decode to the same output key.
+ *
+ * @group Objects
+ */
+export interface RecordCollisionIssue {
+    readonly kind: "Collision";
+    readonly key: string | symbol;
+    readonly previousKey: string | symbol;
+    readonly outputKey: string;
+}
+/**
+ * Record {@link Type}.
+ *
+ * Use `record(Key, Value)` for readonly Records with dynamic string keys, such
+ * as scores by user ID or settings by name. Use {@link object} when property
+ * names are fixed.
+ *
+ * `fromUnknown` validates the Record and runs the complete `Key` and `Value`
+ * pipelines. `from` accepts the Record Output. When either entry Type has a
+ * parent, `from.parent` accepts a Record of their root Outputs and runs their
+ * remaining stages. This collapsed input boundary keeps a Record to at most one
+ * `.parent` suffix.
+ *
+ * By default, validation returns the first issue. Pass `{ errors: "all" }` to
+ * collect issues across the whole Record.
+ *
+ * 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.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertOk,
+ *   assertType,
+ *   Int64FromInt64String,
+ *   String,
+ *   record,
+ *   type Int64,
+ * } from "@evolu/common";
+ *
+ * const ScoresByUser = record(String, Int64FromInt64String);
+ * type ScoresByUser = typeof ScoresByUser.Output;
+ *
+ * // Validate an unknown value.
+ * const scoresFromUnknown = ScoresByUser.fromUnknown({
+ *   ada: "10",
+ *   grace: "20",
+ * });
  *
  * assertOk(scoresFromUnknown, { ada: 10n, grace: 20n });
  *
@@ -5462,16 +5707,6 @@ export { _Object as Object };
  * @group Objects
  */
 export declare const record: <KeyType extends ConcreteTypeNode, ValueType extends ConcreteTypeNode>(key: ValidateRecordKeyType<KeyType>, value: ValidateRecordValueType<ValueType>) => RecordType<KeyType, ValueType>;
-/**
- * The {@link Type} returned by {@link record}.
- *
- * @group Objects
- */
-export interface RecordType<KeyType extends TypeNode, ValueType extends TypeNode> extends Type<"Record", RecordShape<KeyType, ValueType, "Input">, RecordShape<KeyType, ValueType, "Output">, RecordNodeError<KeyType, ValueType>, RecordParent<KeyType, ValueType>, RecordError<InferErrors<KeyType>, InferErrors<ValueType>, RecordCollisionFor<KeyType>>, never, CanonicalInputSubset<RecordShape<KeyType, ValueType, "Input">, RecordShape<KeyType, ValueType, "CanonicalInput">>, AllTypesUseIdentityEncoding<KeyType | ValueType>> {
-    readonly [reflectedTypesSymbol]?: KeyType | ValueType;
-    readonly key: KeyType;
-    readonly value: ValueType;
-}
 interface RecordTypeNode extends TypeNode {
     readonly name: "Record";
     readonly key: TypeNode;
@@ -5494,7 +5729,7 @@ type RecordShape<KeyType extends TypeNode, ValueType extends TypeNode, Field ext
 type RecordTypeField<T extends TypeNode, Field extends "Input" | "Output" | "CanonicalInput"> = Field extends "CanonicalInput" ? CanonicalInputOf<T> : T[Field];
 type RecordParent<KeyType extends TypeNode, ValueType extends TypeNode> = [
     KeyType["parent"] | ValueType["parent"]
-] extends [null] ? null : RecordType<RootType<KeyType>, RootType<ValueType>>;
+] extends [null] ? null : RootRecordType<RootType<KeyType>, RootType<ValueType>>;
 type RecordNodeError<KeyType extends TypeNode, ValueType extends TypeNode> = [
     KeyType["parent"] | ValueType["parent"]
 ] extends [null] ? RecordError<InferErrors<KeyType>, InferErrors<ValueType>, never> : RecordEntriesError<TypeFromError<KeyType>, TypeFromError<ValueType>, RecordCollisionFor<KeyType>>;
@@ -5506,111 +5741,6 @@ type ValidateRecordValueType<T extends ConcreteTypeNode> = IsUnion<T> extends fa
 type RecordKeyConcreteTypeError = CompileTimeError<"Type", "Record key must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
 type RecordValueConcreteTypeError = CompileTimeError<"Type", "Record value must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
 type RecordKeyStringTypeError = CompileTimeError<"Type", "Record key Type Input and Output must extend string.">;
-/**
- * Error returned while validating a {@link record} and its entries.
- *
- * @group Objects
- */
-export type RecordError<KeyError extends TypeError = TypeError, ValueError extends TypeError = TypeError, Collision extends RecordCollisionIssue = RecordCollisionIssue> = RecordNotRecordError | RecordNotPlainRecordError | RecordEntriesErrorValue<KeyError, ValueError, Collision | RecordAccessorIssue | RecordNonEnumerableIssue>;
-/**
- * Error returned when a {@link record} input is not an object.
- *
- * @group Objects
- */
-export interface RecordNotRecordError extends TypeError<"Record"> {
-    readonly reason: {
-        readonly kind: "NotRecord";
-        readonly value: unknown;
-    };
-}
-/**
- * Error returned when a {@link record} input is not a plain object.
- *
- * @group Objects
- */
-export interface RecordNotPlainRecordError extends TypeError<"Record"> {
-    readonly reason: {
-        readonly kind: "NotPlainRecord";
-        readonly value: object;
-    };
-}
-/**
- * Entry errors returned by a {@link record} operation.
- *
- * Property structure is omitted by default because typed operations assert
- * enumerable own data properties. {@link RecordError} includes structural issues
- * at the unknown-input boundary.
- *
- * @group Objects
- */
-export type RecordEntriesError<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends RecordStructuralIssue = RecordCollisionIssue> = [KeyError | ValueError | StructuralIssue] extends [never] ? never : RecordEntriesErrorValue<KeyError, ValueError, StructuralIssue>;
-/**
- * An invalid key, value, or property structure in a {@link record}.
- *
- * @group Objects
- */
-export type RecordIssue<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends RecordStructuralIssue = RecordCollisionIssue> = RecordKeyIssue<KeyError> | RecordValueIssue<ValueError> | StructuralIssue;
-/**
- * A property-structure issue returned by {@link record}.
- *
- * @group Objects
- */
-export type RecordStructuralIssue = RecordAccessorIssue | RecordCollisionIssue | RecordNonEnumerableIssue;
-/**
- * An accessor property rejected by {@link record}.
- *
- * @group Objects
- */
-export interface RecordAccessorIssue {
-    readonly kind: "Accessor";
-    readonly key: string | symbol;
-}
-/**
- * A non-enumerable property rejected by {@link record}.
- *
- * @group Objects
- */
-export interface RecordNonEnumerableIssue {
-    readonly kind: "NonEnumerable";
-    readonly key: string | symbol;
-}
-/**
- * An invalid key and its source property key in a {@link record}.
- *
- * @group Objects
- */
-export type RecordKeyIssue<Error extends TypeError> = Error extends TypeError ? {
-    readonly kind: "Key";
-    readonly key: string | symbol;
-    readonly error: Error;
-} : never;
-/**
- * An invalid value and its property key in a {@link record}.
- *
- * @group Objects
- */
-export type RecordValueIssue<Error extends TypeError> = Error extends TypeError ? {
-    readonly kind: "Value";
-    readonly key: string | symbol;
-    readonly error: Error;
-} : never;
-/**
- * Two {@link record} keys that decode to the same output key.
- *
- * @group Objects
- */
-export interface RecordCollisionIssue {
-    readonly kind: "Collision";
-    readonly key: string | symbol;
-    readonly previousKey: string | symbol;
-    readonly outputKey: string;
-}
-interface RecordEntriesErrorValue<KeyError extends TypeError, ValueError extends TypeError, StructuralIssue extends RecordStructuralIssue> extends TypeError<"Record"> {
-    readonly reason: {
-        readonly kind: "Entries";
-        readonly issues: NonEmptyReadonlyArray<RecordKeyIssue<KeyError> | RecordValueIssue<ValueError> | StructuralIssue>;
-    };
-}
 /**
  * An optional property used to construct an {@link object} Type.
  *
@@ -5789,32 +5919,142 @@ interface RuntimeDefaultOperations {
     readonly createObject: (props: ObjectProps, record: RuntimeRecordTypeNode | undefined) => ObjectTypeNode;
     readonly partial: (type: RuntimeTypeNode) => OptionalProperty<TypeNode>;
 }
+/**
+ * The {@link Type} returned by {@link object}.
+ *
+ * @group Objects
+ */
+export type ObjectType<Props extends ObjectProps, Rest extends ObjectRecordTypeNode | undefined = undefined> = Props extends ObjectValueProps ? Rest extends ObjectRecordTypeNode ? ObjectWithRecordType<Props, Rest> : StrictObjectType<Props> : DefaultObjectType<Props, Rest>;
 /**
  * Properties used to construct an {@link object} Type.
  *
  * @group Objects
  */
 export type ObjectProps = Readonly<Record<string, TypeNode | OptionalProperty<TypeNode> | WithDefaultProperty<TypeNode, unknown, "replace" | "preserve">>>;
-type ObjectValueProps = Readonly<Record<string, TypeNode | OptionalProperty<TypeNode>>>;
-type ObjectProperty = ObjectProps[string];
 /**
- * Plain object {@link Type}.
+ * An error returned while validating an {@link object} and its properties.
  *
- * Use `object(props)` for objects with fixed property names. Properties are
- * required unless wrapped with {@link optional}. An optional property may be
- * absent, but a present value is still validated and does not implicitly accept
- * `undefined`. Wrapping an optional property with {@link withDefault} keeps the
- * input optional and makes the decoded output required. A default for a
- * nullable or undefined-accepting Type alone does not make the property
- * optional.
+ * Declare required properties as required keys and optional properties as
+ * optional keys. Object adds its structural property errors automatically, so
+ * each value is only the error returned by that property's Type. The interface
+ * can be extended by recursive error declarations.
  *
- * Without a second argument, `fromUnknown` rejects additional properties. Pass
- * a {@link record} with the predefined {@link String} key Type to validate and
- * preserve additional string-keyed properties.
+ * @group Objects
+ */
+export interface ObjectError<Errors extends {
+    readonly [Key in keyof Errors]: TypeError | undefined;
+} = Readonly<Record<string, TypeError>>, RestError extends TypeError = ObjectExcessPropertyError> extends TypeError<"Object"> {
+    readonly reason: ObjectNotObjectError["reason"] | ObjectUnexpectedPrototypeError["reason"] | ObjectPropertiesError<ObjectStructuralPropertyErrors<Errors>, RestError>["reason"];
+}
+/**
+ * An error returned when a required {@link object} property is absent.
  *
- * `fromUnknown` requires a plain object. Plain object Types model only own
- * enumerable data properties, so Object prototype properties neither satisfy
- * required properties nor make optional properties present. This keeps Outputs
+ * `ObjectMissingProperty` is reserved for absent required properties. Property
+ * {@link Type | Types} must use another error tag.
+ *
+ * @group Objects
+ */
+export interface ObjectMissingPropertyError extends TypeError<"ObjectMissingProperty"> {
+}
+/**
+ * An error returned when a present {@link object} property is not represented as
+ * an enumerable data property.
+ *
+ * `ObjectPropertyAccess` is reserved for this structural failure. Property
+ * {@link Type | Types} must use another error tag.
+ *
+ * @group Objects
+ */
+export interface ObjectPropertyAccessError extends TypeError<"ObjectPropertyAccess"> {
+    readonly reason: "Accessor" | "NonEnumerable";
+}
+/**
+ * An error returned when an {@link object} input is not an object.
+ *
+ * @group Objects
+ */
+export interface ObjectNotObjectError extends TypeError<"Object"> {
+    readonly reason: {
+        readonly kind: "NotObject";
+        readonly value: unknown;
+    };
+}
+/**
+ * An error returned when an {@link object} input falls outside its supported
+ * plain-object prototype boundary.
+ *
+ * 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
+ */
+export interface ObjectUnexpectedPrototypeError extends TypeError<"Object"> {
+    readonly reason: {
+        readonly kind: "UnexpectedPrototype";
+        readonly value: object;
+    };
+}
+/**
+ * An error returned for an input property outside an Object Type's allowed key
+ * domain.
+ *
+ * This includes a property not declared by an {@link object} schema and a symbol
+ * property on the predefined {@link Object}. The property key locates this error
+ * in the containing Object error map. `ObjectExcessProperty` is reserved for
+ * this structural failure. Property {@link Type | Types} must use another error
+ * tag.
+ *
+ * @group Objects
+ */
+export interface ObjectExcessPropertyError extends TypeError<"ObjectExcessProperty"> {
+}
+/**
+ * An error returned while validating the properties of an {@link object}.
+ *
+ * @group Objects
+ */
+export interface ObjectPropertiesError<Errors extends {
+    readonly [Key in keyof Errors]: TypeError | undefined;
+}, RestError extends TypeError = never> extends TypeError<"Object"> {
+    readonly reason: {
+        readonly kind: "Properties";
+        readonly errors: Partial<Errors> & ([RestError] extends [never] ? unknown : ObjectUnknownPropertyErrors<Exclude<Errors[keyof Errors], undefined>, RestError>);
+    };
+}
+/**
+ * The `fromUnknown` error of an {@link object} Type without a {@link record}
+ * rest.
+ *
+ * It has the shape of {@link ObjectError} with the structural property errors
+ * already included in `Errors`.
+ *
+ * @group Objects
+ */
+export interface StrictObjectFromUnknownError<Errors extends {
+    readonly [Key in keyof Errors]: TypeError;
+}> extends TypeError<"Object"> {
+    readonly reason: ObjectNotObjectError["reason"] | ObjectUnexpectedPrototypeError["reason"] | ObjectPropertiesError<Errors, ObjectExcessPropertyError>["reason"];
+}
+/**
+ * Plain object {@link Type}.
+ *
+ * Use `object(props)` for objects with fixed property names. Properties are
+ * required unless wrapped with {@link optional}. An optional property may be
+ * absent, but a present value is still validated and does not implicitly accept
+ * `undefined`. Wrapping an optional property with {@link withDefault} keeps the
+ * input optional and makes the decoded output required. A default for a
+ * nullable or undefined-accepting Type alone does not make the property
+ * optional.
+ *
+ * Without a second argument, `fromUnknown` rejects additional properties. Pass
+ * a {@link record} with the predefined {@link String} key Type to validate and
+ * preserve additional string-keyed properties.
+ *
+ * `fromUnknown` requires a plain object. Plain object Types model only own
+ * enumerable data properties, so Object prototype properties neither satisfy
+ * required properties nor make optional properties present. This keeps Outputs
  * valid after ordinary object spread restores `Object.prototype`.
  *
  * The prototype must satisfy the realm-neutral structural heuristic described
@@ -5994,6 +6234,8 @@ export declare function object<const Props extends ObjectProps, const Rest exten
 ] extends [never] ? [] : [
     ValidationFailure<ObjectValidationError<Props> | ObjectRecordValidationError<Props, Rest>>
 ]): ObjectType<Props, Rest>;
+type ObjectValueProps = Readonly<Record<string, TypeNode | OptionalProperty<TypeNode>>>;
+type ObjectProperty = ObjectProps[string];
 interface ObjectTypeNode extends TypeNode {
     readonly name: "Object";
     readonly props: ObjectProps;
@@ -6032,12 +6274,6 @@ type ObjectRecordKeyTypeError = CompileTimeError<"Type", "Object Record key must
 type ObjectRecordInputTypeError = CompileTimeError<"Type", "Every declared property Type Input must extend the Object Record value Type Input.">;
 type ObjectRecordOutputTypeError = CompileTimeError<"Type", "Every declared property Type Output must extend the Object Record value Type Output.">;
 type ObjectRecordCanonicalInputTypeError = CompileTimeError<"Type", "Every declared property Type CanonicalInput must extend the Object Record value Type CanonicalInput.">;
-/**
- * The {@link Type} returned by {@link object}.
- *
- * @group Objects
- */
-export type ObjectType<Props extends ObjectProps, Rest extends ObjectRecordTypeNode | undefined = undefined> = Props extends ObjectValueProps ? Rest extends ObjectRecordTypeNode ? ObjectWithRecordType<Props, Rest> : StrictObjectType<Props> : DefaultObjectType<Props, Rest>;
 type ObjectValueType<Props extends ObjectValueProps, Rest extends ObjectRecordTypeNode | undefined> = Rest extends ObjectRecordTypeNode ? ObjectWithRecordType<Props, Rest> : StrictObjectType<Props>;
 type DefaultableObjectPropertyType<Property extends ObjectProperty> = Property extends WithDefaultProperty<infer T, infer Value, infer Strategy> ? Type<"WithDefault", T["Input"], WithDefaultOutput<T, Value, Strategy, "missing" | DefaultOriginal<T>>, never, T, InferErrors<T>, never, T["CanonicalInput"], false> : Property extends TypeNode | OptionalProperty<TypeNode> ? ObjectPropertyType<Property> : never;
 type DefaultInputProps<Props extends ObjectProps> = {
@@ -6093,8 +6329,14 @@ type ObjectWithRecordParents<Props extends ObjectValueProps, Rest extends Object
 type RootObjectProps<Props extends ObjectValueProps> = {
     readonly [Key in keyof Props]: Props[Key] extends OptionalProperty<infer T> ? OptionalProperty<RootType<T>> : Props[Key] extends TypeNode ? RootType<Props[Key]> : never;
 };
-type RootObjectRecord<Rest extends ObjectRecordTypeNode> = RecordType<typeof String, RootType<Rest["value"]>>;
-interface ObjectWithRecordReflection<Props extends ObjectValueProps, Rest extends ObjectRecordTypeNode> {
+type RootObjectRecord<Rest extends ObjectRecordTypeNode> = Rest["parent"] extends infer Parent extends ObjectRecordTypeNode ? Parent : Rest;
+/**
+ * The declared properties and {@link record} rest of an {@link object} Type
+ * created with a Record.
+ *
+ * @group Objects
+ */
+export interface ObjectWithRecordReflection<Props extends ObjectValueProps, Rest extends ObjectRecordTypeNode> {
     readonly props: Readonly<Props>;
     readonly record: Rest;
 }
@@ -6108,103 +6350,6 @@ type StrictObjectFromUnknownPropertyErrors<Props extends ObjectValueProps> = {
 } & {
     readonly [Key in OptionalObjectKeys<Props>]: Props[Key][typeof errorsSymbol] | ObjectPropertyAccessError;
 };
-/**
- * An error returned when a required {@link object} property is absent.
- *
- * `ObjectMissingProperty` is reserved for absent required properties. Property
- * {@link Type | Types} must use another error tag.
- *
- * @group Objects
- */
-export interface ObjectMissingPropertyError extends TypeError<"ObjectMissingProperty"> {
-}
-/**
- * An error returned when a present {@link object} property is not represented as
- * an enumerable data property.
- *
- * `ObjectPropertyAccess` is reserved for this structural failure. Property
- * {@link Type | Types} must use another error tag.
- *
- * @group Objects
- */
-export interface ObjectPropertyAccessError extends TypeError<"ObjectPropertyAccess"> {
-    readonly reason: "Accessor" | "NonEnumerable";
-}
-/**
- * An error returned when an {@link object} input is not an object.
- *
- * @group Objects
- */
-export interface ObjectNotObjectError extends TypeError<"Object"> {
-    readonly reason: {
-        readonly kind: "NotObject";
-        readonly value: unknown;
-    };
-}
-/**
- * An error returned when an {@link object} input falls outside its supported
- * plain-object prototype boundary.
- *
- * 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
- */
-export interface ObjectUnexpectedPrototypeError extends TypeError<"Object"> {
-    readonly reason: {
-        readonly kind: "UnexpectedPrototype";
-        readonly value: object;
-    };
-}
-/**
- * An error returned for an input property outside an Object Type's allowed key
- * domain.
- *
- * This includes a property not declared by an {@link object} schema and a symbol
- * property on the predefined {@link Object}. The property key locates this error
- * in the containing Object error map. `ObjectExcessProperty` is reserved for
- * this structural failure. Property {@link Type | Types} must use another error
- * tag.
- *
- * @group Objects
- */
-export interface ObjectExcessPropertyError extends TypeError<"ObjectExcessProperty"> {
-}
-/**
- * An error returned while validating an {@link object} and its properties.
- *
- * Declare required properties as required keys and optional properties as
- * optional keys. Object adds its structural property errors automatically, so
- * each value is only the error returned by that property's Type. The interface
- * can be extended by recursive error declarations.
- *
- * @group Objects
- */
-export interface ObjectError<Errors extends {
-    readonly [Key in keyof Errors]: TypeError | undefined;
-} = Readonly<Record<string, TypeError>>, RestError extends TypeError = ObjectExcessPropertyError> extends TypeError<"Object"> {
-    readonly reason: ObjectNotObjectError["reason"] | ObjectUnexpectedPrototypeError["reason"] | ObjectPropertiesError<ObjectStructuralPropertyErrors<Errors>, RestError>["reason"];
-}
-/**
- * An error returned while validating the properties of an {@link object}.
- *
- * @group Objects
- */
-export interface ObjectPropertiesError<Errors extends {
-    readonly [Key in keyof Errors]: TypeError | undefined;
-}, RestError extends TypeError = never> extends TypeError<"Object"> {
-    readonly reason: {
-        readonly kind: "Properties";
-        readonly errors: Partial<Errors> & ([RestError] extends [never] ? unknown : ObjectUnknownPropertyErrors<Exclude<Errors[keyof Errors], undefined>, RestError>);
-    };
-}
-interface StrictObjectFromUnknownError<Errors extends {
-    readonly [Key in keyof Errors]: TypeError;
-}> extends TypeError<"Object"> {
-    readonly reason: ObjectNotObjectError["reason"] | ObjectUnexpectedPrototypeError["reason"] | ObjectPropertiesError<Errors, ObjectExcessPropertyError>["reason"];
-}
 type ObjectStructuralPropertyErrors<Errors extends {
     readonly [Key in keyof Errors]: TypeError | undefined;
 }> = {
@@ -6216,6 +6361,14 @@ type ObjectFromParentError<Errors extends {
 type ObjectUnknownPropertyErrors<Error extends TypeError, RestError extends TypeError> = Readonly<Record<PropertyKey, Error | RestError | undefined>>;
 type ObjectRestFromUnknownError<Rest extends ObjectRecordTypeNode | undefined> = Rest extends ObjectRecordTypeNode ? ObjectPropertyAccessError | RecordEntriesErrorValue<TypeOfError<"String">, InferErrors<Rest["value"]>, never> : ObjectExcessPropertyError;
 type ObjectRestFromParentError<Rest extends ObjectRecordTypeNode | undefined> = Rest extends ObjectRecordTypeNode ? RecordEntriesError<never, TypeFromError<Rest["value"]>, never> : never;
+/**
+ * Maps every required object property Type to an optional property.
+ *
+ * @group Objects
+ */
+export type PartialObjectProps<Props extends ObjectProps> = {
+    readonly [Key in keyof Props]: Props[Key] extends WithDefaultProperty<infer T, infer Value, infer Strategy> ? OptionalProperty<WithDefaultType<T, Value, Strategy>> : Props[Key] extends OptionalProperty<TypeNode> ? Props[Key] : Props[Key] extends TypeNode ? OptionalProperty<Props[Key]> : never;
+};
 /**
  * Object {@link Type} with every property optional.
  *
@@ -6246,12 +6399,13 @@ type ObjectRestFromParentError<Rest extends ObjectRecordTypeNode | undefined> =
  */
 export declare const partial: <const Props extends ObjectProps>(props: Props, ..._validation: [ObjectValidationError<Props>] extends [never] ? [] : [ValidationFailure<ObjectValidationError<Props>>]) => ObjectType<PartialObjectProps<Props>>;
 /**
- * Maps every required object property Type to an optional property.
+ * Maps object properties whose Union Type includes {@link Null} to optional
+ * properties.
  *
  * @group Objects
  */
-export type PartialObjectProps<Props extends ObjectProps> = {
-    readonly [Key in keyof Props]: Props[Key] extends WithDefaultProperty<infer T, infer Value, infer Strategy> ? OptionalProperty<WithDefaultType<T, Value, Strategy>> : Props[Key] extends OptionalProperty<TypeNode> ? Props[Key] : Props[Key] extends TypeNode ? OptionalProperty<Props[Key]> : never;
+export type NullableToOptionalProps<Props extends ObjectProps> = {
+    readonly [Key in keyof Props]: Props[Key] extends OptionalProperty<TypeNode> ? Props[Key] : Props[Key] extends UnionType<infer Members> ? typeof Null extends Members[number] ? OptionalProperty<Props[Key]> : Props[Key] : Props[Key];
 };
 /**
  * Object {@link Type} making every property whose Union Type includes
@@ -6286,15 +6440,6 @@ export type PartialObjectProps<Props extends ObjectProps> = {
  * @group Objects
  */
 export declare const nullableToOptional: <const Props extends ObjectProps>(props: Props, ..._validation: [ObjectValidationError<Props>] extends [never] ? [] : [ValidationFailure<ObjectValidationError<Props>>]) => ObjectType<NullableToOptionalProps<Props>>;
-/**
- * Maps object properties whose Union Type includes {@link Null} to optional
- * properties.
- *
- * @group Objects
- */
-export type NullableToOptionalProps<Props extends ObjectProps> = {
-    readonly [Key in keyof Props]: Props[Key] extends OptionalProperty<TypeNode> ? Props[Key] : Props[Key] extends UnionType<infer Members> ? typeof Null extends Members[number] ? OptionalProperty<Props[Key]> : Props[Key] : Props[Key];
-};
 /**
  * Object {@link Type} without the selected declared properties.
  *
@@ -6332,6 +6477,16 @@ export interface ObjectKeysType<Key extends TypeNode, T extends TypeNode & {
     readonly output: T;
     readonly [reflectedTypesSymbol]?: Key | T;
 }
+/**
+ * An error from the externally named object decoded by {@link objectKeys}.
+ *
+ * @group Objects
+ */
+export interface ObjectKeysError<T extends TypeNode & {
+    readonly props: ObjectProps;
+}> extends TypeError<"ObjectKeys">, TransparentTypeError {
+    readonly error: ObjectError<Readonly<Record<string, T["props"][keyof T["props"]][typeof errorsSymbol] | ObjectMissingPropertyError | ObjectExcessPropertyError>>>;
+}
 /**
  * Renames a strict {@link object} Type's encoded keys using a string codec.
  *
@@ -6386,16 +6541,6 @@ export declare const objectKeys: <Key extends ConcreteTypeNode & {
     readonly props: ObjectProps;
     readonly record?: never;
 }>(type: T & ValidateOutput<T>) => ObjectKeysType<Key, T>;
-/**
- * An error from the externally named object decoded by {@link objectKeys}.
- *
- * @group Objects
- */
-export interface ObjectKeysError<T extends TypeNode & {
-    readonly props: ObjectProps;
-}> extends TypeError<"ObjectKeys">, TransparentTypeError {
-    readonly error: ObjectError<Readonly<Record<string, T["props"][keyof T["props"]][typeof errorsSymbol] | ObjectMissingPropertyError | ObjectExcessPropertyError>>>;
-}
 /**
  * Creates a {@link Type} for {@link Result} values.
  *
@@ -6411,53 +6556,145 @@ export interface ObjectKeysError<T extends TypeNode & {
  *   assertOk,
  *   NonNegativeInt,
  *   String,
- *   object,
- *   result,
+ *   object,
+ *   result,
+ *   typed,
+ * } from "@evolu/common";
+ *
+ * const SyncResponse = result(
+ *   object({ timestamp: NonNegativeInt }),
+ *   typed("SyncFailed", { message: String }),
+ * );
+ *
+ * const validated = SyncResponse.fromUnknown({
+ *   ok: true,
+ *   value: { timestamp: 42 },
+ * });
+ *
+ * assertOk(validated, { ok: true, value: { timestamp: 42 } });
+ * assertOk(validated.value, { timestamp: 42 });
+ * ```
+ *
+ * @group Results
+ */
+export declare function result<OkType extends ConcreteTypeNode, ErrorType extends ConcreteTypeNode>(okType: ValidateElement<OkType>, errorType: ValidateElement<ErrorType>): DiscriminatedUnionType<"ok", readonly [
+    ObjectType<{
+        readonly ok: LiteralType<true>;
+        readonly value: OkType;
+    }>,
+    ObjectType<{
+        readonly ok: LiteralType<false>;
+        readonly error: ErrorType;
+    }>
+]>;
+/**
+ * A {@link result} Type for `Result<unknown, unknown>`.
+ *
+ * Use this when only the Result structure must be validated, while its value
+ * and error remain intentionally unknown.
+ *
+ * @group Results
+ */
+export declare const UnknownResult: DiscriminatedUnionType<"ok", readonly [StrictObjectType<{
+    readonly ok: LiteralType<true>;
+    readonly value: Type<"Unknown", unknown, unknown, never, null, never, never, unknown, true>;
+}>, StrictObjectType<{
+    readonly ok: LiteralType<false>;
+    readonly error: Type<"Unknown", unknown, unknown, never, null, never, never, unknown, true>;
+}>]>;
+export type UnknownResult = typeof UnknownResult.Output;
+/**
+ * The {@link ObjectType} returned by {@link typed}.
+ *
+ * @group Discriminated unions
+ */
+export type TypedType<Tag extends TypeName, Props extends ObjectProps = Readonly<Record<never, never>>, Rest extends ObjectRecordTypeNode | undefined = undefined> = ObjectType<TypedProps<Tag, Props>, Rest>;
+/**
+ * A TypeScript interface with a literal `type` property.
+ *
+ * Use `Typed` for both domain objects in discriminated unions and plain domain
+ * errors returned by {@link Result}. Name a domain error interface `XError`.
+ * When `X` already describes a failure, use `X` for its `type` discriminant
+ * because `Error` describes the interface's role rather than the runtime error
+ * kind. Keep `Error` when it is needed to make the discriminant unambiguous,
+ * such as `TimeoutError`.
+ *
+ * Typed unions model mutually exclusive states as separate variants instead of
+ * combinations of flags and optional properties. TypeScript narrows a union by
+ * its literal `type` property. To enforce exhaustive handling, return from
+ * every case of a value-producing switch or assert that the remaining value is
+ * `never` in the `default` case of a side-effecting switch.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   err,
+ *   ok,
+ *   type Result,
+ *   type Typed,
+ * } from "@evolu/common";
+ *
+ * interface User extends Typed<"User"> {
+ *   readonly id: string;
+ * }
+ *
+ * interface UserNotFoundError extends Typed<"UserNotFound"> {
+ *   readonly id: string;
+ * }
+ *
+ * const getUser = (id: string): Result<User, UserNotFoundError> =>
+ *   id === "user-1"
+ *     ? ok({ type: "User", id })
+ *     : err({ type: "UserNotFound", id });
+ *
+ * assertOk(getUser("user-1"), { type: "User", id: "user-1" });
+ * assertErr(getUser("missing"), { type: "UserNotFound", id: "missing" });
+ * ```
+ *
+ * @group Discriminated unions
+ */
+export interface Typed<Tag extends TypeName> {
+    readonly type: Tag;
+}
+/**
+ * Extracts members of a {@link Typed} Output union by their `type` literal.
+ *
+ * The requested tag is constrained to the union's actual discriminator values,
+ * so a misspelling is a TypeScript error instead of silently producing
+ * `never`.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertType,
+ *   String,
+ *   discriminatedUnion,
  *   typed,
+ *   type ExtractTyped,
  * } from "@evolu/common";
  *
- * const SyncResponse = result(
- *   object({ timestamp: NonNegativeInt }),
- *   typed("SyncFailed", { message: String }),
- * );
- *
- * const validated = SyncResponse.fromUnknown({
- *   ok: true,
- *   value: { timestamp: 42 },
- * });
+ * const Create = typed("Create", { id: String });
+ * const Delete = typed("Delete", { id: String });
+ * const Message = discriminatedUnion(Create, Delete);
+ * type Message = typeof Message.Output;
  *
- * assertOk(validated, { ok: true, value: { timestamp: 42 } });
- * assertOk(validated.value, { timestamp: 42 });
- * ```
+ * type CreateMessage = ExtractTyped<Message, "Create">;
  *
- * @group Results
- */
-export declare function result<OkType extends ConcreteTypeNode, ErrorType extends ConcreteTypeNode>(okType: ValidateElement<OkType>, errorType: ValidateElement<ErrorType>): DiscriminatedUnionType<"ok", readonly [
-    ObjectType<{
-        readonly ok: LiteralType<true>;
-        readonly value: OkType;
-    }>,
-    ObjectType<{
-        readonly ok: LiteralType<false>;
-        readonly error: ErrorType;
-    }>
-]>;
-/**
- * A {@link result} Type for `Result<unknown, unknown>`.
+ * assertType<CreateMessage, typeof Create.Output>();
  *
- * Use this when only the Result structure must be validated, while its value
- * and error remain intentionally unknown.
+ * // @ts-expect-error "Cretae" is not a Message type.
+ * type _Typo = ExtractTyped<Message, "Cretae">;
+ * ```
  *
- * @group Results
+ * @group Discriminated unions
  */
-export declare const UnknownResult: DiscriminatedUnionType<"ok", readonly [StrictObjectType<{
-    readonly ok: LiteralType<true>;
-    readonly value: Type<"Unknown", unknown, unknown, never, null, never, never, unknown, true>;
-}>, StrictObjectType<{
-    readonly ok: LiteralType<false>;
-    readonly error: Type<"Unknown", unknown, unknown, never, null, never, never, unknown, true>;
-}>]>;
-export type UnknownResult = typeof UnknownResult.Output;
+export type ExtractTyped<Output extends Typed<TypeName>, Name extends Output["type"]> = Extract<Output, {
+    readonly type: Name;
+}>;
 /**
  * Creates an {@link ObjectType} with a literal `type` property.
  *
@@ -6557,98 +6794,6 @@ export declare function typed<const Tag extends TypeName, const Props extends Ob
 ] extends [never] ? [] : [
     ValidationFailure<TypedValidationError<Props> | ObjectRecordValidationError<TypedProps<Tag, Props>, Rest>>
 ]): TypedType<Tag, Props, Rest extends ObjectRecordTypeNode ? Rest : never>;
-/**
- * A TypeScript interface with a literal `type` property.
- *
- * Use `Typed` for both domain objects in discriminated unions and plain domain
- * errors returned by {@link Result}. Name a domain error interface `XError`.
- * When `X` already describes a failure, use `X` for its `type` discriminant
- * because `Error` describes the interface's role rather than the runtime error
- * kind. Keep `Error` when it is needed to make the discriminant unambiguous,
- * such as `TimeoutError`.
- *
- * Typed unions model mutually exclusive states as separate variants instead of
- * combinations of flags and optional properties. TypeScript narrows a union by
- * its literal `type` property. To enforce exhaustive handling, return from
- * every case of a value-producing switch or assert that the remaining value is
- * `never` in the `default` case of a side-effecting switch.
- *
- * ### Example
- *
- * ```ts
- * import {
- *   assertErr,
- *   assertOk,
- *   err,
- *   ok,
- *   type Result,
- *   type Typed,
- * } from "@evolu/common";
- *
- * interface User extends Typed<"User"> {
- *   readonly id: string;
- * }
- *
- * const getUser = (id: string): Result<User, UserNotFoundError> =>
- *   id === "user-1"
- *     ? ok({ type: "User", id })
- *     : err({ type: "UserNotFound", id });
- *
- * interface UserNotFoundError extends Typed<"UserNotFound"> {
- *   readonly id: string;
- * }
- *
- * assertOk(getUser("user-1"), { type: "User", id: "user-1" });
- * assertErr(getUser("missing"), { type: "UserNotFound", id: "missing" });
- * ```
- *
- * @group Discriminated unions
- */
-export interface Typed<Tag extends TypeName> {
-    readonly type: Tag;
-}
-/**
- * Extracts members of a {@link Typed} Output union by their `type` literal.
- *
- * The requested tag is constrained to the union's actual discriminator values,
- * so a misspelling is a TypeScript error instead of silently producing
- * `never`.
- *
- * ### Example
- *
- * ```ts
- * import {
- *   assertType,
- *   String,
- *   discriminatedUnion,
- *   typed,
- *   type ExtractTyped,
- * } from "@evolu/common";
- *
- * const Create = typed("Create", { id: String });
- * const Delete = typed("Delete", { id: String });
- * const Message = discriminatedUnion(Create, Delete);
- * type Message = typeof Message.Output;
- *
- * type CreateMessage = ExtractTyped<Message, "Create">;
- *
- * assertType<CreateMessage, typeof Create.Output>();
- *
- * // @ts-expect-error "Cretae" is not a Message type.
- * type _Typo = ExtractTyped<Message, "Cretae">;
- * ```
- *
- * @group Discriminated unions
- */
-export type ExtractTyped<Output extends Typed<TypeName>, Name extends Output["type"]> = Extract<Output, {
-    readonly type: Name;
-}>;
-/**
- * The {@link ObjectType} returned by {@link typed}.
- *
- * @group Discriminated unions
- */
-export type TypedType<Tag extends TypeName, Props extends ObjectProps = Readonly<Record<never, never>>, Rest extends ObjectRecordTypeNode | undefined = undefined> = ObjectType<TypedProps<Tag, Props>, Rest>;
 type TypedProps<Tag extends TypeName, Props extends ObjectProps> = {
     readonly type: LiteralType<Tag>;
 } & Props;
@@ -6730,73 +6875,6 @@ export declare const UnknownNextResult: DiscriminatedUnionType<"ok", readonly [S
     }>>]>;
 }>]>;
 export type UnknownNextResult = typeof UnknownNextResult.Output;
-/**
- * Discriminated union {@link Type}.
- *
- * With no explicit key, the conventional `type` property created by
- * {@link typed} is used. Pass a key first to discriminate
- * {@link ObjectType | Object Types} using a different property.
- *
- * Every member must be an Object Type with a unique required string, number,
- * bigint, or boolean {@link LiteralType} at the discriminator key. Unlike
- * {@link union}, only the selected member is decoded, checked, or encoded. The
- * Discriminated Union Input therefore narrows each member's discriminator from
- * its widened Input to the exact literal that selects that member. Use
- * `fromUnknown` when a value does not yet have that correlated Input type.
- *
- * ### Example
- *
- * ```ts
- * 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);
- *
- * assertOk(Event.fromUnknown({ type: "Created", id: "id" }), {
- *   type: "Created",
- *   id: "id",
- * });
- * ```
- *
- * @group Discriminated unions
- */
-export declare function discriminatedUnion<const Members extends DiscriminatedUnionMembers>(...members: Members & DiscriminatedUnionValidation<"type", Members>): DiscriminatedUnionType<"type", Members>;
-/**
- * Creates a Discriminated Union Type with an explicit discriminator key.
- *
- * ### Example
- *
- * ```ts
- * import {
- *   assertOk,
- *   Number,
- *   String,
- *   discriminatedUnion,
- *   literal,
- *   object,
- * } from "@evolu/common";
- *
- * const Added = object({ kind: literal("added"), value: String });
- * const Removed = object({ kind: literal("removed"), id: Number });
- * const Event = discriminatedUnion("kind", Added, Removed);
- *
- * assertOk(Event.fromUnknown({ kind: "added", value: "Evolu" }), {
- *   kind: "added",
- *   value: "Evolu",
- * });
- * assertOk(Event.fromUnknown({ kind: "removed", id: 1 }), {
- *   kind: "removed",
- *   id: 1,
- * });
- * ```
- */
-export declare function discriminatedUnion<const Key extends string, const Members extends DiscriminatedUnionMembers>(key: ValidateDiscriminatedUnionKey<Key>, ...members: Members & DiscriminatedUnionValidation<Key, Members>): DiscriminatedUnionType<Key, Members>;
 /**
  * The routed {@link Type} returned by {@link discriminatedUnion}.
  *
@@ -6861,19 +6939,86 @@ export interface DiscriminatedUnionDiscriminatorError<Key extends string = strin
  *
  * @group Discriminated unions
  */
-export interface DiscriminatedUnionMemberIssue<Discriminator extends Literal = Literal, Error extends TypeError = TypeError> {
-    readonly kind: "Member";
-    readonly discriminator: Discriminator;
-    readonly error: Error;
-}
+export interface DiscriminatedUnionMemberIssue<Discriminator extends Literal = Literal, Error extends TypeError = TypeError> {
+    readonly kind: "Member";
+    readonly discriminator: Discriminator;
+    readonly error: Error;
+}
+/**
+ * An error returned by the member selected by {@link discriminatedUnion}.
+ *
+ * @group Discriminated unions
+ */
+export type DiscriminatedUnionMemberError<Issue extends DiscriminatedUnionMemberIssue = DiscriminatedUnionMemberIssue> = [Issue] extends [never] ? never : TypeError<"DiscriminatedUnion"> & {
+    readonly reason: Issue;
+};
+/**
+ * Discriminated union {@link Type}.
+ *
+ * With no explicit key, the conventional `type` property created by
+ * {@link typed} is used. Pass a key first to discriminate
+ * {@link ObjectType | Object Types} using a different property.
+ *
+ * Every member must be an Object Type with a unique required string, number,
+ * bigint, or boolean {@link LiteralType} at the discriminator key. Unlike
+ * {@link union}, only the selected member is decoded, checked, or encoded. The
+ * Discriminated Union Input therefore narrows each member's discriminator from
+ * its widened Input to the exact literal that selects that member. Use
+ * `fromUnknown` when a value does not yet have that correlated Input type.
+ *
+ * ### Example
+ *
+ * ```ts
+ * 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);
+ *
+ * assertOk(Event.fromUnknown({ type: "Created", id: "id" }), {
+ *   type: "Created",
+ *   id: "id",
+ * });
+ * ```
+ *
+ * @group Discriminated unions
+ */
+export declare function discriminatedUnion<const Members extends DiscriminatedUnionMembers>(...members: Members & DiscriminatedUnionValidation<"type", Members>): DiscriminatedUnionType<"type", Members>;
 /**
- * An error returned by the member selected by {@link discriminatedUnion}.
+ * Creates a Discriminated Union Type with an explicit discriminator key.
  *
- * @group Discriminated unions
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertOk,
+ *   Number,
+ *   String,
+ *   discriminatedUnion,
+ *   literal,
+ *   object,
+ * } from "@evolu/common";
+ *
+ * const Added = object({ kind: literal("added"), value: String });
+ * const Removed = object({ kind: literal("removed"), id: Number });
+ * const Event = discriminatedUnion("kind", Added, Removed);
+ *
+ * assertOk(Event.fromUnknown({ kind: "added", value: "Evolu" }), {
+ *   kind: "added",
+ *   value: "Evolu",
+ * });
+ * assertOk(Event.fromUnknown({ kind: "removed", id: 1 }), {
+ *   kind: "removed",
+ *   id: 1,
+ * });
+ * ```
  */
-export type DiscriminatedUnionMemberError<Issue extends DiscriminatedUnionMemberIssue = DiscriminatedUnionMemberIssue> = [Issue] extends [never] ? never : TypeError<"DiscriminatedUnion"> & {
-    readonly reason: Issue;
-};
+export declare function discriminatedUnion<const Key extends string, const Members extends DiscriminatedUnionMembers>(key: ValidateDiscriminatedUnionKey<Key>, ...members: Members & DiscriminatedUnionValidation<Key, Members>): DiscriminatedUnionType<Key, Members>;
 type DiscriminatedUnionObjectType = ObjectTypeNode & ConcreteTypeNode;
 type DiscriminatedUnionMembers = AtLeastTwoReadonlyArray<DiscriminatedUnionObjectType>;
 type DiscriminatedUnionLiteral = string | number | bigint | boolean;
@@ -6917,6 +7062,28 @@ type DiscriminatedUnionMembersTupleError = CompileTimeError<"Type", "Members mus
 type DiscriminatedUnionMemberConcreteTypeError = CompileTimeError<"Type", "Member must use one concrete Object Type node.">;
 type DiscriminatedUnionPropertyError<Key extends string> = CompileTimeError<"Type", `Property "${Key}" must be a required String, Number, BigInt, or Boolean Literal Type in every member.`>;
 type DiscriminatedUnionDuplicateValueError<Key extends string, Expected extends DiscriminatedUnionLiteral> = CompileTimeError<"Type", `Duplicate value "${Expected}" at property "${Key}".`>;
+/**
+ * A deferred {@link Type} with an explicit recursive type declaration.
+ *
+ * A Lazy Type exposes one terminal input parent before its definition is
+ * evaluated. Its `from` operation accepts its Output, while `from.parent`
+ * performs the complete conversion from Input to Output. The resolved Type's
+ * intermediate parent suffixes and constructor-specific reflection are
+ * intentionally not exposed.
+ *
+ * `FromError` describes `from.parent` failures, `InputError` describes the
+ * synthetic parent's unknown-input failures, and `Errors` describes the
+ * complete `fromUnknown` failures. Keeping those channels explicit makes a
+ * recursive declaration finite for TypeScript while preserving structured
+ * errors at every boundary.
+ *
+ * @group Recursive
+ */
+export interface LazyType<in out Input, in out Output, in out FromError extends TypeError, in out InputError extends TypeError, in out Errors extends TypeError, in out CanonicalInput extends Input = Input, in out UsesIdentityEncoding extends boolean = true> extends Type<"Lazy", Input, Output, FromError, 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>;
+}
 /**
  * Creates a lazy {@link Type} for recursive definitions.
  *
@@ -6983,30 +7150,15 @@ type DiscriminatedUnionDuplicateValueError<Key extends string, Expected extends
  * @group Recursive
  */
 export declare function lazy<Target extends ConcreteTypeNode>(getType: Thunk<ValidateLazyTarget<Target>>): LazyType<Target["Input"], Target["Output"], TypeFromError<Target>, InferErrors<RootType<Target>>, InferErrors<Target>, CanonicalInputOf<Target>, IdentityEncodingOf<Target>>;
+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.">;
 /**
- * A deferred {@link Type} with an explicit recursive type declaration.
- *
- * A Lazy Type exposes one terminal input parent before its definition is
- * evaluated. Its `from` operation accepts its Output, while `from.parent`
- * performs the complete conversion from Input to Output. The resolved Type's
- * intermediate parent suffixes and constructor-specific reflection are
- * intentionally not exposed.
- *
- * `FromError` describes `from.parent` failures, `InputError` describes the
- * synthetic parent's unknown-input failures, and `Errors` describes the
- * complete `fromUnknown` failures. Keeping those channels explicit makes a
- * recursive declaration finite for TypeScript while preserving structured
- * errors at every boundary.
+ * The root {@link Type} for Evolu {@link Data}.
  *
- * @group Recursive
+ * @group Base
  */
-export interface LazyType<in out Input, in out Output, in out FromError extends TypeError, in out InputError extends TypeError, in out Errors extends TypeError, in out CanonicalInput extends Input = Input, in out UsesIdentityEncoding extends boolean = true> extends Type<"Lazy", Input, Output, FromError, 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>;
+export interface DataType extends Type<"Data", Data, Data, DataError, null, DataError, never, Data> {
 }
-type ValidateLazyTarget<Target extends ConcreteTypeNode> = IsUnion<Target> extends false ? Target : LazyTargetConcreteTypeError;
-type LazyTargetConcreteTypeError = CompileTimeError<"Type", "Lazy Type definition must return one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
 /**
  * Evolu's recursive platform-independent structured-cloneable data domain.
  *
@@ -7052,46 +7204,17 @@ export type Data = undefined | null | string | number | bigint | boolean | Reado
     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<IsData<User>, true>();
- * assertType<IsData<Service>, false>();
- * ```
+ * An error containing one or more issues found while validating a candidate as
+ * {@link Data}.
  *
  * @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;
+export interface DataError extends TypeError<"Data"> {
+    readonly reason: {
+        readonly kind: "Issues";
+        readonly issues: NonEmptyReadonlyArray<DataIssue>;
+    };
+}
 /**
  * One issue found while validating a candidate as {@link Data}.
  *
@@ -7127,25 +7250,6 @@ export type DataIssue = {
     readonly path: ReadonlyArray<PropertyKey>;
     readonly container: "Array" | "Set" | "Map";
 };
-/**
- * An error containing one or more issues found while validating a candidate as
- * {@link Data}.
- *
- * @group Base
- */
-export interface DataError extends TypeError<"Data"> {
-    readonly reason: {
-        readonly kind: "Issues";
-        readonly issues: NonEmptyReadonlyArray<DataIssue>;
-    };
-}
-/**
- * The root {@link Type} for Evolu {@link Data}.
- *
- * @group Base
- */
-export interface DataType extends Type<"Data", Data, Data, DataError, null, DataError, never, Data> {
-}
 /**
  * Root Type for {@link Data} values.
  *
@@ -7167,6 +7271,54 @@ export interface DataType extends Type<"Data", Data, Data, DataError, null, Data
  * @group Base
  */
 export declare const Data: DataType;
+/**
+ * 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<IsData<User>, true>();
+ * assertType<IsData<Service>, false>();
+ * ```
+ *
+ * @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;
+/**
+ * The exact root {@link Type} of in-memory JSON data values.
+ *
+ * @group JSON
+ */
+export interface JsonValueType extends Type<"JsonValue", JsonValue, JsonValue, JsonValueError, null, JsonValueError, never, JsonValue> {
+}
 /**
  * A candidate JSON value before exact runtime validation.
  *
@@ -7213,6 +7365,18 @@ export type JsonArray = ReadonlyArray<JsonValue>;
 export interface JsonObject {
     readonly [key: string]: JsonValue;
 }
+/**
+ * An error containing one or more issues found while validating a candidate as
+ * an exact {@link JsonValue}.
+ *
+ * @group JSON
+ */
+export interface JsonValueError extends TypeError<"JsonValue"> {
+    readonly reason: {
+        readonly kind: "Issues";
+        readonly issues: NonEmptyReadonlyArray<JsonValueIssue>;
+    };
+}
 /**
  * One issue found while validating a candidate as an exact {@link JsonValue}.
  *
@@ -7251,35 +7415,6 @@ export type JsonValueIssue = {
     readonly path: ReadonlyArray<string | number | symbol>;
     readonly ancestorPath: ReadonlyArray<string | number | symbol>;
 };
-/**
- * An error containing one or more issues found while validating a candidate as
- * an exact {@link JsonValue}.
- *
- * @group JSON
- */
-export interface JsonValueError extends TypeError<"JsonValue"> {
-    readonly reason: {
-        readonly kind: "Issues";
-        readonly issues: NonEmptyReadonlyArray<JsonValueIssue>;
-    };
-}
-/**
- * The exact root {@link Type} of in-memory JSON data values.
- *
- * @group JSON
- */
-export interface JsonValueType extends Type<"JsonValue", JsonValue, JsonValue, JsonValueError, null, JsonValueError, never, JsonValue> {
-}
-/**
- * The exact top-level JSON object {@link Type}.
- *
- * @group JSON
- */
-export interface JsonObjectType extends Type<"Record", JsonObject, JsonObject, RecordError<TypeOfError<"String">, JsonValueError, never>, null, RecordError<TypeOfError<"String">, JsonValueError, never>, never, JsonObject> {
-    readonly [reflectedTypesSymbol]?: typeof String | JsonValueType;
-    readonly key: typeof String;
-    readonly value: JsonValueType;
-}
 /**
  * An error returned when a string does not contain valid JSON text.
  *
@@ -7320,6 +7455,16 @@ export declare const JsonValue: JsonValueType;
  * @group JSON
  */
 export declare const JsonArray: ArrayType<JsonValueType>;
+/**
+ * The exact top-level JSON object {@link Type}.
+ *
+ * @group JSON
+ */
+export interface JsonObjectType extends Type<"Record", JsonObject, JsonObject, RecordError<TypeOfError<"String">, JsonValueError, never>, null, RecordError<TypeOfError<"String">, JsonValueError, never>, never, JsonObject> {
+    readonly [reflectedTypesSymbol]?: typeof String | JsonValueType;
+    readonly key: typeof String;
+    readonly value: JsonValueType;
+}
 /**
  * Exact top-level JSON object {@link Type}.
  *