@evolu/common 8.9.0 → 8.10.0

package/dist/src/Type.d.ts

@@ -236,15 +236,22 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      */
     readonly to: [Parent] extends [infer P extends TypeNode] ? ToOperation<Output, CanonicalInput, P> : (value: Output) => CanonicalInput;
     /**
-     * Shorthand for calling {@link getOrThrow} with the result of the deepest
-     * `from` operation, which accepts this Type's `Input`.
+     * Runs the deepest `from` operation, which accepts this Type's `Input`, and
+     * returns its decoded value or throws an Error.
+     *
+     * Returned validation errors use this Type's {@link Type.formatError} as the
+     * Error message and preserve the original validation error as `cause`. With
+     * `{ errors: "all" }`, the cause retains all collected errors; the message
+     * still follows `formatError`, which describes the first issue.
      *
      * The typed `Input` boundary is asserted before the remaining pipeline runs.
-     * A boundary violation is a bug, so it throws directly; `getOrThrow` maps
-     * only a validation error returned after that boundary.
+     * A boundary violation is a bug, so it throws directly with its assertion
+     * message instead of formatting a returned validation error.
      *
      * `Type.orThrow.parent(value)` does not exist. To throw after starting from a
-     * typed boundary, call `getOrThrow` with the corresponding `from` operation.
+     * typed boundary, call {@link getOrThrow} with the corresponding `from`
+     * operation. Its generic Error message differs from this operation's
+     * message.
      *
      * Use `orThrow` for startup and configuration, module constants, test
      * fixtures, and internal invariants where failure must stop the current flow.
@@ -256,20 +263,31 @@ export interface Type<Name extends TypeName, in out Input, in out Output, Error
      * ```ts
      * import {
      *   assertEqual,
-     *   getOrThrow,
+     *   assertInstanceOf,
+     *   assertErr,
      *   minLength,
      *   String,
+     *   trySync,
      * } from "@evolu/common";
      *
      * const NonEmptyString = minLength(1)(String);
      *
      * const value = NonEmptyString.orThrow("Evolu");
      *
-     * // Equivalent because `from.parent` is this Type's deepest `from` operation:
-     * const sameValue = getOrThrow(NonEmptyString.from.parent("Evolu"));
-     *
      * assertEqual(value, "Evolu");
-     * assertEqual(sameValue, value);
+     *
+     * const failed = trySync(() => NonEmptyString.orThrow(""));
+     * assertErr(failed);
+     * assertInstanceOf(failed.error, Error);
+     * assertEqual(
+     *   failed.error.message,
+     *   'The value "" does not meet the minimum length of 1.',
+     * );
+     * assertEqual(failed.error.cause, {
+     *   type: "MinLength1",
+     *   value: "",
+     *   min: 1,
+     * });
      * ```
      */
     readonly orThrow: TypeOperationFn<"orThrow", Input, Output, never>;
@@ -355,6 +373,50 @@ export interface TypeValueError<Name extends TypeName = TypeName> extends TypeEr
  * @group Core
  */
 export type TypeErrorFormatter<Error extends TypeError> = (error: Error) => string;
+/**
+ * A formatted validation issue located by its path from the root value.
+ *
+ * @group Core
+ */
+export interface TypeIssue {
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly message: string;
+}
+/**
+ * Converts an error from a {@link Type} into formatted issues with paths.
+ *
+ * Pass the Type that produced the error. This uses its nested and localized
+ * formatters without validating the input again. To retain every issue, decode
+ * with `{ errors: "all" }`; this function cannot recover errors omitted during
+ * validation. A root issue has an empty path.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   IntFromString,
+ *   object,
+ *   typeErrorToIssues,
+ * } from "@evolu/common";
+ *
+ * const Settings = object({ port: IntFromString });
+ *
+ * const result = Settings.fromUnknown({ port: "http" }, { errors: "all" });
+ * assertErr(result);
+ *
+ * assertEqual(typeErrorToIssues(Settings, result.error), [
+ *   {
+ *     path: ["port"],
+ *     message: 'The value "http" is not a decimal integer.',
+ *   },
+ * ]);
+ * ```
+ *
+ * @group Core
+ */
+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.
@@ -379,6 +441,21 @@ export interface TypeNode {
     readonly fromUnknown: (value: unknown, options?: ValidationOptions) => Result<unknown, TypeError>;
     readonly is: (value: unknown) => boolean;
 }
+declare const outputValidationSymbolType: unique symbol;
+declare const getRuntimeTypeIssuesSymbolType: unique symbol;
+type RuntimeOutputValidation = (value: unknown, options?: ValidationOptions) => Result<unknown, TypeError>;
+interface RuntimeTypeIssue {
+    readonly name: TypeName;
+    readonly error: TypeError;
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly formatError: TypeErrorFormatter<TypeError>;
+    readonly alternatives?: ReadonlyArray<{
+        readonly index: number;
+        readonly name: TypeName;
+        readonly issues: NonEmptyReadonlyArray<RuntimeTypeIssue>;
+    }>;
+}
+type RuntimeGetTypeIssues = (error: TypeError, mode: ValidationOptions["errors"]) => NonEmptyReadonlyArray<RuntimeTypeIssue>;
 /**
  * Asserts type equality or validates a value with a {@link Type}.
  *
@@ -435,6 +512,11 @@ export declare function assertType<T extends TypeNode>(type: T, value: unknown):
  * that produced them. Different localized Type sets can coexist in separate
  * application or dependency-injection scopes.
  *
+ * A Union formatter supplies the summary of the failure. Retained member
+ * failures are appended using their own localized formatters, with member
+ * indexes, Type names, and paths identifying each alternative. The Union still
+ * produces one issue at its enclosing path.
+ *
  * Localization is scoped to the selected Types instead of a package-wide
  * translation registry. Static imports give bundlers an explicit dependency
  * graph, so unrelated Types, locales, and formatters can be removed. Bundling
@@ -655,7 +737,7 @@ type ReflectedTypes<T extends TypeNode> = typeof reflectedTypesSymbol extends ke
     readonly name: "Object";
     readonly props: infer Props extends ObjectProps;
     readonly record?: infer Rest;
-} ? ObjectPropertyType<Props[keyof Props]> | Extract<Rest, TypeNode> : never;
+} ? DefaultableObjectPropertyType<Props[keyof Props]> | Extract<Rest, TypeNode> : never;
 type RootType<T extends TypeNode> = T extends {
     readonly parent: infer Parent extends TypeNode;
 } ? RootType<Parent> : T;
@@ -716,7 +798,42 @@ interface ValidationFailure<Error> {
     readonly [validationFailureSymbol]: Error;
 }
 type ValidateParent<T extends ConcreteTypeNode> = IsUnion<T> extends false ? T : CompileTimeError<"Type", "Parent must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
-type ValidateOutput<T extends ConcreteTypeNode> = IsUnion<T> extends false ? T : CompileTimeError<"Type", "Output Type must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
+/**
+ * Requires one concrete output {@link Type} node in a factory parameter.
+ *
+ * Rejects TypeScript unions of Type nodes. A {@link union} Type is one concrete
+ * node and remains valid. Use an intersection with the inferred parameter type
+ * to preserve its specific Type. This guard performs no runtime validation.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertSame,
+ *   Number,
+ *   String,
+ *   union,
+ *   type AnyType,
+ *   type ValidateOutput,
+ * } from "@evolu/common";
+ *
+ * const defineOutput = <T extends AnyType>(
+ *   type: T & ValidateOutput<T>,
+ * ): T => type;
+ *
+ * assertSame(defineOutput(String), String);
+ *
+ * const Value = union(String, Number);
+ * assertSame(defineOutput(Value), Value);
+ *
+ * const uncertain = String as typeof String | typeof Number;
+ * // @ts-expect-error Output Type must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
+ * defineOutput(uncertain);
+ * ```
+ *
+ * @group Construction
+ */
+export type ValidateOutput<T extends AnyType> = IsUnion<T> extends false ? T : CompileTimeError<"Type", "Output Type must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.">;
 type ValidateConcreteTypeName<Name extends TypeName> = IsTypeNameUnion<Name> extends false ? {} extends Readonly<Record<Name, never>> ? ConcreteChildTypeNameError : Name : ConcreteChildTypeNameError;
 type ValidateChildTypeName<Name extends TypeName, ParentType extends TypeNode> = [ChildTypeNameValidationError<Name, ParentType>] extends [never] ? Name : ChildTypeNameValidationError<Name, ParentType>;
 type ChildTypeNameValidationError<Name extends TypeName, ParentType extends TypeNode> = IsTypeNameUnion<Name> extends true ? ConcreteChildTypeNameError : {} extends Readonly<Record<Name, never>> ? ConcreteChildTypeNameError : Name extends InferErrors<ParentType>["type"] ? ChildTypeNameCollisionError : never;
@@ -748,6 +865,8 @@ type ConcreteChildTypeNameError = CompileTimeError<"Type", "Name must be one con
  * its error's `type` must equal that name and must not duplicate an inherited
  * error type. An infallible child has no own error to format.
  *
+ * Use {@link createTypeWithError} to wrap an existing validator's errors.
+ *
  * ### Example
  *
  * A root Type for a custom external value category:
@@ -778,6 +897,7 @@ type ConcreteChildTypeNameError = CompileTimeError<"Type", "Name must be one con
  * );
  *
  * assertOk(Text.fromUnknown("Evolu"), "Evolu");
+ *
  * const invalid = Text.fromUnknown(42);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -791,6 +911,48 @@ export declare function createType<Name extends TypeName, Output, Error extends
 export declare function createType<Name extends TypeName, ParentType extends ConcreteTypeNode>(name: ValidateConcreteTypeName<Name>, parent: ValidateParent<ParentType>, fromParent: (value: ParentType["Output"]) => Result<ParentType["Output"], never>): Type<Name, ParentType["Input"], ParentType["Output"], never, ParentType, InferErrors<ParentType>, ChildCustomFrom<ParentType, ParentType["Output"], never>, CanonicalInputForChild<ParentType, ParentType["Output"]>, IdentityEncodingOf<ParentType>>;
 /** Creates a fallible child Type that narrows its parent's Output. */
 export declare function createType<Name extends TypeName, ParentType extends ConcreteTypeNode, Output extends ParentType["Output"], Error extends TypeError<Name>>(name: Name, parent: ValidateBrandParent<Name, ParentType>, fromParent: (value: ParentType["Output"]) => Result<Output, Error>, formatError: [Error] extends [never] ? never : TypeErrorFormatter<NoInfer<Error>>): Type<Name, ParentType["Input"], Output, Error, ParentType, Error | InferErrors<ParentType>, ChildCustomFrom<ParentType, Output, Error>, CanonicalInputForChild<ParentType, Output>, IdentityEncodingOf<ParentType>>;
+/**
+ * Creates a root {@link Type} with a custom error for an existing validator.
+ *
+ * The source must use identity encoding. The new Type accepts its Output as
+ * Input and hides its parent boundaries. Validation and error collection are
+ * delegated automatically; the mapper receives the failure and original value.
+ * The formatter presents the mapped error as one issue.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   createTypeWithError,
+ *   Number,
+ *   String,
+ *   union,
+ *   type TypeError,
+ *   type UnionError,
+ * } from "@evolu/common";
+ *
+ * interface ValueError extends TypeError<"Value"> {
+ *   readonly cause: UnionError;
+ * }
+ *
+ * const Value = createTypeWithError(
+ *   "Value",
+ *   union(String, Number),
+ *   (cause): ValueError => ({ type: "Value", cause }),
+ *   () => "Enter text or a number.",
+ * );
+ *
+ * const result = Value.fromUnknown(false, { errors: "all" });
+ * assertErr(result);
+ * assertEqual(result.error.cause.errors.length, 2);
+ * assertEqual(Value.formatError(result.error), "Enter text or a number.");
+ * ```
+ *
+ * @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>;
 /**
  * Transform {@link Type}.
  *
@@ -943,8 +1105,33 @@ type DeepestFromError<Operation> = DeepestFromOperation<Operation> extends (...a
     readonly error: infer Error extends TypeError;
 } ? Error : never : never;
 type TypeFromError<T extends TypeNode> = unknown extends T[typeof customFromSymbol] ? DeepestFromError<TypeFromOperation<T>> : [T[typeof customFromSymbol]] extends [never] ? NonRootErrors<T> : DeepestFromError<T[typeof customFromSymbol]>;
+type RuntimeOperationFn<Value> = (value: never, options?: ValidationOptions) => Value;
+type RuntimeOperation<Value> = RuntimeOperationFn<Value> & {
+    parent?: RuntimeOperation<Value>;
+};
+type RuntimeEncoder = RuntimeOperation<unknown>;
+declare const encoderSymbolType: unique symbol;
+declare const fromSymbolType: unique symbol;
 declare const templateLiteralSyntaxSymbolType: unique symbol;
 declare const templateLiteralSyntaxSymbol: typeof templateLiteralSyntaxSymbolType;
+/**
+ * Type-erased {@link Type} used to traverse and invoke heterogeneous Type nodes
+ * at runtime.
+ */
+type RuntimeTypeNode = Omit<TypeNode, typeof customFromSymbol> & {
+    readonly [customFromSymbol]: never;
+    readonly fromUnknown: (value: unknown, options: ValidationOptions) => Result<unknown, TypeError>;
+    readonly formatError: TypeErrorFormatter<TypeError>;
+    readonly from: RuntimeOperation<Result<unknown, TypeError>>;
+    readonly to: RuntimeEncoder;
+    readonly orThrow: RuntimeOperation<unknown>;
+    readonly orNull: RuntimeOperation<unknown>;
+    readonly [outputValidationSymbolType]: RuntimeOutputValidation;
+    readonly [fromSymbolType]: RuntimeOperation<Result<unknown, TypeError>>;
+    readonly [encoderSymbolType]: RuntimeEncoder;
+    readonly [getRuntimeTypeIssuesSymbolType]: RuntimeGetTypeIssues;
+    readonly [templateLiteralSyntaxSymbolType]?: true;
+};
 /**
  * An infallible {@link Type} accepting every value.
  *
@@ -1082,6 +1269,7 @@ export declare const String: Type<"String", string, string, TypeOfError<"String"
  * >();
  *
  * assertOk(Age.fromUnknown(122), 122);
+ *
  * const invalid = Age.fromUnknown(200);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -1107,6 +1295,47 @@ export declare const BigInt: Type<"BigInt", bigint, bigint, TypeOfError<"BigInt"
  * @group Base
  */
 export declare const Boolean: Type<"Boolean", boolean, boolean, TypeOfError<"Boolean">, null, TypeOfError<"Boolean">, never, boolean, true>;
+/**
+ * Error returned when a string is neither `true` nor `false`.
+ *
+ * @group Base
+ */
+export interface BooleanFromStringError extends TypeError<"BooleanFromString"> {
+    readonly value: string;
+}
+/**
+ * Transforms a boolean spelled as text into a {@link Boolean}.
+ *
+ * This is useful for inputs that carry booleans as text, such as environment
+ * variables, URL query parameters, and form fields. Exactly `true` and `false`
+ * are accepted, the spellings JSON and JavaScript use, so a boolean has one
+ * representation in every source.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   BooleanFromString,
+ * } from "@evolu/common";
+ *
+ * assertOk(BooleanFromString.fromUnknown("true"), true);
+ * assertOk(BooleanFromString.fromUnknown("false"), false);
+ * assertEqual(BooleanFromString.to(true), "true");
+ *
+ * const invalid = BooleanFromString.fromUnknown("yes");
+ * assertErr(invalid, { type: "BooleanFromString", value: "yes" });
+ * assertEqual(
+ *   BooleanFromString.formatError(invalid.error),
+ *   'The value "yes" is not a boolean. Use true or false.',
+ * );
+ * ```
+ *
+ * @group Base
+ */
+export declare const BooleanFromString: TransformType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, Type<"Boolean", boolean, boolean, TypeOfError<"Boolean">, null, TypeOfError<"Boolean">, never, boolean, true>, "BooleanFromString", BooleanFromStringError, "false" | "true">;
 /**
  * A JavaScript symbol {@link Type}.
  *
@@ -1236,6 +1465,7 @@ export declare function objectTag<Name extends keyof ObjectTagOutputByName>(name
  *   "TaggedValue",
  *   instanceOf(TaggedValue),
  * );
+ *
  * const value = new TaggedValue();
  * const result = TaggedValueType.fromUnknown(value);
  *
@@ -1338,6 +1568,34 @@ export interface InstanceOfError extends TypeValueError<"InstanceOf"> {
 }
 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.">;
+/**
+ * Requires one concrete literal type in a factory parameter.
+ *
+ * Preserves an exact literal and produces a compile-time error for widened,
+ * union, branded, or open template literal types. Use an intersection with the
+ * inferred parameter type, as {@link prefixed} does. This guard performs no
+ * runtime validation.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertType, type ValidateLiteral } from "@evolu/common";
+ *
+ * const definePrefix = <Prefix extends string>(
+ *   prefix: Prefix & ValidateLiteral<Prefix>,
+ * ): Prefix => prefix;
+ *
+ * const prefix = definePrefix("APP_");
+ * assertType<typeof prefix, "APP_">();
+ *
+ * const widened: string = "APP_";
+ * // @ts-expect-error Expected must be one concrete literal value.
+ * definePrefix(widened);
+ * ```
+ *
+ * @group Unions
+ */
+export type ValidateLiteral<Expected extends Literal> = IsUnion<Expected> extends false ? {} extends Readonly<Record<`${Expected}`, never>> ? LiteralCompileTimeError : Expected : LiteralCompileTimeError;
 /**
  * Literal {@link Type}.
  *
@@ -1366,6 +1624,7 @@ type InstanceConstructorCompileTimeError = CompileTimeError<"Type", "Constructor
  *
  * assertType<typeof Ready.Output, "ready">();
  * assertOk(Ready.fromUnknown("ready"), "ready");
+ *
  * const invalid = Ready.fromUnknown("pending");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -1390,7 +1649,6 @@ export interface LiteralType<Expected extends Literal> extends Type<"Literal", W
 }
 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 ValidateLiteral<Expected extends Literal> = IsUnion<Expected> extends false ? {} extends Readonly<Record<`${Expected}`, never>> ? LiteralCompileTimeError : Expected : LiteralCompileTimeError;
 type LiteralCompileTimeError = CompileTimeError<"Type", "Expected must be one concrete literal value.">;
 /**
  * Error returned when a value does not equal the expected literal.
@@ -1435,6 +1693,11 @@ export declare const Null: LiteralType<null>;
  * errors: "all" }` to retain every member failure and collect nested errors
  * within each member.
  *
+ * Formatting keeps one Union issue at the enclosing path and appends the
+ * retained failures below its summary. Member indexes identify alternatives,
+ * not positions in the input. Nested member paths appear in the message.
+ * Formatting never retries validation or recovers discarded failures.
+ *
  * Member order matters when multiple members accept the same value: validation
  * and encoding use the first matching member. When member Inputs overlap,
  * decoding the value emitted by the first member selected for an Output must
@@ -1683,6 +1946,7 @@ interface UnionErrorValue<Error extends TypeError, MemberError extends UnionMemb
  * assertOk(result, ["cs", "CZ"]);
  * const locale = result.value;
  * assertType<typeof locale, SupportedLocale>();
+ *
  * const invalid = SupportedLocale.fromUnknown("cs/CZ");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -1960,6 +2224,7 @@ type TemplateLiteralStringWidth<Value extends string, Width extends ReadonlyArra
  * }
  *
  * assertOk(Int64.fromUnknown(42n), 42n);
+ *
  * const invalid = Int64.fromUnknown(2n ** 63n);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -2009,6 +2274,7 @@ export interface BrandType<ParentType extends TypeNode, Name extends TypeName, E
  *
  * const value = "2023-01-01T12:00:00.000Z";
  * assertOk(DateIso.fromUnknown(value), value);
+ *
  * const invalid = DateIso.fromUnknown("2023-01-01");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -2135,6 +2401,7 @@ export interface UInt64Error extends TypeError<"UInt64"> {
  * }
  *
  * assertOk(TrimmedString.fromUnknown("Evolu"), "Evolu");
+ *
  * const invalid = TrimmedString.fromUnknown(" Evolu");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -2216,57 +2483,643 @@ export type BrandFactory<Name extends TypeName, Value, Error extends TypeError<N
 export type ValidateBrandFactoryNumber<Value extends number> = IsUnion<Value> extends false ? {} extends Record<`${Value}`, never> ? Value & Readonly<Record<BrandFactoryNumberError, never>> : Value : Value & Readonly<Record<BrandFactoryNumberError, never>>;
 type BrandFactoryNumberError = CompileTimeError<"Brand Factory", "Parameter must be one concrete numeric literal instead of a widened, union, or branded number.">;
 /**
- * Capitalized {@link Brand}.
+ * Naming conventions accepted by {@link identifier}.
  *
- * Requires the first character of a string to be uppercase.
+ * @group String
+ */
+export type IdentifierCasing = "camelCase" | "PascalCase" | "snake_case" | "kebab-case" | "CONSTANT_CASE";
+/**
+ * Brand names of the Types that {@link identifier} creates, by casing.
+ *
+ * @group String
+ */
+export interface IdentifierBrandByCasing {
+    readonly camelCase: "CamelCaseIdentifier";
+    readonly PascalCase: "PascalCaseIdentifier";
+    readonly snake_case: "SnakeCaseIdentifier";
+    readonly "kebab-case": "KebabCaseIdentifier";
+    readonly CONSTANT_CASE: "ConstantCaseIdentifier";
+}
+/**
+ * Adds identifier validation in a naming convention to an existing string Type.
+ *
+ * An identifier is one or more ASCII words, each starting with a letter and
+ * continuing with letters or digits. camelCase and PascalCase start every word
+ * after the first with an uppercase letter, so `httpUrl` has two words and
+ * `httpURL` has four. snake_case, kebab-case, and CONSTANT_CASE put exactly one
+ * separator between words. Validation keeps the spelling and rejects empty
+ * strings, whitespace, punctuation, and non-ASCII characters.
+ *
+ * Words never start with a digit. Identifier grammars in most languages forbid
+ * a leading digit, and camelCase cannot mark a word boundary before one, so the
+ * rule applies to every word and keeps every conversion exact. Join an
+ * abbreviation such as `2FA` to the previous word, as in `MAX2FA_ATTEMPTS` and
+ * `max2faAttempts`, or spell the number out, as in `TWO_FACTOR_SECRET`.
+ *
+ * Convert validated identifiers with functions such as
+ * {@link camelCaseToSnakeCase}. Conversions preserve word boundaries, and
+ * converting back restores the original spelling. They return only the
+ * destination brand, dropping unrelated constraints such as input length.
  *
  * ### Example
  *
  * ```ts
  * import {
- *   assertEqual,
  *   assertErr,
  *   assertOk,
- *   assertType,
- *   Data,
+ *   identifier,
+ *   maxLength,
  *   String,
+ * } from "@evolu/common";
+ *
+ * const EnvName = identifier("CONSTANT_CASE")(maxLength(16)(String));
+ *
+ * assertOk(EnvName.fromUnknown("HTTP2_PORT"), "HTTP2_PORT");
+ * assertErr(EnvName.fromUnknown("HTTP_2_PORT"));
+ * ```
+ *
+ * @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`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export declare const CamelCaseIdentifier: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "CamelCaseIdentifier", IdentifierError<"camelCase">>;
+export type CamelCaseIdentifier = typeof CamelCaseIdentifier.Output;
+/**
+ * A validated PascalCase identifier, such as `Http2Port`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export declare const PascalCaseIdentifier: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "PascalCaseIdentifier", IdentifierError<"PascalCase">>;
+export type PascalCaseIdentifier = typeof PascalCaseIdentifier.Output;
+/**
+ * A validated snake_case identifier, such as `http2_port`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export declare const SnakeCaseIdentifier: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "SnakeCaseIdentifier", IdentifierError<"snake_case">>;
+export type SnakeCaseIdentifier = typeof SnakeCaseIdentifier.Output;
+/**
+ * A validated kebab-case identifier, such as `http2-port`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export declare const KebabCaseIdentifier: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "KebabCaseIdentifier", IdentifierError<"kebab-case">>;
+export type KebabCaseIdentifier = typeof KebabCaseIdentifier.Output;
+/**
+ * A validated CONSTANT_CASE identifier, such as `HTTP2_PORT`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export declare const ConstantCaseIdentifier: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "ConstantCaseIdentifier", IdentifierError<"CONSTANT_CASE">>;
+export type ConstantCaseIdentifier = typeof ConstantCaseIdentifier.Output;
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `http2Port` to `Http2Port`. Use {@link pascalCaseToCamelCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const camelCaseToPascalCase: (value: CamelCaseIdentifier) => PascalCaseIdentifier;
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link SnakeCaseIdentifier}.
+ *
+ * Converts `http2Port` to `http2_port`. Use {@link snakeCaseToCamelCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const camelCaseToSnakeCase: (value: CamelCaseIdentifier) => SnakeCaseIdentifier;
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link KebabCaseIdentifier}.
+ *
+ * Converts `http2Port` to `http2-port`. Use {@link kebabCaseToCamelCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const camelCaseToKebabCase: (value: CamelCaseIdentifier) => KebabCaseIdentifier;
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `http2Port` to `HTTP2_PORT`. Use {@link constantCaseToCamelCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const camelCaseToConstantCase: (value: CamelCaseIdentifier) => ConstantCaseIdentifier;
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `http2Port`. Use {@link camelCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const pascalCaseToCamelCase: (value: PascalCaseIdentifier) => CamelCaseIdentifier;
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link SnakeCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `http2_port`. Use {@link snakeCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const pascalCaseToSnakeCase: (value: PascalCaseIdentifier) => SnakeCaseIdentifier;
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link KebabCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `http2-port`. Use {@link kebabCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const pascalCaseToKebabCase: (value: PascalCaseIdentifier) => KebabCaseIdentifier;
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `HTTP2_PORT`. Use {@link constantCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const pascalCaseToConstantCase: (value: PascalCaseIdentifier) => ConstantCaseIdentifier;
+/**
+ * Converts a {@link SnakeCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `http2_port` to `http2Port`. Use {@link camelCaseToSnakeCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const snakeCaseToCamelCase: (value: SnakeCaseIdentifier) => CamelCaseIdentifier;
+/**
+ * Converts a {@link SnakeCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `http2_port` to `Http2Port`. Use {@link pascalCaseToSnakeCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const snakeCaseToPascalCase: (value: SnakeCaseIdentifier) => PascalCaseIdentifier;
+/**
+ * Converts a {@link SnakeCaseIdentifier} to a {@link KebabCaseIdentifier}.
+ *
+ * Converts `http2_port` to `http2-port`. Use {@link kebabCaseToSnakeCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const snakeCaseToKebabCase: (value: SnakeCaseIdentifier) => KebabCaseIdentifier;
+/**
+ * Converts a {@link SnakeCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `http2_port` to `HTTP2_PORT`. Use {@link constantCaseToSnakeCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const snakeCaseToConstantCase: (value: SnakeCaseIdentifier) => ConstantCaseIdentifier;
+/**
+ * Converts a {@link KebabCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `http2-port` to `http2Port`. Use {@link camelCaseToKebabCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const kebabCaseToCamelCase: (value: KebabCaseIdentifier) => CamelCaseIdentifier;
+/**
+ * Converts a {@link KebabCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `http2-port` to `Http2Port`. Use {@link pascalCaseToKebabCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const kebabCaseToPascalCase: (value: KebabCaseIdentifier) => PascalCaseIdentifier;
+/**
+ * Converts a {@link KebabCaseIdentifier} to a {@link SnakeCaseIdentifier}.
+ *
+ * Converts `http2-port` to `http2_port`. Use {@link snakeCaseToKebabCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const kebabCaseToSnakeCase: (value: KebabCaseIdentifier) => SnakeCaseIdentifier;
+/**
+ * Converts a {@link KebabCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `http2-port` to `HTTP2_PORT`. Use {@link constantCaseToKebabCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const kebabCaseToConstantCase: (value: KebabCaseIdentifier) => ConstantCaseIdentifier;
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `http2Port`. Use {@link camelCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const constantCaseToCamelCase: (value: ConstantCaseIdentifier) => CamelCaseIdentifier;
+/**
+ * Decodes a {@link ConstantCaseIdentifier} to a {@link CamelCaseIdentifier} and
+ * restores the original spelling when encoding.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   CamelCaseIdentifierFromConstantCaseIdentifier,
+ * } from "@evolu/common";
+ *
+ * const Key = CamelCaseIdentifierFromConstantCaseIdentifier;
+ * const result = Key.fromUnknown("HTTP2_PORT");
+ * assertOk(result, "http2Port");
+ * assertEqual(Key.to(result.value), "HTTP2_PORT");
+ * ```
+ *
+ * @group String
+ */
+export declare const CamelCaseIdentifierFromConstantCaseIdentifier: TransformType<BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "ConstantCaseIdentifier", IdentifierError<"CONSTANT_CASE">>, BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "CamelCaseIdentifier", IdentifierError<"camelCase">>, "CamelCaseIdentifierFromConstantCaseIdentifier", never, string & Brand<"ConstantCaseIdentifier">>;
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `Http2Port`. Use {@link pascalCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const constantCaseToPascalCase: (value: ConstantCaseIdentifier) => PascalCaseIdentifier;
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link SnakeCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `http2_port`. Use {@link snakeCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const constantCaseToSnakeCase: (value: ConstantCaseIdentifier) => SnakeCaseIdentifier;
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link KebabCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `http2-port`. Use {@link kebabCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export declare const constantCaseToKebabCase: (value: ConstantCaseIdentifier) => KebabCaseIdentifier;
+/**
+ * Adds capitalized text validation to an existing string Type.
+ *
+ * Narrows the output to TypeScript's `Capitalize<string>` while preserving the
+ * parent Type's constraints. Validation leaves the text unchanged. Use
+ * {@link capitalize} to change its casing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertErr,
+ *   assertOk,
  *   capitalized,
- *   type Brand,
+ *   maxLength,
+ *   String,
  * } from "@evolu/common";
  *
- * const CapitalizedString = capitalized(String);
- * type CapitalizedString = typeof CapitalizedString.Output;
+ * const Label = capitalized(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("Hello world"), "Hello world");
+ * assertErr(Label.fromUnknown("hello world"));
+ * ```
  *
- * assertType<CapitalizedString, string & Brand<"Capitalized">>();
+ * @group String
+ */
+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.
  *
- * assertOk(CapitalizedString.fromUnknown("Evolu"), "Evolu");
- * const invalid = CapitalizedString.fromUnknown("evolu");
- * assertErr(invalid);
- * assertType(Data, invalid.error);
- * assertEqual(invalid.error, {
- *   type: "Capitalized",
- *   value: "evolu",
- * });
+ * @group String
+ */
+export interface CapitalizedError extends TypeError<"Capitalized"> {
+    readonly value: string;
+}
+/**
+ * Validates capitalized text as TypeScript's `Capitalize<string>`.
+ *
+ * The rest of the text can use any casing. Empty strings and text starting with
+ * an uncased character, such as a digit or emoji, are valid. Use
+ * {@link capitalize} to produce a capitalized value from any string.
+ *
+ * Capitalization applies to general text, including spaces and punctuation.
+ * Both `hello` and `Hello` become `Hello`, so the original initial casing
+ * cannot be recovered. Capitalization does not identify words or turn text into
+ * an identifier.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, CapitalizedString } from "@evolu/common";
+ *
+ * const text: CapitalizedString = "Hello world";
+ * assertOk(CapitalizedString.fromUnknown(text), text);
+ * assertErr(CapitalizedString.fromUnknown("hello world"));
+ * assertOk(CapitalizedString.fromUnknown(""), "");
+ * ```
+ *
+ * @group String
+ */
+export declare const CapitalizedString: Type<"Capitalized", string, Capitalize<string>, CapitalizedError, Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, CapitalizedError | TypeOfError<"String">, never, Capitalize<string>, true>;
+export type CapitalizedString = typeof CapitalizedString.Output;
+/**
+ * Uppercases the first Unicode code point and returns a
+ * {@link CapitalizedString}.
+ *
+ * Preserves the remainder of the string and leaves an empty string unchanged.
+ * Uses JavaScript's default Unicode casing without locale-specific rules.
+ * Changing case can change the length, so input brands are not retained.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, capitalize } from "@evolu/common";
+ *
+ * const text = capitalize("hello world");
+ * assertEqual(text, "Hello world");
+ * assertType<typeof text, "Hello world">();
+ * assertEqual(capitalize(text), text);
+ * ```
+ *
+ * @group String
+ */
+export declare const capitalize: <S extends string>(value: S) => Capitalize<S>;
+/**
+ * Adds uncapitalized text validation to an existing string Type.
+ *
+ * Narrows the output to TypeScript's `Uncapitalize<string>` while preserving
+ * the parent Type's constraints. Validation leaves the text unchanged. Use
+ * {@link uncapitalize} to change its casing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   uncapitalized,
+ *   maxLength,
+ *   String,
+ * } from "@evolu/common";
+ *
+ * const Label = uncapitalized(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("hello WORLD"), "hello WORLD");
+ * assertErr(Label.fromUnknown("Hello WORLD"));
+ * ```
+ *
+ * @group String
+ */
+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>`.
+ *
+ * The rest of the text can use any casing. Empty strings and text starting with
+ * an uncased character, such as a digit or emoji, are valid. Use
+ * {@link uncapitalize} to produce an uncapitalized value from any string.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, UncapitalizedString } from "@evolu/common";
+ *
+ * const text: UncapitalizedString = "hello WORLD";
+ * assertOk(UncapitalizedString.fromUnknown(text), text);
+ * assertErr(UncapitalizedString.fromUnknown("Hello WORLD"));
+ * assertOk(UncapitalizedString.fromUnknown(""), "");
+ * ```
+ *
+ * @group String
+ */
+export declare const UncapitalizedString: Type<"Uncapitalized", string, Uncapitalize<string>, UncapitalizedError, Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, TypeOfError<"String"> | UncapitalizedError, never, Uncapitalize<string>, true>;
+export type UncapitalizedString = typeof UncapitalizedString.Output;
+/**
+ * Lowercases the first Unicode code point and returns a
+ * {@link UncapitalizedString}.
+ *
+ * Preserves the remainder of the string and leaves an empty string unchanged.
+ * Uses JavaScript's default Unicode casing without locale-specific rules.
+ * Changing case can change the length, so input brands are not retained.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, uncapitalize } from "@evolu/common";
+ *
+ * const text = uncapitalize("Hello WORLD");
+ * assertEqual(text, "hello WORLD");
+ * assertType<typeof text, "hello WORLD">();
+ * assertEqual(uncapitalize(text), text);
+ * ```
+ *
+ * @group String
+ */
+export declare const uncapitalize: <S extends string>(value: S) => Uncapitalize<S>;
+/**
+ * Adds uppercased text validation to an existing string Type.
+ *
+ * Narrows the output to TypeScript's `Uppercase<string>` while preserving the
+ * parent Type's constraints. Validation leaves the text unchanged. Use
+ * {@link uppercase} to change its casing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   uppercased,
+ *   maxLength,
+ *   String,
+ * } from "@evolu/common";
+ *
+ * const Label = uppercased(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("HELLO WORLD"), "HELLO WORLD");
+ * assertErr(Label.fromUnknown("Hello world"));
+ * ```
+ *
+ * @group String
+ */
+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>`.
+ *
+ * Checks the whole string using JavaScript's Unicode uppercase mapping. Empty
+ * strings and uncased characters, such as digits and emoji, are valid. Use
+ * {@link uppercase} to produce an uppercased value from any string.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, UppercasedString } from "@evolu/common";
+ *
+ * const text: UppercasedString = "HELLO WORLD";
+ * assertOk(UppercasedString.fromUnknown(text), text);
+ * assertErr(UppercasedString.fromUnknown("Hello world"));
+ * assertOk(UppercasedString.fromUnknown(""), "");
+ * ```
+ *
+ * @group String
+ */
+export declare const UppercasedString: Type<"Uppercased", string, Uppercase<string>, UppercasedError, Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, TypeOfError<"String"> | UppercasedError, never, Uppercase<string>, true>;
+export type UppercasedString = typeof UppercasedString.Output;
+/**
+ * Uppercases the whole string and returns a {@link UppercasedString}.
+ *
+ * Leaves an empty string unchanged. Uses JavaScript's default Unicode casing
+ * without locale-specific rules. Changing case can change the length, so input
+ * brands are not retained.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, uppercase } from "@evolu/common";
+ *
+ * const text = uppercase("Hello world");
+ * assertEqual(text, "HELLO WORLD");
+ * assertType<typeof text, "HELLO WORLD">();
+ * assertEqual(uppercase(text), text);
+ * ```
+ *
+ * @group String
+ */
+export declare const uppercase: <S extends string>(value: S) => Uppercase<S>;
+/**
+ * Adds lowercased text validation to an existing string Type.
+ *
+ * Narrows the output to TypeScript's `Lowercase<string>` while preserving the
+ * parent Type's constraints. Validation leaves the text unchanged. Use
+ * {@link lowercase} to change its casing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   lowercased,
+ *   maxLength,
+ *   String,
+ * } from "@evolu/common";
+ *
+ * const Label = lowercased(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("hello world"), "hello world");
+ * assertErr(Label.fromUnknown("Hello WORLD"));
  * ```
  *
  * @group String
  */
-export declare const capitalized: BrandFactory<"Capitalized", string, CapitalizedError>;
+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 capitalized} rejects a string.
+ * Error returned when {@link lowercased} rejects a string.
  *
  * @group String
  */
-export interface CapitalizedError extends TypeError<"Capitalized"> {
+export interface LowercasedError extends TypeError<"Lowercased"> {
     readonly value: string;
 }
 /**
- * Capitalized {@link 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
+ * {@link lowercase} to produce a lowercased value from any string.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, LowercasedString } from "@evolu/common";
+ *
+ * const text: LowercasedString = "hello world";
+ * assertOk(LowercasedString.fromUnknown(text), text);
+ * assertErr(LowercasedString.fromUnknown("Hello WORLD"));
+ * assertOk(LowercasedString.fromUnknown(""), "");
+ * ```
  *
  * @group String
  */
-export declare const CapitalizedString: BrandType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, "Capitalized", CapitalizedError>;
-export type CapitalizedString = typeof CapitalizedString.Output;
+export declare const LowercasedString: Type<"Lowercased", string, Lowercase<string>, LowercasedError, Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, LowercasedError | TypeOfError<"String">, never, Lowercase<string>, true>;
+export type LowercasedString = typeof LowercasedString.Output;
+/**
+ * Lowercases the whole string and returns a {@link LowercasedString}.
+ *
+ * Leaves an empty string unchanged. Uses JavaScript's default Unicode casing
+ * without locale-specific rules. Changing case can change the length, so input
+ * brands are not retained.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, lowercase } from "@evolu/common";
+ *
+ * const text = lowercase("Hello WORLD");
+ * assertEqual(text, "hello world");
+ * assertType<typeof text, "hello world">();
+ * assertEqual(lowercase(text), text);
+ * ```
+ *
+ * @group String
+ */
+export declare const lowercase: <S extends string>(value: S) => Lowercase<S>;
 /**
  * String {@link Brand} without surrounding whitespace.
  *
@@ -2318,6 +3171,116 @@ export type TrimmedString = typeof TrimmedString.Output;
  * @group String
  */
 export declare const trim: (value: string) => TrimmedString;
+/**
+ * String {@link Brand} requiring an exact, case-sensitive prefix.
+ *
+ * Validation preserves the complete string, including the prefix. An empty
+ * prefix accepts every string allowed by the parent Type. The prefix must be
+ * one concrete string literal so different prefixes have distinct brands.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   maxLength,
+ *   startsWith,
+ *   String,
+ *   type Brand,
+ * } from "@evolu/common";
+ *
+ * const EnvName = startsWith("APP_")(maxLength(64)(String));
+ *
+ * const name = EnvName.fromUnknown("APP_PORT");
+ * assertOk(name, "APP_PORT");
+ * assertType<
+ *   typeof name.value,
+ *   string & Brand<"MaxLength64"> & Brand<"StartsWithAPP_">
+ * >();
+ *
+ * assertEqual(EnvName.to(name.value), "APP_PORT");
+ *
+ * assertErr(EnvName.fromUnknown("app_PORT"));
+ * assertErr(EnvName.fromUnknown("APP_" + "X".repeat(61)));
+ * ```
+ *
+ * @group String
+ */
+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.
+ *
+ * @group String
+ */
+export interface StartsWithError<Prefix extends string = string> extends TypeError<`StartsWith${Prefix}`> {
+    readonly value: string;
+    readonly prefix: Prefix;
+}
+/**
+ * Decodes a prefixed string with another {@link Type} and restores the prefix
+ * when encoding.
+ *
+ * Uses {@link startsWith} to validate an exact, case-sensitive prefix before
+ * removing one occurrence. The wrapped Type validates and decodes the suffix;
+ * its constraints apply to the suffix, and its Output is preserved. Encoding
+ * prepends the prefix to the wrapped Type's canonical string representation. An
+ * empty prefix leaves that representation unchanged.
+ *
+ * The prefix must be one concrete string literal. The wrapped Type must accept
+ * a string Input and encode to strings; its Output can have another type, as
+ * with {@link PortFromString}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   ConstantCaseIdentifier,
+ *   prefixed,
+ *   PortFromString,
+ *   type Port,
+ * } from "@evolu/common";
+ *
+ * const EnvName = prefixed("APP_")(ConstantCaseIdentifier);
+ *
+ * const name = EnvName.fromUnknown("APP_PORT");
+ * assertOk(name, "PORT");
+ * assertType<typeof name.value, ConstantCaseIdentifier>();
+ *
+ * assertEqual(EnvName.to(name.value), "APP_PORT");
+ *
+ * assertErr(EnvName.fromUnknown("OTHER_PORT"));
+ * assertErr(EnvName.fromUnknown("APP_port"));
+ *
+ * const PortSetting = prefixed("port:")(PortFromString);
+ *
+ * const port = PortSetting.fromUnknown("port:04000");
+ * assertOk(port, 4000);
+ * assertType<typeof port.value, Port>();
+ *
+ * assertEqual(PortSetting.to(port.value), "port:4000");
+ * ```
+ *
+ * @group String
+ */
+export declare const prefixed: <Prefix extends string>(prefix: Prefix & ValidateLiteral<Prefix>) => <T extends ConcreteTypeNode & {
+    readonly Input: string;
+    readonly CanonicalInput: string;
+}>(type: T & ValidateOutput<T> & (string extends T["Input"] ? unknown : PrefixedInputTypeError)) => PrefixedType<Prefix, T>;
+/**
+ * The {@link Type} returned by {@link prefixed}.
+ *
+ * @group String
+ */
+export interface PrefixedType<Prefix extends string, T extends TypeNode> extends TransformType<BrandType<typeof String, `StartsWith${Prefix}`, StartsWithError<Prefix>>, T, `Prefixed${Prefix}`, never> {
+}
+type PrefixedInputTypeError = CompileTimeError<"Type", "Prefixed Type Input must accept every string.">;
 /**
  * Minimum-length {@link Brand} for values whose `length` is at least `min`.
  *
@@ -2460,6 +3423,7 @@ export interface LengthError<Exact extends number = number> extends TypeError<`L
  * assertType<UrlSafeString, string & Brand<"UrlSafeString">>();
  *
  * assertOk(UrlSafeString.fromUnknown("abc-123_DEF"), "abc-123_DEF");
+ *
  * const invalid = UrlSafeString.fromUnknown("not safe");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -2555,7 +3519,13 @@ export declare const uint8ArrayToBase64Url: (bytes: Uint8Array) => Base64Url;
  */
 export declare const base64UrlToUint8Array: (value: Base64Url) => Uint8Array;
 /**
- * A non-empty URL-safe name containing at most 64 UTF-16 code units.
+ * A non-empty file-system-safe and URL-safe token of at most 64 UTF-16 code
+ * units.
+ *
+ * Evolu uses it for database file names, storage pool names, and log prefixes.
+ * It accepts the {@link UrlSafeString} alphabet in any order, so it may start
+ * with a digit, `-`, or `_`. It is not a language identifier; for
+ * word-structured names, use {@link identifier}.
  *
  * @group String
  */
@@ -3093,6 +4063,7 @@ export type PositiveFiniteNumber = typeof PositiveFiniteNumber.Output;
  * assertType<Int, number & Brand<"Int">>();
  *
  * assertOk(Int.fromUnknown(42), 42);
+ *
  * const invalid = Int.fromUnknown(1.5);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -3141,6 +4112,52 @@ export declare const zeroNonNegativeInt: number & Brand<"NonNaN"> & Brand<"Finit
  */
 export declare const PositiveInt: 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>, "Positive", PositiveError>;
 export type PositiveInt = typeof PositiveInt.Output;
+/**
+ * Error returned when a string is not a decimal integer.
+ *
+ * @group Number
+ */
+export interface IntFromStringError extends TypeError<"IntFromString"> {
+    readonly value: string;
+}
+/**
+ * Transforms a decimal integer string into an {@link Int}.
+ *
+ * This is useful for inputs that carry numbers as text, such as environment
+ * variables, URL query parameters, and form fields. The string must consist of
+ * an optional minus sign and digits; the {@link Int} constraint then rejects
+ * values outside the safe integer range.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertSame,
+ *   IntFromString,
+ * } from "@evolu/common";
+ *
+ * assertOk(IntFromString.fromUnknown("4000"), 4000);
+ * assertOk(IntFromString.fromUnknown("-1"), -1);
+ * assertEqual(IntFromString.to(IntFromString.orThrow("42")), "42");
+ *
+ * const negativeZero = IntFromString.orThrow("-0");
+ * assertSame(negativeZero, -0);
+ * assertEqual(IntFromString.to(negativeZero), "-0");
+ *
+ * const invalid = IntFromString.fromUnknown("4000.5");
+ * assertErr(invalid, { type: "IntFromString", value: "4000.5" });
+ * assertEqual(
+ *   IntFromString.formatError(invalid.error),
+ *   'The value "4000.5" is not a decimal integer.',
+ * );
+ * ```
+ *
+ * @group Number
+ */
+export declare const IntFromString: TransformType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "Int", IntError>, "IntFromString", IntFromStringError, string>;
 /**
  * Minimum {@link PositiveInt} value.
  *
@@ -3277,6 +4294,55 @@ export interface LessThanOrEqualToError<Max extends number = number> extends Typ
     readonly value: number;
     readonly max: Max;
 }
+/**
+ * A TCP or UDP port as an integer from zero through 65535, inclusive.
+ *
+ * When binding a server, zero requests an automatically assigned port. Use
+ * {@link PortFromString} for configuration values supplied as text.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, Port } from "@evolu/common";
+ *
+ * assertOk(Port.fromUnknown(0), 0);
+ * assertOk(Port.fromUnknown(4000), 4000);
+ * assertOk(Port.fromUnknown(65535), 65535);
+ * assertErr(Port.fromUnknown(-1));
+ * assertErr(Port.fromUnknown(65536));
+ * assertErr(Port.fromUnknown(4000.5));
+ * ```
+ *
+ * @group Number
+ */
+export declare const Port: 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>, "LessThanOrEqualTo65535", LessThanOrEqualToError<65535>>, "Port", never>;
+export type Port = typeof Port.Output;
+/**
+ * Parses a decimal integer string and validates it as a {@link Port}.
+ *
+ * Uses {@link IntFromString} for decimal parsing, including its rejection of
+ * whitespace, plus signs, fractions, and exponent notation.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   PortFromString,
+ * } from "@evolu/common";
+ *
+ * assertOk(PortFromString.fromUnknown("0"), 0);
+ * assertOk(PortFromString.fromUnknown("4000"), 4000);
+ * assertErr(PortFromString.fromUnknown("65536"));
+ * assertErr(PortFromString.fromUnknown("http"));
+ * assertEqual(PortFromString.to(PortFromString.orThrow("04000")), "4000");
+ * ```
+ *
+ * @group Number
+ */
+export declare const PortFromString: TransformType<TransformType<Type<"String", string, string, TypeOfError<"String">, null, TypeOfError<"String">, never, string, true>, BrandType<BrandType<BrandType<Type<"Number", number, number, TypeOfError<"Number">, null, TypeOfError<"Number">, never, number, true>, "NonNaN", NonNaNError>, "Finite", FiniteError>, "Int", IntError>, "IntFromString", IntFromStringError, string>, 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>, "LessThanOrEqualTo65535", LessThanOrEqualToError<65535>>, "Port", never>, "PortFromString", never, number & Brand<"NonNaN"> & Brand<"Finite"> & Brand<"Int"> & Brand<"NonNegative"> & Brand<"LessThanOrEqualTo65535"> & Brand<"Port">>;
 /**
  * Finite {@link Number} from zero to one, inclusive.
  *
@@ -3526,6 +4592,7 @@ export type NegativeDecimalString = typeof NegativeDecimalString.Output;
  * >();
  *
  * assertOk(Tenths.fromUnknown(0.3), 0.3);
+ *
  * const invalid = Tenths.fromUnknown(0.31);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -3622,6 +4689,7 @@ export interface BetweenError<Min extends number = number, Max extends number =
  *
  * const UserId = brand("UserId", String);
  * const UserIds = array(UserId);
+ *
  * const result = UserIds.from.parent(["ada", "grace"]);
  *
  * assertType<
@@ -3630,6 +4698,7 @@ export interface BetweenError<Min extends number = number, Max extends number =
  * >();
  * assertOk(result, ["ada", "grace"]);
  * assertOk(UserIds.fromUnknown(["ada", "grace"]), ["ada", "grace"]);
+ *
  * const invalid = UserIds.fromUnknown("ada");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -4146,53 +5215,92 @@ interface TupleItemsErrorValue<Error extends TypeError, IncludeStructuralIssues
     };
 }
 /**
- * Decimal digit from `"0"` to `"9"`.
+ * Decimal integer string from `"0"` to `"9"`.
  *
  * @group String
  */
 export declare const Digit: UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>;
 export type Digit = typeof Digit.Output;
 /**
- * Decimal digit from `"1"` to `"9"`.
+ * Decimal integer string from `"1"` to `"9"`.
  *
  * @group String
  */
 export declare const Digit1To9: UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>;
 export type Digit1To9 = typeof Digit1To9.Output;
 /**
- * Decimal string from `"1"` to `"6"`.
+ * Decimal integer string from `"1"` to `"6"`.
  *
  * @group String
  */
 export declare const Digit1To6: UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">]>;
 export type Digit1To6 = typeof Digit1To6.Output;
 /**
- * Decimal string from `"1"` to `"23"`.
+ * Decimal integer string from `"1"` to `"23"`, without a leading zero.
  *
  * @group String
  */
-export declare const Digit1To23: UnionType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, TemplateLiteralType<readonly ["1", UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>]>, TemplateLiteralType<readonly ["2", UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">]>]>]>;
+export declare const Digit1To23: UnionType<readonly [
+    typeof Digit1To9,
+    TemplateLiteralType<readonly ["1", typeof Digit]>,
+    TemplateLiteralType<readonly [
+        "2",
+        UnionType<readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">
+        ]>
+    ]>
+]>;
 export type Digit1To23 = typeof Digit1To23.Output;
 /**
- * Decimal string from `"1"` to `"51"`.
+ * Decimal integer string from `"1"` to `"51"`, without a leading zero.
  *
  * @group String
  */
-export declare const Digit1To51: UnionType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, TemplateLiteralType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">]>, UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>]>, TemplateLiteralType<readonly ["5", UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>]>]>;
+export declare const Digit1To51: UnionType<readonly [
+    typeof Digit1To9,
+    TemplateLiteralType<readonly [
+        UnionType<readonly [
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">,
+            LiteralType<"4">
+        ]>,
+        typeof Digit
+    ]>,
+    TemplateLiteralType<readonly ["5", UnionType<readonly [LiteralType<"0">, LiteralType<"1">]>]>
+]>;
 export type Digit1To51 = typeof Digit1To51.Output;
 /**
- * Decimal string from `"1"` to `"99"`.
+ * Decimal integer string from `"1"` to `"99"`, without a leading zero.
  *
  * @group String
  */
-export declare const Digit1To99: UnionType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, TemplateLiteralType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>]>]>;
+export declare const Digit1To99: UnionType<readonly [
+    typeof Digit1To9,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit]>
+]>;
 export type Digit1To99 = typeof Digit1To99.Output;
 /**
- * Decimal string from `"1"` to `"59"`.
+ * Decimal integer string from `"1"` to `"59"`, without a leading zero.
  *
  * @group String
  */
-export declare const Digit1To59: UnionType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>, TemplateLiteralType<readonly [UnionType<readonly [LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">]>, UnionType<readonly [LiteralType<"0">, LiteralType<"1">, LiteralType<"2">, LiteralType<"3">, LiteralType<"4">, LiteralType<"5">, LiteralType<"6">, LiteralType<"7">, LiteralType<"8">, LiteralType<"9">]>]>]>;
+export declare const Digit1To59: UnionType<readonly [
+    typeof Digit1To9,
+    TemplateLiteralType<readonly [
+        UnionType<readonly [
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">,
+            LiteralType<"4">,
+            LiteralType<"5">
+        ]>,
+        typeof Digit
+    ]>
+]>;
 export type Digit1To59 = typeof Digit1To59.Output;
 type PlainObjectError = ObjectError<Readonly<Record<never, never>>, ObjectPropertyAccessError | ObjectExcessPropertyError>;
 /**
@@ -4301,6 +5409,7 @@ export { _Object as Object };
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -4336,6 +5445,7 @@ export { _Object as Object };
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -4370,6 +5480,16 @@ interface RecordTypeNode extends TypeNode {
 interface ObjectRecordTypeNode extends RecordTypeNode {
     readonly key: typeof String;
 }
+type RuntimeRecordKeyTypeNode = Omit<RuntimeTypeNode, "fromUnknown" | "from" | "to"> & {
+    readonly fromUnknown: (value: unknown, options: ValidationOptions) => Result<string, TypeError>;
+    readonly from: RuntimeOperation<Result<string, TypeError>>;
+    readonly to: (value: never) => string;
+};
+interface RuntimeRecordTypeNode extends RuntimeTypeNode {
+    readonly name: "Record";
+    readonly key: RuntimeRecordKeyTypeNode;
+    readonly value: RuntimeTypeNode;
+}
 type RecordShape<KeyType extends TypeNode, ValueType extends TypeNode, Field extends "Input" | "Output" | "CanonicalInput"> = [Extract<RecordTypeField<KeyType, Field>, string>] extends [never] ? Readonly<Record<string, never>> : Readonly<Partial<Record<Extract<RecordTypeField<KeyType, Field>, string>, RecordTypeField<ValueType, Field>>>>;
 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> = [
@@ -4499,6 +5619,7 @@ interface RecordEntriesErrorValue<KeyError extends TypeError, ValueError extends
 export interface OptionalProperty<T extends TypeNode> {
     readonly type: T;
     readonly [errorsSymbol]: InferErrors<T>;
+    readonly [optionalPropertySymbol]: true;
 }
 /**
  * Optional {@link object} property.
@@ -4534,13 +5655,147 @@ export interface OptionalProperty<T extends TypeNode> {
  * @group Objects
  */
 export declare const optional: <T extends TypeNode>(type: ValidateOptionalPropertyType<T>) => OptionalProperty<T>;
+declare const optionalPropertySymbolType: unique symbol;
+declare const optionalPropertySymbol: typeof optionalPropertySymbolType;
 type ValidateOptionalPropertyType<T extends TypeNode> = IsUnion<T> extends false ? T extends ConcreteTypeNode ? T : ObjectPropertyTypeError : ObjectPropertyTypeError;
+/**
+ * A value decoded by {@link withDefault} with the `preserve` strategy.
+ *
+ * `defaultUsed` distinguishes supplied values from defaults, even when their
+ * values are equal. `original` records the decoded absence, not the raw input
+ * before other transformations.
+ *
+ * @group Construction
+ */
+export type Defaulted<Value, Default = Value, Original extends "missing" | "null" | "undefined" = "missing" | "null" | "undefined"> = {
+    readonly value: Value;
+    readonly defaultUsed: false;
+} | {
+    readonly value: Default;
+    readonly defaultUsed: true;
+    readonly original: Original;
+};
+/**
+ * The value Type returned by {@link withDefault}.
+ *
+ * @group Construction
+ */
+export interface WithDefaultType<T extends TypeNode, Value, Strategy extends "replace" | "preserve"> extends Type<"WithDefault", T["Input"], WithDefaultOutput<T, Value, Strategy>, never, T, InferErrors<T>, ChildCustomFrom<T, WithDefaultOutput<T, Value, Strategy>, never>, T["CanonicalInput"], false> {
+}
+/**
+ * An optional input property made required in the Output by {@link withDefault}.
+ *
+ * @group Objects
+ */
+export interface WithDefaultProperty<T extends TypeNode, Value, Strategy extends "replace" | "preserve"> {
+    readonly type: T;
+    readonly value: Value;
+    readonly strategy: Strategy;
+    /** @ignore */
+    readonly [errorsSymbol]: InferErrors<T>;
+    /** @ignore */
+    readonly [defaultPropertySymbol]: RuntimeDefaultOperations;
+}
+/**
+ * Supplies a decoded default for absence accepted by another {@link Type}.
+ *
+ * You might not need this: use `??` where a value is consumed if the default
+ * does not need to become part of the decoded data. By default, replacement
+ * loses the distinction between absence and an explicitly supplied value. Set
+ * `strategy: "preserve"` to retain it.
+ *
+ * Defaults apply after decoding, to `null` and `undefined` accepted by the
+ * wrapped Type, and to missing properties when wrapping {@link optional}. Types
+ * whose Output excludes both `null` and `undefined` require `optional`;
+ * otherwise there is no accepted absence to default. Invalid supplied values
+ * still fail. An optional property does not accept an explicit `undefined`
+ * unless its Type does. The default must be an Output of the wrapped Type; it
+ * is checked when constructing the declaration. It may itself be `null` or
+ * `undefined` when the wrapped Output accepts that value.
+ *
+ * Omitting `strategy` returns the effective value and encodes it as supplied
+ * data. `strategy: "preserve"` returns {@link Defaulted} and restores absence
+ * when encoding. A supplied value equal to the default still has `defaultUsed:
+ * false`. Preserved defaults must equal the configured value: {@link Data}
+ * values use structural equality, and other values use reference identity.
+ * Every decoded absence reuses the configured default by reference; defaults
+ * are not cloned. Treat default values as immutable, like other Type
+ * declarations.
+ *
+ * Pass the default value as the second argument. Add `{ strategy: "preserve" }`
+ * as the third argument to retain supplied-input evidence. Explicit `strategy:
+ * "replace"` is not accepted.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   Boolean,
+ *   nullOr,
+ *   object,
+ *   optional,
+ *   withDefault,
+ * } from "@evolu/common";
+ *
+ * const Settings = object({
+ *   enabled: withDefault(optional(Boolean), true, {
+ *     strategy: "preserve",
+ *   }),
+ * });
+ *
+ * const missing = Settings.fromUnknown({});
+ * assertOk(missing, {
+ *   enabled: { value: true, defaultUsed: true, original: "missing" },
+ * });
+ * assertEqual(Settings.to(missing.value), {});
+ *
+ * assertOk(Settings.fromUnknown({ enabled: true }), {
+ *   enabled: { value: true, defaultUsed: false },
+ * });
+ * assertErr(Settings.fromUnknown({ enabled: undefined }));
+ *
+ * const Enabled = withDefault(nullOr(Boolean), true);
+ *
+ * assertOk(Enabled.fromUnknown(null), true);
+ * assertEqual(Enabled.to(true), true);
+ * ```
+ *
+ * @group Construction
+ */
+export declare function withDefault<T extends TypeNode, const Value extends NoInfer<T["Output"]>>(property: OptionalProperty<T> & {
+    readonly type: ValidateDefaultType<T, true>;
+}, value: Value): WithDefaultProperty<T, Value, "replace">;
+export declare function withDefault<T extends TypeNode, const Value extends NoInfer<T["Output"]>>(property: OptionalProperty<T> & {
+    readonly type: ValidateDefaultType<T, true>;
+}, value: Value, options: {
+    readonly strategy: "preserve";
+}): WithDefaultProperty<T, Value, "preserve">;
+export declare function withDefault<T extends TypeNode, const Value extends NoInfer<T["Output"]>>(type: T & ValidateDefaultType<T>, value: Value): WithDefaultType<T, Value, "replace">;
+export declare function withDefault<T extends TypeNode, const Value extends NoInfer<T["Output"]>>(type: T & ValidateDefaultType<T>, value: Value, options: {
+    readonly strategy: "preserve";
+}): WithDefaultType<T, Value, "preserve">;
+type ValidateDefaultType<T extends TypeNode, Optional extends boolean = false> = ValidateOptionalPropertyType<T> & ([ChildTypeNameValidationError<"WithDefault", T>] extends [never] ? unknown : ChildTypeNameValidationError<"WithDefault", T>) & (Optional extends true ? unknown : [DefaultOriginal<T>] extends [never] ? CompileTimeError<"Type", "withDefault requires an optional property or a Type whose Output includes null or undefined."> : unknown);
+type DefaultOriginal<T extends TypeNode> = (null extends T["Output"] ? "null" : never) | (undefined extends T["Output"] ? "undefined" : never);
+type WithDefaultOutput<T extends TypeNode, Value, Strategy extends "replace" | "preserve", Original extends "missing" | "null" | "undefined" = DefaultOriginal<T>> = Strategy extends "replace" ? NonNullable<T["Output"]> | Value : Defaulted<NonNullable<T["Output"]>, Value, Original>;
+declare const defaultPropertySymbolType: unique symbol;
+declare const defaultPropertySymbol: typeof defaultPropertySymbolType;
+interface RuntimeDefaultOperations {
+    readonly output: RuntimeTypeNode;
+    readonly decode: (value: unknown) => unknown;
+    readonly encode: (value: never) => unknown;
+    readonly createObject: (props: ObjectProps, record: RuntimeRecordTypeNode | undefined) => ObjectTypeNode;
+    readonly partial: (type: RuntimeTypeNode) => OptionalProperty<TypeNode>;
+}
 /**
  * Properties used to construct an {@link object} Type.
  *
  * @group Objects
  */
-export type ObjectProps = Readonly<Record<string, TypeNode | OptionalProperty<TypeNode>>>;
+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}.
@@ -4548,7 +5803,10 @@ type ObjectProperty = ObjectProps[string];
  * 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`.
+ * `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
@@ -4636,6 +5894,7 @@ type ObjectProperty = ObjectProps[string];
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -4671,6 +5930,7 @@ type ObjectProperty = ObjectProps[string];
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -4686,7 +5946,7 @@ type ObjectProperty = ObjectProps[string];
  *
  * @group Objects
  */
-export declare function object<const Props extends ObjectProps>(props: Props, ...validation: [ObjectValidationError<Props>] extends [never] ? [] : [ValidationFailure<ObjectValidationError<Props>>]): StrictObjectType<Props>;
+export declare function object<const Props extends ObjectValueProps>(props: Props, ...validation: [ObjectValidationError<Props>] extends [never] ? [] : [ValidationFailure<ObjectValidationError<Props>>]): StrictObjectType<Props>;
 /**
  * Creates an Object Type with additional record properties.
  *
@@ -4705,6 +5965,7 @@ export declare function object<const Props extends ObjectProps>(props: Props, ..
  *   { authorization: String },
  *   record(String, String),
  * );
+ *
  * const result = RequestHeaders.fromUnknown({
  *   authorization: "Bearer token",
  *   "x-request-id": "request-1",
@@ -4717,11 +5978,22 @@ export declare function object<const Props extends ObjectProps>(props: Props, ..
  * assertType<(typeof result.value)["x-request-id"], string | undefined>();
  * ```
  */
-export declare function object<const Props extends ObjectProps, const Rest extends RecordTypeNode & ConcreteTypeNode>(props: Props, record: Rest, ...validation: [
+export declare function object<const Props extends ObjectValueProps, const Rest extends RecordTypeNode & ConcreteTypeNode>(props: Props, record: Rest, ...validation: [
     ObjectValidationError<Props> | ObjectRecordValidationError<Props, Rest>
 ] extends [never] ? [] : [
     ValidationFailure<ObjectValidationError<Props> | ObjectRecordValidationError<Props, Rest>>
 ]): ObjectWithRecordType<Props, Rest extends ObjectRecordTypeNode ? Rest : never>;
+/** Creates an Object Type with explicit defaults for optional inputs. */
+export declare function object<const Props extends ObjectProps>(props: Props, ...validation: [ObjectValidationError<Props>] extends [never] ? [] : [ValidationFailure<ObjectValidationError<Props>>]): ObjectType<Props>;
+/**
+ * Creates an Object Type with explicit defaults and additional record
+ * properties.
+ */
+export declare function object<const Props extends ObjectProps, const Rest extends ObjectRecordTypeNode & ConcreteTypeNode>(props: Props, record: Rest, ...validation: [
+    ObjectValidationError<Props> | ObjectRecordValidationError<Props, Rest>
+] extends [never] ? [] : [
+    ValidationFailure<ObjectValidationError<Props> | ObjectRecordValidationError<Props, Rest>>
+]): ObjectType<Props, Rest>;
 interface ObjectTypeNode extends TypeNode {
     readonly name: "Object";
     readonly props: ObjectProps;
@@ -4732,16 +6004,18 @@ type ObjectValidationError<Props extends ObjectProps> = IsUnion<Props> extends f
 }[keyof Props] : ObjectPropsTypeError;
 type ObjectRecordValidationError<Props extends ObjectProps, Rest extends RecordTypeNode & ConcreteTypeNode> = IsUnion<Rest> extends false ? Rest["key"] extends typeof String ? typeof String extends Rest["key"] ? ObjectRecordPropertyValidationError<Props, Rest["value"]> : ObjectRecordKeyTypeError : ObjectRecordKeyTypeError : ObjectRecordTypeError;
 type ObjectRecordPropertyValidationError<Props extends ObjectProps, ValueType extends TypeNode> = [
-    ObjectPropertyType<Props[keyof Props]>["Input"],
-    ObjectPropertyType<Props[keyof Props]>["Output"],
-    ObjectPropertyType<Props[keyof Props]>["CanonicalInput"]
+    DefaultableObjectPropertyType<Props[keyof Props]>["Input"],
+    DefaultableObjectPropertyType<Props[keyof Props]>["Output"],
+    DefaultableObjectPropertyType<Props[keyof Props]>["CanonicalInput"]
 ] extends [ValueType["Input"], ValueType["Output"], ValueType["CanonicalInput"]] ? never : ObjectRecordPropertyTypeError<Props, ValueType>;
-type ObjectRecordPropertyTypeError<Props extends ObjectProps, ValueType extends TypeNode> = [ObjectPropertyType<Props[keyof Props]>["Input"]] extends [
+type ObjectRecordPropertyTypeError<Props extends ObjectProps, ValueType extends TypeNode> = [DefaultableObjectPropertyType<Props[keyof Props]>["Input"]] extends [
     ValueType["Input"]
-] ? [ObjectPropertyType<Props[keyof Props]>["Output"]] extends [
+] ? [DefaultableObjectPropertyType<Props[keyof Props]>["Output"]] extends [
     ValueType["Output"]
 ] ? ObjectRecordCanonicalInputTypeError : ObjectRecordOutputTypeError : ObjectRecordInputTypeError;
-type ObjectPropertyValidationError<Property extends ObjectProperty> = IsUnion<Property> extends false ? Property extends OptionalProperty<infer T extends TypeNode> ? ObjectPropertyTypeValidationError<T> : Property extends TypeNode ? ObjectPropertyTypeValidationError<Property> : ObjectPropertyTypeError : ObjectPropertyTypeError;
+type ObjectPropertyValidationError<Property extends ObjectProperty> = IsUnion<Property> extends false ? Property extends TypeNode ? ObjectPropertyTypeValidationError<Property> : Property extends {
+    readonly type: infer T extends TypeNode;
+} ? ObjectPropertyTypeValidationError<T> : ObjectPropertyTypeError : ObjectPropertyTypeError;
 type ObjectPropertyTypeValidationError<T extends TypeNode> = IsUnion<T> extends false ? T extends ConcreteTypeNode ? [
     Extract<"ObjectMissingProperty" | "ObjectPropertyAccess" | "ObjectExcessProperty", InferErrors<T>["type"]>
 ] extends [never] ? never : CompileTimeError<"Type", "Property Type must not use an error tag reserved for Object structure."> : ObjectPropertyTypeError : ObjectPropertyTypeError;
@@ -4763,60 +6037,73 @@ type ObjectRecordCanonicalInputTypeError = CompileTimeError<"Type", "Every decla
  *
  * @group Objects
  */
-export type ObjectType<Props extends ObjectProps, Rest extends ObjectRecordTypeNode | undefined = undefined> = Rest extends ObjectRecordTypeNode ? ObjectWithRecordType<Props, Rest> : StrictObjectType<Props>;
-type StrictObjectType<Props extends ObjectProps> = Type<"Object", StrictObjectShape<Props, "Input">, StrictObjectShape<Props, "Output">, [
+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> = {
+    readonly [Key in keyof Props]: Props[Key] extends WithDefaultProperty<infer T, unknown, "replace" | "preserve"> ? OptionalProperty<T> : Extract<Props[Key], TypeNode | OptionalProperty<TypeNode>>;
+};
+type DefaultOutputProps<Props extends ObjectProps> = {
+    readonly [Key in keyof Props]: Props[Key] extends WithDefaultProperty<infer T, infer Value, infer Strategy> ? Type<"DefaultValue", WithDefaultOutput<T, Value, Strategy, "missing" | DefaultOriginal<T>>, WithDefaultOutput<T, Value, Strategy, "missing" | DefaultOriginal<T>>, never> : Extract<Props[Key], TypeNode | OptionalProperty<TypeNode>>;
+};
+type DefaultObjectType<Props extends ObjectProps, Rest extends ObjectRecordTypeNode | undefined> = Type<"Object", ObjectValueType<DefaultInputProps<Props>, Rest>["Input"], ObjectValueType<DefaultOutputProps<Props>, Rest>["Output"], TypeFromError<ObjectValueType<DefaultInputProps<Props>, Rest>>, RootType<ObjectValueType<DefaultInputProps<Props>, Rest>>, InferErrors<ObjectValueType<DefaultInputProps<Props>, Rest>>, never, ObjectValueType<DefaultInputProps<Props>, Rest>["CanonicalInput"], false> & {
+    readonly props: Readonly<Props>;
+} & (Rest extends ObjectRecordTypeNode ? {
+    readonly record: Rest;
+} : {});
+type StrictObjectType<Props extends ObjectValueProps> = Type<"Object", StrictObjectShape<Props, "Input">, StrictObjectShape<Props, "Output">, [
     StrictObjectParents<Props>
 ] extends [null] ? StrictObjectFromUnknownError<StrictObjectFromUnknownPropertyErrors<Props>> : ObjectFromParentError<ObjectFromParentPropertyErrors<Props>>, [
     StrictObjectParents<Props>
 ] extends [null] ? null : StrictRootObjectType<RootObjectProps<Props>>, StrictObjectFromUnknownError<StrictObjectFromUnknownPropertyErrors<Props>>, never, StrictObjectShape<Props, "CanonicalInput">, AllTypesUseIdentityEncoding<ObjectPropertyType<Props[keyof Props]>>> & {
     readonly props: Readonly<Props>;
 };
-type ObjectWithRecordType<Props extends ObjectProps, Rest extends ObjectRecordTypeNode> = Type<"Object", ObjectWithRecordShape<Props, Rest, "Input">, ObjectWithRecordShape<Props, Rest, "Output">, [
+type ObjectWithRecordType<Props extends ObjectValueProps, Rest extends ObjectRecordTypeNode> = Type<"Object", ObjectWithRecordShape<Props, Rest, "Input">, ObjectWithRecordShape<Props, Rest, "Output">, [
     ObjectWithRecordParents<Props, Rest>
 ] extends [null] ? ObjectError<ObjectDeclaredErrors<Props>, ObjectRestFromUnknownError<Rest>> : ObjectPropertiesError<ObjectFromParentPropertyErrors<Props>, ObjectRestFromParentError<Rest>>, [
     ObjectWithRecordParents<Props, Rest>
 ] extends [null] ? null : RootObjectWithRecordType<RootObjectProps<Props>, RootObjectRecord<Rest>>, ObjectError<ObjectDeclaredErrors<Props>, ObjectRestFromUnknownError<Rest>>, never, ObjectWithRecordShape<Props, Rest, "CanonicalInput">, AllTypesUseIdentityEncoding<ObjectPropertyType<Props[keyof Props]> | Rest>> & ObjectWithRecordReflection<Props, Rest>;
-type StrictObjectShape<Props extends ObjectProps, Field extends "Input" | "Output" | "CanonicalInput"> = keyof Props extends never ? Readonly<Record<string, never>> : {
+type StrictObjectShape<Props extends ObjectValueProps, Field extends "Input" | "Output" | "CanonicalInput"> = keyof Props extends never ? Readonly<Record<string, never>> : {
     readonly [Key in RequiredObjectKeys<Props>]: ObjectTypeField<ObjectPropertyType<Props[Key]>, Field>;
 } & {
     readonly [Key in OptionalObjectKeys<Props>]?: ObjectTypeField<ObjectPropertyType<Props[Key]>, Field>;
 };
-type ObjectWithRecordShape<Props extends ObjectProps, Rest extends ObjectRecordTypeNode, Field extends "Input" | "Output" | "CanonicalInput"> = keyof Props extends never ? ObjectRestShape<Rest, Field> : ObjectDeclaredShape<Props, Field> & ObjectRestShape<Rest, Field>;
-type ObjectDeclaredShape<Props extends ObjectProps, Field extends "Input" | "Output" | "CanonicalInput"> = Simplify<{
+type ObjectWithRecordShape<Props extends ObjectValueProps, Rest extends ObjectRecordTypeNode, Field extends "Input" | "Output" | "CanonicalInput"> = keyof Props extends never ? ObjectRestShape<Rest, Field> : ObjectDeclaredShape<Props, Field> & ObjectRestShape<Rest, Field>;
+type ObjectDeclaredShape<Props extends ObjectValueProps, Field extends "Input" | "Output" | "CanonicalInput"> = Simplify<{
     readonly [Key in RequiredObjectKeys<Props>]: ObjectTypeField<ObjectPropertyType<Props[Key]>, Field>;
 } & {
     readonly [Key in OptionalObjectKeys<Props>]?: ObjectTypeField<ObjectPropertyType<Props[Key]>, Field>;
 }>;
 type ObjectRestShape<Rest extends ObjectRecordTypeNode, Field extends "Input" | "Output" | "CanonicalInput"> = Readonly<Partial<Record<string, ObjectTypeField<Rest["value"], Field>>>>;
 type ObjectTypeField<T extends TypeNode, Field extends "Input" | "Output" | "CanonicalInput"> = Field extends "CanonicalInput" ? CanonicalInputOf<T> : T[Field];
-type RequiredObjectKeys<Props extends ObjectProps> = Exclude<keyof Props, OptionalObjectKeys<Props>>;
-type OptionalObjectKeys<Props extends ObjectProps> = {
+type RequiredObjectKeys<Props extends ObjectValueProps> = Exclude<keyof Props, OptionalObjectKeys<Props>>;
+type OptionalObjectKeys<Props extends ObjectValueProps> = {
     readonly [Key in keyof Props]: Props[Key] extends OptionalProperty<TypeNode> ? Key : never;
 }[keyof Props];
-type ObjectPropertyType<Property extends ObjectProperty> = Property extends OptionalProperty<infer T> ? T : Property;
-type ObjectFromParentPropertyErrors<Props extends ObjectProps> = {
+type ObjectPropertyType<Property extends ObjectValueProps[string]> = Property extends OptionalProperty<infer T> ? T : Property;
+type ObjectFromParentPropertyErrors<Props extends ObjectValueProps> = {
     readonly [Key in keyof Props]: TypeFromError<ObjectPropertyType<Props[Key]>>;
 };
-type StrictRootObjectType<Props extends ObjectProps> = Type<"Object", StrictObjectShape<Props, "Input">, StrictObjectShape<Props, "Output">, StrictObjectFromUnknownError<StrictObjectFromUnknownPropertyErrors<Props>>, null, StrictObjectFromUnknownError<StrictObjectFromUnknownPropertyErrors<Props>>, never, StrictObjectShape<Props, "CanonicalInput">, AllTypesUseIdentityEncoding<ObjectPropertyType<Props[keyof Props]>>> & {
+type StrictRootObjectType<Props extends ObjectValueProps> = Type<"Object", StrictObjectShape<Props, "Input">, StrictObjectShape<Props, "Output">, StrictObjectFromUnknownError<StrictObjectFromUnknownPropertyErrors<Props>>, null, StrictObjectFromUnknownError<StrictObjectFromUnknownPropertyErrors<Props>>, never, StrictObjectShape<Props, "CanonicalInput">, AllTypesUseIdentityEncoding<ObjectPropertyType<Props[keyof Props]>>> & {
     readonly props: Readonly<Props>;
 };
-type RootObjectWithRecordType<Props extends ObjectProps, Rest extends ObjectRecordTypeNode> = Type<"Object", ObjectWithRecordShape<Props, Rest, "Input">, ObjectWithRecordShape<Props, Rest, "Output">, ObjectError<ObjectDeclaredErrors<Props>, ObjectRestFromUnknownError<Rest>>, null, ObjectError<ObjectDeclaredErrors<Props>, ObjectRestFromUnknownError<Rest>>, never, ObjectWithRecordShape<Props, Rest, "CanonicalInput">, AllTypesUseIdentityEncoding<ObjectPropertyType<Props[keyof Props]> | Rest>> & ObjectWithRecordReflection<Props, Rest>;
-type StrictObjectParents<Props extends ObjectProps> = ObjectPropertyType<Props[keyof Props]>["parent"];
-type ObjectWithRecordParents<Props extends ObjectProps, Rest extends ObjectRecordTypeNode> = ObjectPropertyType<Props[keyof Props]>["parent"] | Rest["parent"];
-type RootObjectProps<Props extends ObjectProps> = {
+type RootObjectWithRecordType<Props extends ObjectValueProps, Rest extends ObjectRecordTypeNode> = Type<"Object", ObjectWithRecordShape<Props, Rest, "Input">, ObjectWithRecordShape<Props, Rest, "Output">, ObjectError<ObjectDeclaredErrors<Props>, ObjectRestFromUnknownError<Rest>>, null, ObjectError<ObjectDeclaredErrors<Props>, ObjectRestFromUnknownError<Rest>>, never, ObjectWithRecordShape<Props, Rest, "CanonicalInput">, AllTypesUseIdentityEncoding<ObjectPropertyType<Props[keyof Props]> | Rest>> & ObjectWithRecordReflection<Props, Rest>;
+type StrictObjectParents<Props extends ObjectValueProps> = ObjectPropertyType<Props[keyof Props]>["parent"];
+type ObjectWithRecordParents<Props extends ObjectValueProps, Rest extends ObjectRecordTypeNode> = ObjectPropertyType<Props[keyof Props]>["parent"] | Rest["parent"];
+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 ObjectProps, Rest extends ObjectRecordTypeNode> {
+interface ObjectWithRecordReflection<Props extends ObjectValueProps, Rest extends ObjectRecordTypeNode> {
     readonly props: Readonly<Props>;
     readonly record: Rest;
 }
-type ObjectDeclaredErrors<Props extends ObjectProps> = {
+type ObjectDeclaredErrors<Props extends ObjectValueProps> = {
     readonly [Key in RequiredObjectKeys<Props>]: Props[Key][typeof errorsSymbol];
 } & {
     readonly [Key in OptionalObjectKeys<Props>]?: Props[Key][typeof errorsSymbol];
 };
-type StrictObjectFromUnknownPropertyErrors<Props extends ObjectProps> = {
+type StrictObjectFromUnknownPropertyErrors<Props extends ObjectValueProps> = {
     readonly [Key in RequiredObjectKeys<Props>]: Props[Key][typeof errorsSymbol] | ObjectMissingPropertyError | ObjectPropertyAccessError;
 } & {
     readonly [Key in OptionalObjectKeys<Props>]: Props[Key][typeof errorsSymbol] | ObjectPropertyAccessError;
@@ -4933,7 +6220,8 @@ type ObjectRestFromParentError<Rest extends ObjectRecordTypeNode | undefined> =
  * Object {@link Type} with every property optional.
  *
  * No property is required, but every present property must still satisfy its
- * Type.
+ * Type. For {@link withDefault} properties, this disables the missing-property
+ * default; defaults for present `null` or `undefined` values still apply.
  *
  * ### Example
  *
@@ -4963,7 +6251,7 @@ export declare const partial: <const Props extends ObjectProps>(props: Props, ..
  * @group Objects
  */
 export type PartialObjectProps<Props extends ObjectProps> = {
-    readonly [Key in keyof Props]: Props[Key] extends OptionalProperty<TypeNode> ? Props[Key] : Props[Key] extends TypeNode ? OptionalProperty<Props[Key]> : never;
+    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} making every property whose Union Type includes
@@ -5023,12 +6311,91 @@ export type NullableToOptionalProps<Props extends ObjectProps> = {
  *
  * @group Objects
  */
-export declare const omit: <const Props extends ObjectProps, const Keys extends ReadonlyArray<keyof Props>, Rest extends ObjectRecordTypeNode | undefined = undefined>(objectType: ObjectType<Props, Rest>, ...keys: Keys & ([ValidateOmitKeys<Keys>] extends [never] ? unknown : readonly [ValidationFailure<ValidateOmitKeys<Keys>>])) => ObjectType<Omit<Props, Keys[number]>, Rest>;
+export declare const omit: <const Props extends ObjectProps, const Keys extends ReadonlyArray<keyof Props>, Rest extends ObjectRecordTypeNode | undefined = undefined>(objectType: {
+    readonly props: Props;
+    readonly record?: Rest;
+} & NoInfer<ObjectType<Props, Rest>>, ...keys: Keys & ([ValidateOmitKeys<Keys>] extends [never] ? unknown : readonly [ValidationFailure<ValidateOmitKeys<Keys>>])) => ObjectType<Omit<Props, Keys[number]>, Rest>;
 type ValidateOmitKeys<Keys extends ReadonlyArray<PropertyKey>> = number extends Keys["length"] ? OmitKeysTupleError : IsUnion<Keys["length"]> extends false ? {
     readonly [Index in keyof Keys & `${number}`]: IsUnion<Keys[Index]> extends false ? {} extends Readonly<Record<Keys[Index], never>> ? OmitKeyConcreteTypeError : never : OmitKeyConcreteTypeError;
 }[keyof Keys & `${number}`] : OmitKeysTupleError;
 type OmitKeysTupleError = CompileTimeError<"Type", "Omitted keys must use one concrete finite tuple.">;
 type OmitKeyConcreteTypeError = CompileTimeError<"Type", "Each omitted key must be one concrete property key.">;
+/**
+ * The {@link Type} returned by {@link objectKeys}.
+ *
+ * @group Objects
+ */
+export interface ObjectKeysType<Key extends TypeNode, T extends TypeNode & {
+    readonly props: ObjectProps;
+}> extends Type<"ObjectKeys", unknown, T["Output"], ObjectKeysError<T> | TransformOutputError<"ObjectKeys", InferErrors<T>>, typeof Unknown, ObjectKeysError<T> | TransformOutputError<"ObjectKeys", InferErrors<T>>, never, Readonly<Record<string, T["CanonicalInput"][keyof T["CanonicalInput"]]>>, false> {
+    readonly key: Key;
+    readonly output: T;
+    readonly [reflectedTypesSymbol]?: Key | T;
+}
+/**
+ * Renames a strict {@link object} Type's encoded keys using a string codec.
+ *
+ * The object declaration uses semantic keys. Each key must be a valid Output of
+ * the key Type. Its canonical encoding becomes the external property name.
+ * Decoding accepts those exact names; aliases and unknown properties are
+ * rejected. Values, optionality, and semantic Output stay with the object Type.
+ * Only the outer keys change. Nested field codecs keep their own behavior.
+ *
+ * Construction rejects invalid schema keys, duplicate encodings, and key codecs
+ * that do not decode their encodings back to the declared keys. These are
+ * schema mistakes; invalid external values return normal Type errors. Error
+ * paths use the external names, including missing required properties.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   CamelCaseIdentifierFromConstantCaseIdentifier,
+ *   object,
+ *   objectKeys,
+ *   optional,
+ *   PortFromString,
+ *   prefixed,
+ * } from "@evolu/common";
+ *
+ * const Key = prefixed("APP_")(
+ *   CamelCaseIdentifierFromConstantCaseIdentifier,
+ * );
+ * const Settings = objectKeys(Key)(
+ *   object({ port: optional(PortFromString) }),
+ * );
+ *
+ * const result = Settings.fromUnknown({ APP_PORT: "04000" });
+ * assertOk(result, { port: 4000 });
+ *
+ * assertEqual(Settings.to(result.value), { APP_PORT: "4000" });
+ *
+ * assertErr(Settings.fromUnknown({ APP_POTR: "4000" }));
+ * ```
+ *
+ * @group Objects
+ */
+export declare const objectKeys: <Key extends ConcreteTypeNode & {
+    readonly Output: string;
+    readonly CanonicalInput: string;
+}>(key: Key & ValidateOutput<Key>) => <T extends ConcreteTypeNode & {
+    readonly name: "Object";
+    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.
  *
@@ -5122,7 +6489,9 @@ export type UnknownResult = typeof UnknownResult.Output;
  *   type: "Loaded",
  *   value: "Evolu",
  * });
+ *
  * assertFalse(Loading.is({ type: "Loading", progress: 1 }));
+ *
  * assertType<
  *   typeof Loading.Output extends { readonly type: "Loading" }
  *     ? true
@@ -5168,6 +6537,7 @@ export declare function typed<const Tag extends TypeName, const Props extends Ob
  * } from "@evolu/common";
  *
  * const Open = typed("Open", { label: String }, record(String, String));
+ *
  * const result = Open.fromUnknown({
  *   type: "Open",
  *   label: "Ready",
@@ -5316,6 +6686,7 @@ type TypedTypePropertyError = CompileTimeError<"Type", 'Additional properties mu
  * };
  *
  * assertEqual(describeNext({ ok: true, value: "item" }), "Value: item");
+ *
  * assertEqual(
  *   describeNext({
  *     ok: false,
@@ -5323,6 +6694,7 @@ type TypedTypePropertyError = CompileTimeError<"Type", 'Additional properties mu
  *   }),
  *   "Done: complete",
  * );
+ *
  * assertEqual(
  *   describeNext({
  *     ok: false,