@evolu/common 8.8.0 → 8.10.0

package/src/Type.ts

@@ -341,9 +341,9 @@
  * parameter type. If application code claims an accessor-backed object or an
  * object with excess properties is an Object Output, the assertion throws
  * because the application contract is broken. `orThrow` and `orNull` preserve
- * the assertion at their typed `Input` boundary, then apply {@link getOrThrow}
- * or {@link getOrNull} only to validation failures returned by the remaining
- * pipeline.
+ * the assertion at their typed `Input` boundary. After that boundary, `orThrow`
+ * throws returned validation errors with a formatted message and the original
+ * error as `cause`, while `orNull` maps them to `null`.
  *
  * Consequently, structural representation errors such as sparse Arrays,
  * accessors, and excess properties normally do not enter user-facing validation
@@ -461,17 +461,23 @@ import {
 import { assert, assertNonNullable } from "./Assert.ts";
 import type { Brand } from "./Brand.ts";
 import type { RandomBytesDep } from "./Crypto.ts";
+import { eqData } from "./Eq.ts";
 import { identity, type Thunk } from "./Function.ts";
-import { createMutableRecord, getObjectKind, isPlainObject } from "./Object.ts";
+import {
+  createMutableRecord,
+  getObjectKind,
+  isPlainObject,
+  type ReadonlyRecord,
+} from "./Object.ts";
 import { hasNodeBuffer } from "./Platform.ts";
 import {
   err,
   flatMapResult,
   getOk,
   getOrNull,
-  getOrThrow,
   ok,
   trySync,
+  type getOrThrow,
   type Result,
 } from "./Result.ts";
 import { safelyStringifyUnknownValue } from "./String.ts";
@@ -767,15 +773,22 @@ export interface Type<
     : (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.
@@ -787,20 +800,31 @@ export interface Type<
    * ```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>;
@@ -900,6 +924,61 @@ 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 const typeErrorToIssues = <T extends TypeNode>(
+  type: T,
+  error: InferErrors<NoInfer<T>>,
+): NonEmptyReadonlyArray<TypeIssue> => {
+  const runtimeType = type as unknown as RuntimeTypeNode;
+  return runtimeType[getRuntimeTypeIssuesSymbol](error, "all").map((issue) => ({
+    path: issue.path,
+    message: formatRuntimeTypeIssue(issue),
+  })) as unknown as NonEmptyReadonlyArray<TypeIssue>;
+};
+
 /**
  * The common structural shape of every {@link Type}, with its specific type
  * parameters erased.
@@ -950,6 +1029,11 @@ interface RuntimeTypeIssue {
   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 = (
@@ -1033,6 +1117,34 @@ const createCollectionRuntimeTypeIssues =
 const formatDefaultRuntimeTypeIssue: RuntimeFormatTypeIssue = (issue) =>
   issue.formatError(issue.error);
 
+const formatRuntimeTypeIssue = (
+  issue: RuntimeTypeIssue,
+  formatIssue: RuntimeFormatTypeIssue = formatDefaultRuntimeTypeIssue,
+): string => {
+  const summary = formatIssue(issue);
+  if (issue.alternatives === undefined) return summary;
+
+  return [
+    summary,
+    ...issue.alternatives.flatMap(({ index, name, issues }) =>
+      issues.map((issue) => {
+        const path = issue.path
+          .map((key) =>
+            typeof key === "string"
+              ? `[${JSON.stringify(key)}]`
+              : `[${globalThis.String(key)}]`,
+          )
+          .join("");
+        const message = formatRuntimeTypeIssue(issue, formatIssue).replaceAll(
+          "\n",
+          "\n  ",
+        );
+        return `- ${index}: ${name}${path}: ${message}`;
+      }),
+    ),
+  ].join("\n");
+};
+
 /**
  * Asserts type equality or validates a value with a {@link Type}.
  *
@@ -1134,6 +1246,11 @@ const assertTypeOutput = <Error extends TypeError>(
  * 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
@@ -1319,11 +1436,24 @@ const withFormatError = (
         localizedTypeBySource,
       )
     : null;
+  const localizeIssue = (issue: RuntimeTypeIssue): RuntimeTypeIssue => ({
+    ...issue,
+    formatError: () => formatIssue(issue),
+    ...(issue.alternatives === undefined
+      ? {}
+      : {
+          alternatives: issue.alternatives.map((alternative) => ({
+            ...alternative,
+            issues: alternative.issues.map(
+              localizeIssue,
+            ) as unknown as NonEmptyReadonlyArray<RuntimeTypeIssue>,
+          })),
+        }),
+  });
   const getTypeIssues: RuntimeGetTypeIssues = (error, mode) =>
-    source[getRuntimeTypeIssuesSymbol](error, mode).map((issue) => ({
-      ...issue,
-      formatError: () => formatIssue(issue),
-    })) as unknown as NonEmptyReadonlyArray<RuntimeTypeIssue>;
+    source[getRuntimeTypeIssuesSymbol](error, mode).map(
+      localizeIssue,
+    ) as unknown as NonEmptyReadonlyArray<RuntimeTypeIssue>;
   const derived = createTypeNode<RuntimeTypeNode>(
     source.name,
     parent,
@@ -1342,7 +1472,10 @@ const withFormatError = (
   // boundary. Private operation chains on derived still support composition.
   globalThis.Object.assign(derived, {
     from: source.from,
-    orThrow: source.orThrow,
+    orThrow: createRuntimeOrThrow(
+      getTerminalRuntimeNode(source.from),
+      derived.formatError,
+    ),
     orNull: source.orNull,
   });
 
@@ -1396,11 +1529,12 @@ const localizeTypeReflection = (
   ) as Record<string | symbol, unknown>;
 
   for (const key of Reflect.ownKeys(value)) {
-    localized[key] = localizeTypeReflection(
-      (value as Record<string | symbol, unknown>)[key],
-      formatIssue,
-      localizedTypeBySource,
-    );
+    const property = (value as Record<string | symbol, unknown>)[key];
+    // Configured defaults are opaque data whose identity must be preserved.
+    localized[key] =
+      key === "value" && globalThis.Object.hasOwn(value, defaultPropertySymbol)
+        ? property
+        : localizeTypeReflection(property, formatIssue, localizedTypeBySource);
   }
 
   return localized;
@@ -1678,7 +1812,8 @@ type ReflectedTypes<T extends TypeNode> =
           readonly props: infer Props extends ObjectProps;
           readonly record?: infer Rest;
         }
-      ? ObjectPropertyType<Props[keyof Props]> | Extract<Rest, TypeNode>
+      ? | DefaultableObjectPropertyType<Props[keyof Props]>
+        | Extract<Rest, TypeNode>
       : never;
 
 type RootType<T extends TypeNode> = T extends {
@@ -1845,7 +1980,42 @@ type ValidateParent<T extends ConcreteTypeNode> =
         "Parent must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes."
       >;
 
-type ValidateOutput<T extends ConcreteTypeNode> =
+/**
+ * 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<
@@ -1927,6 +2097,8 @@ type ConcreteChildTypeNameError = CompileTimeError<
  * 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:
@@ -1957,6 +2129,7 @@ type ConcreteChildTypeNameError = CompileTimeError<
  * );
  *
  * assertOk(Text.fromUnknown("Evolu"), "Evolu");
+ *
  * const invalid = Text.fromUnknown(42);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -2051,10 +2224,8 @@ export function createType(
 }
 
 const assertRefinementIdentity =
-  (
-    refinement: (value: unknown) => Result<unknown, TypeError>,
-  ): ((value: unknown) => Result<unknown, TypeError>) =>
-  (value) => {
+  (refinement: (value: unknown) => Result<unknown, TypeError>) =>
+  (value: unknown): Result<unknown, TypeError> => {
     const result = refinement(value);
     if (result.ok) {
       assert(
@@ -2065,6 +2236,70 @@ const assertRefinementIdentity =
     return result;
   };
 
+/**
+ * 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 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> =>
+  createRootType<Name, T["Output"], Error>(
+    name,
+    (value, options) => {
+      const result = type.fromUnknown(value, options);
+      return result.ok ? result : err(mapError(result.error, value));
+    },
+    formatError,
+  );
+
 const createRootType = <Name extends TypeName, Output, Error extends TypeError>(
   name: Name,
   fromUnknown: (
@@ -2581,6 +2816,16 @@ const mapRuntimeResult =
   (value: never, options = firstValidationOptions) =>
     map(operation(value, options), options);
 
+const createRuntimeOrThrow = (
+  fromInput: RuntimeOperation<Result<unknown, TypeError>>,
+  formatError: TypeErrorFormatter<TypeError>,
+): RuntimeOperation<unknown> =>
+  mapRuntimeResult(fromInput, (result) => {
+    if (result.ok) return result.value;
+
+    throw new Error(formatError(result.error), { cause: result.error });
+  });
+
 // `map` must return a fresh operation because this function can attach `.parent`.
 const mapRuntimeOperations = <Input, Output>(
   operation: RuntimeOperation<Input>,
@@ -2666,7 +2911,8 @@ const createTypeNode = <Node extends TypeNode = TypeNode>(
   const runtimeFormatError: TypeErrorFormatter<TypeError> =
     runtimeParent?.[getRuntimeTypeIssuesSymbol] === getTypeIssues
       ? runtimeParent.formatError
-      : (error) => formatIssue(getTypeIssues(error, "first")[0]);
+      : (error) =>
+          formatRuntimeTypeIssue(getTypeIssues(error, "first")[0], formatIssue);
   const typedFrom = addRuntimeAssertions(
     name,
     is,
@@ -2690,7 +2936,7 @@ const createTypeNode = <Node extends TypeNode = TypeNode>(
     is,
     from: typedFrom,
     to: typedTo,
-    orThrow: mapRuntimeResult(fromInput, getOrThrow),
+    orThrow: createRuntimeOrThrow(fromInput, runtimeFormatError),
     orNull: mapRuntimeResult(fromInput, getOrNull),
     "~standard": createStandardSchemaProps(
       fromUnknown,
@@ -2724,7 +2970,7 @@ const createStandardSchemaProps = (
       ? { value: result.value }
       : {
           issues: getTypeIssues(result.error, "all").map((issue) => ({
-            message: formatIssue(issue),
+            message: formatRuntimeTypeIssue(issue, formatIssue),
             path: issue.path,
           })),
         };
@@ -2940,6 +3186,7 @@ export const String = /*#__PURE__*/ createTypeOfType("String");
  * >();
  *
  * assertOk(Age.fromUnknown(122), 122);
+ *
  * const invalid = Age.fromUnknown(200);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -2968,6 +3215,64 @@ export const BigInt = /*#__PURE__*/ createTypeOfType("BigInt");
  */
 export const Boolean = /*#__PURE__*/ createTypeOfType("Boolean");
 
+/**
+ * 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 const BooleanFromString = /*#__PURE__*/ transform(
+  "BooleanFromString",
+  String,
+  Boolean,
+  {
+    from: (value): Result<boolean, BooleanFromStringError> =>
+      value === "true"
+        ? ok(true)
+        : value === "false"
+          ? ok(false)
+          : err({ type: "BooleanFromString", value }),
+    to: (value) => (value ? "true" : "false"),
+  },
+  (error) =>
+    `The value ${safelyStringifyUnknownValue(error.value)} is not a boolean. Use true or false.`,
+);
+
 /**
  * A JavaScript symbol {@link Type}.
  *
@@ -3142,6 +3447,7 @@ export function objectTag<Name extends keyof ObjectTagOutputByName>(
  *   "TaggedValue",
  *   instanceOf(TaggedValue),
  * );
+ *
  * const value = new TaggedValue();
  * const result = TaggedValueType.fromUnknown(value);
  *
@@ -3344,6 +3650,40 @@ type InstanceConstructorCompileTimeError = CompileTimeError<
   "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}.
  *
@@ -3372,6 +3712,7 @@ type InstanceConstructorCompileTimeError = CompileTimeError<
  *
  * assertType<typeof Ready.Output, "ready">();
  * assertOk(Ready.fromUnknown("ready"), "ready");
+ *
  * const invalid = Ready.fromUnknown("pending");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -3463,13 +3804,6 @@ type LiteralParentErrors<Expected extends Literal> =
     ? 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."
@@ -3523,6 +3857,11 @@ export const Null = /*#__PURE__*/ literal(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
@@ -3611,10 +3950,7 @@ export function union(
     inputMembers,
     (member, value, options) => member[outputValidationSymbol](value, options),
   );
-  const defaultFormatter = (() =>
-    "A value does not match any allowed variant.") as TypeErrorFormatter<TypeError>;
-  const getTypeIssues: RuntimeGetTypeIssues = (error) =>
-    singleRuntimeTypeIssue("Union", error, defaultFormatter);
+  const getTypeIssues = createUnionRuntimeTypeIssues(members);
   const input = createTypeNode<
     UnionInputType<unknown, UnionErrorValue<TypeError>>
   >(
@@ -3625,7 +3961,7 @@ export function union(
     inputValidateOutput,
     ok,
     identity,
-    getTypeIssues,
+    createUnionRuntimeTypeIssues(inputMembers),
   );
   const fromUnknown = createUnionValidation(members, (member, value, options) =>
     member.fromUnknown(value, options),
@@ -3667,6 +4003,24 @@ export function union(
   );
 }
 
+const createUnionRuntimeTypeIssues =
+  (members: ReadonlyArray<RuntimeTypeNode>): RuntimeGetTypeIssues =>
+  (error) => [
+    {
+      name: "Union",
+      error,
+      path: [],
+      formatError: () => "A value does not match any allowed variant.",
+      alternatives: (error as UnionErrorValue<TypeError>).errors.map(
+        ({ index, error }) => ({
+          index,
+          name: members[index].name,
+          issues: members[index][getRuntimeTypeIssuesSymbol](error, "all"),
+        }),
+      ),
+    },
+  ];
+
 const createUnionValidation =
   (
     members: ReadonlyArray<RuntimeTypeNode>,
@@ -4024,6 +4378,7 @@ interface UnionErrorValue<
  * assertOk(result, ["cs", "CZ"]);
  * const locale = result.value;
  * assertType<typeof locale, SupportedLocale>();
+ *
  * const invalid = SupportedLocale.fromUnknown("cs/CZ");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -4892,6 +5247,7 @@ const getTemplateLiteralPartFraming = (
  * }
  *
  * assertOk(Int64.fromUnknown(42n), 42n);
+ *
  * const invalid = Int64.fromUnknown(2n ** 63n);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -4990,6 +5346,7 @@ export interface BrandType<
  *
  * 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);
@@ -5164,6 +5521,7 @@ export interface UInt64Error extends TypeError<"UInt64"> {
  * }
  *
  * assertOk(TrimmedString.fromUnknown("Evolu"), "Evolu");
+ *
  * const invalid = TrimmedString.fromUnknown(" Evolu");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -5260,144 +5618,1147 @@ type BrandFactoryNumberError = CompileTimeError<
 >;
 
 /**
- * Capitalized {@link Brand}.
+ * Naming conventions accepted by {@link identifier}.
+ *
+ * @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.
  *
- * Requires the first character of a string to be uppercase.
+ * 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,
- *   capitalized,
- *   type Brand,
  * } from "@evolu/common";
  *
- * const CapitalizedString = capitalized(String);
- * type CapitalizedString = typeof CapitalizedString.Output;
- *
- * assertType<CapitalizedString, string & Brand<"Capitalized">>();
+ * const EnvName = identifier("CONSTANT_CASE")(maxLength(16)(String));
  *
- * assertOk(CapitalizedString.fromUnknown("Evolu"), "Evolu");
- * const invalid = CapitalizedString.fromUnknown("evolu");
- * assertErr(invalid);
- * assertType(Data, invalid.error);
- * assertEqual(invalid.error, {
- *   type: "Capitalized",
- *   value: "evolu",
- * });
+ * assertOk(EnvName.fromUnknown("HTTP2_PORT"), "HTTP2_PORT");
+ * assertErr(EnvName.fromUnknown("HTTP_2_PORT"));
  * ```
  *
  * @group String
  */
-export const capitalized: BrandFactory<
-  "Capitalized",
-  string,
-  CapitalizedError
-> = (parent) =>
-  brand(
-    "Capitalized",
-    parent,
-    (value) => {
-      const [first = ""] = value;
+export const identifier =
+  <Casing extends IdentifierCasing>(
+    casing: Casing,
+  ): BrandFactory<
+    IdentifierBrandByCasing[Casing],
+    string,
+    IdentifierError<Casing>
+  > =>
+  (parent) => {
+    const name = identifierBrandByCasing[casing];
+    const pattern = identifierPatternByCasing[casing];
 
-      return value === first.toUpperCase() + value.slice(first.length)
-        ? ok()
-        : err<CapitalizedError>({ type: "Capitalized", value });
-    },
-    (error) =>
-      `The value ${safelyStringifyUnknownValue(error.value)} must be capitalized.`,
-  );
+    return brand(
+      name,
+      parent,
+      (value) =>
+        pattern.test(value)
+          ? ok()
+          : err<IdentifierError<Casing>>({ type: name, value, casing }),
+      (error) =>
+        `The value ${safelyStringifyUnknownValue(error.value)} is not a ${error.casing} identifier.`,
+    );
+  };
 
 /**
- * Error returned when {@link capitalized} rejects a string.
+ * Error returned when {@link identifier} rejects a string.
  *
  * @group String
  */
-export interface CapitalizedError extends TypeError<"Capitalized"> {
+export interface IdentifierError<
+  Casing extends IdentifierCasing = IdentifierCasing,
+> extends TypeError<IdentifierBrandByCasing[Casing]> {
   readonly value: string;
+  readonly casing: Casing;
 }
 
+const identifierBrandByCasing: IdentifierBrandByCasing = {
+  camelCase: "CamelCaseIdentifier",
+  PascalCase: "PascalCaseIdentifier",
+  snake_case: "SnakeCaseIdentifier",
+  "kebab-case": "KebabCaseIdentifier",
+  CONSTANT_CASE: "ConstantCaseIdentifier",
+};
+
+const identifierPatternByCasing: ReadonlyRecord<IdentifierCasing, RegExp> = {
+  camelCase: /^[a-z][a-zA-Z0-9]*$/u,
+  PascalCase: /^[A-Z][a-zA-Z0-9]*$/u,
+  snake_case: /^[a-z][a-z0-9]*(?:_[a-z][a-z0-9]*)*$/u,
+  "kebab-case": /^[a-z][a-z0-9]*(?:-[a-z][a-z0-9]*)*$/u,
+  CONSTANT_CASE: /^[A-Z][A-Z0-9]*(?:_[A-Z][A-Z0-9]*)*$/u,
+};
+
 /**
- * Capitalized {@link String}.
+ * A validated camelCase identifier, such as `http2Port`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
  *
  * @group String
  */
-export const CapitalizedString = /*#__PURE__*/ capitalized(String);
-export type CapitalizedString = typeof CapitalizedString.Output;
+export const CamelCaseIdentifier =
+  /*#__PURE__*/ identifier("camelCase")(String);
+export type CamelCaseIdentifier = typeof CamelCaseIdentifier.Output;
 
 /**
- * String {@link Brand} without surrounding whitespace.
+ * A validated PascalCase identifier, such as `Http2Port`.
  *
- * ### Example
+ * See {@link identifier} for the grammar and the conversion functions.
  *
- * ```ts
+ * @group String
+ */
+export const PascalCaseIdentifier =
+  /*#__PURE__*/ identifier("PascalCase")(String);
+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 const SnakeCaseIdentifier =
+  /*#__PURE__*/ identifier("snake_case")(String);
+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 const KebabCaseIdentifier =
+  /*#__PURE__*/ identifier("kebab-case")(String);
+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 const ConstantCaseIdentifier =
+  /*#__PURE__*/ identifier("CONSTANT_CASE")(String);
+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 const camelCaseToPascalCase = (
+  value: CamelCaseIdentifier,
+): PascalCaseIdentifier =>
+  (value.charAt(0).toUpperCase() + value.slice(1)) as 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 const camelCaseToSnakeCase = (
+  value: CamelCaseIdentifier,
+): SnakeCaseIdentifier =>
+  value.replaceAll(
+    /[A-Z]/gu,
+    (letter) => `_${letter.toLowerCase()}`,
+  ) as 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 const camelCaseToKebabCase = (
+  value: CamelCaseIdentifier,
+): KebabCaseIdentifier => snakeCaseToKebabCase(camelCaseToSnakeCase(value));
+
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `http2Port` to `HTTP2_PORT`. Use {@link constantCaseToCamelCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const camelCaseToConstantCase = (
+  value: CamelCaseIdentifier,
+): ConstantCaseIdentifier =>
+  snakeCaseToConstantCase(camelCaseToSnakeCase(value));
+
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `http2Port`. Use {@link camelCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const pascalCaseToCamelCase = (
+  value: PascalCaseIdentifier,
+): CamelCaseIdentifier =>
+  (value.charAt(0).toLowerCase() + value.slice(1)) as 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 const pascalCaseToSnakeCase = (
+  value: PascalCaseIdentifier,
+): SnakeCaseIdentifier => camelCaseToSnakeCase(pascalCaseToCamelCase(value));
+
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link KebabCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `http2-port`. Use {@link kebabCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const pascalCaseToKebabCase = (
+  value: PascalCaseIdentifier,
+): KebabCaseIdentifier => snakeCaseToKebabCase(pascalCaseToSnakeCase(value));
+
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `HTTP2_PORT`. Use {@link constantCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const pascalCaseToConstantCase = (
+  value: PascalCaseIdentifier,
+): ConstantCaseIdentifier =>
+  snakeCaseToConstantCase(pascalCaseToSnakeCase(value));
+
+/**
+ * Converts a {@link SnakeCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `http2_port` to `http2Port`. Use {@link camelCaseToSnakeCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const snakeCaseToCamelCase = (
+  value: SnakeCaseIdentifier,
+): CamelCaseIdentifier =>
+  value.replaceAll(/_[a-z]/gu, (word) =>
+    word.charAt(1).toUpperCase(),
+  ) as 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 const snakeCaseToPascalCase = (
+  value: SnakeCaseIdentifier,
+): PascalCaseIdentifier => camelCaseToPascalCase(snakeCaseToCamelCase(value));
+
+/**
+ * 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 const snakeCaseToKebabCase = (
+  value: SnakeCaseIdentifier,
+): KebabCaseIdentifier => value.replaceAll("_", "-") as 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 const snakeCaseToConstantCase = (
+  value: SnakeCaseIdentifier,
+): ConstantCaseIdentifier => value.toUpperCase() as 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 const kebabCaseToCamelCase = (
+  value: KebabCaseIdentifier,
+): CamelCaseIdentifier => snakeCaseToCamelCase(kebabCaseToSnakeCase(value));
+
+/**
+ * Converts a {@link KebabCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `http2-port` to `Http2Port`. Use {@link pascalCaseToKebabCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const kebabCaseToPascalCase = (
+  value: KebabCaseIdentifier,
+): PascalCaseIdentifier => camelCaseToPascalCase(kebabCaseToCamelCase(value));
+
+/**
+ * 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 const kebabCaseToSnakeCase = (
+  value: KebabCaseIdentifier,
+): SnakeCaseIdentifier => value.replaceAll("-", "_") as 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 const kebabCaseToConstantCase = (
+  value: KebabCaseIdentifier,
+): ConstantCaseIdentifier =>
+  snakeCaseToConstantCase(kebabCaseToSnakeCase(value));
+
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `http2Port`. Use {@link camelCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const constantCaseToCamelCase = (
+  value: ConstantCaseIdentifier,
+): CamelCaseIdentifier => snakeCaseToCamelCase(constantCaseToSnakeCase(value));
+
+/**
+ * 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 const CamelCaseIdentifierFromConstantCaseIdentifier =
+  /*#__PURE__*/ transform(
+    "CamelCaseIdentifierFromConstantCaseIdentifier",
+    ConstantCaseIdentifier,
+    CamelCaseIdentifier,
+    {
+      from: (value) => ok(constantCaseToCamelCase(value)),
+      to: camelCaseToConstantCase,
+    },
+  );
+
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `Http2Port`. Use {@link pascalCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const constantCaseToPascalCase = (
+  value: ConstantCaseIdentifier,
+): PascalCaseIdentifier =>
+  camelCaseToPascalCase(constantCaseToCamelCase(value));
+
+/**
+ * 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 const constantCaseToSnakeCase = (
+  value: ConstantCaseIdentifier,
+): SnakeCaseIdentifier => value.toLowerCase() as 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 const constantCaseToKebabCase = (
+  value: ConstantCaseIdentifier,
+): KebabCaseIdentifier => snakeCaseToKebabCase(constantCaseToSnakeCase(value));
+
+/**
+ * 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,
+ *   maxLength,
+ *   String,
+ * } from "@evolu/common";
+ *
+ * const Label = capitalized(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("Hello world"), "Hello world");
+ * assertErr(Label.fromUnknown("hello world"));
+ * ```
+ *
+ * @group String
+ */
+export const capitalized = <
+  ParentType extends ConcreteTypeNode & { readonly Output: string },
+>(
+  parent: ValidateBrandParent<"Capitalized", ParentType>,
+): ReturnType<
+  typeof createType<
+    "Capitalized",
+    ParentType,
+    ParentType["Output"] & Capitalize<string>,
+    CapitalizedError
+  >
+> =>
+  createType<
+    "Capitalized",
+    ParentType,
+    ParentType["Output"] & Capitalize<string>,
+    CapitalizedError
+  >(
+    "Capitalized",
+    parent,
+    (value) =>
+      value === capitalize(value)
+        ? ok(value as ParentType["Output"] & Capitalize<string>)
+        : err({ type: "Capitalized", value }),
+    (error) =>
+      `The value ${safelyStringifyUnknownValue(error.value)} must be capitalized.`,
+  );
+
+/**
+ * Error returned when {@link capitalized} rejects a string.
+ *
+ * @group String
+ */
+export interface CapitalizedError extends TypeError<"Capitalized"> {
+  readonly value: string;
+}
+
+/**
+ * Validates capitalized text as TypeScript's `Capitalize<string>`.
+ *
+ * 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 const CapitalizedString = /*#__PURE__*/ capitalized(String);
+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 const capitalize = <S extends string>(value: S): Capitalize<S> => {
+  const [first = ""] = value;
+  return (first.toUpperCase() + value.slice(first.length)) as 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 const uncapitalized = <
+  ParentType extends ConcreteTypeNode & { readonly Output: string },
+>(
+  parent: ValidateBrandParent<"Uncapitalized", ParentType>,
+): ReturnType<
+  typeof createType<
+    "Uncapitalized",
+    ParentType,
+    ParentType["Output"] & Uncapitalize<string>,
+    UncapitalizedError
+  >
+> =>
+  createType<
+    "Uncapitalized",
+    ParentType,
+    ParentType["Output"] & Uncapitalize<string>,
+    UncapitalizedError
+  >(
+    "Uncapitalized",
+    parent,
+    (value) =>
+      value === uncapitalize(value)
+        ? ok(value as ParentType["Output"] & Uncapitalize<string>)
+        : err({ type: "Uncapitalized", value }),
+    (error) =>
+      `The value ${safelyStringifyUnknownValue(error.value)} must not start with an uppercase letter.`,
+  );
+
+/**
+ * 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 const UncapitalizedString = /*#__PURE__*/ uncapitalized(String);
+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 const uncapitalize = <S extends string>(value: S): Uncapitalize<S> => {
+  const [first = ""] = value;
+  return (first.toLowerCase() + value.slice(first.length)) as 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 const uppercased = <
+  ParentType extends ConcreteTypeNode & { readonly Output: string },
+>(
+  parent: ValidateBrandParent<"Uppercased", ParentType>,
+): ReturnType<
+  typeof createType<
+    "Uppercased",
+    ParentType,
+    ParentType["Output"] & Uppercase<string>,
+    UppercasedError
+  >
+> =>
+  createType<
+    "Uppercased",
+    ParentType,
+    ParentType["Output"] & Uppercase<string>,
+    UppercasedError
+  >(
+    "Uppercased",
+    parent,
+    (value) =>
+      value === uppercase(value)
+        ? ok(value as ParentType["Output"] & Uppercase<string>)
+        : err({ type: "Uppercased", value }),
+    (error) =>
+      `The value ${safelyStringifyUnknownValue(error.value)} must be uppercased.`,
+  );
+
+/**
+ * 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 const UppercasedString = /*#__PURE__*/ uppercased(String);
+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 const uppercase = <S extends string>(value: S): Uppercase<S> =>
+  value.toUpperCase() as 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 const lowercased = <
+  ParentType extends ConcreteTypeNode & { readonly Output: string },
+>(
+  parent: ValidateBrandParent<"Lowercased", ParentType>,
+): ReturnType<
+  typeof createType<
+    "Lowercased",
+    ParentType,
+    ParentType["Output"] & Lowercase<string>,
+    LowercasedError
+  >
+> =>
+  createType<
+    "Lowercased",
+    ParentType,
+    ParentType["Output"] & Lowercase<string>,
+    LowercasedError
+  >(
+    "Lowercased",
+    parent,
+    (value) =>
+      value === lowercase(value)
+        ? ok(value as ParentType["Output"] & Lowercase<string>)
+        : err({ type: "Lowercased", value }),
+    (error) =>
+      `The value ${safelyStringifyUnknownValue(error.value)} must be lowercased.`,
+  );
+
+/**
+ * Error returned when {@link lowercased} rejects a string.
+ *
+ * @group String
+ */
+export interface LowercasedError extends TypeError<"Lowercased"> {
+  readonly value: string;
+}
+
+/**
+ * Validates lowercased text as TypeScript's `Lowercase<string>`.
+ *
+ * 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 const LowercasedString = /*#__PURE__*/ lowercased(String);
+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 const lowercase = <S extends string>(value: S): Lowercase<S> =>
+  value.toLowerCase() as Lowercase<S>;
+
+/**
+ * String {@link Brand} without surrounding whitespace.
+ *
+ * ### Example
+ *
+ * ```ts
  * import { assertOk, String, trimmed } from "@evolu/common";
  *
- * const Trimmed = trimmed(String);
+ * const Trimmed = trimmed(String);
+ *
+ * assertOk(Trimmed.fromUnknown("Evolu"), "Evolu");
+ * ```
+ *
+ * @group String
+ */
+export const trimmed: BrandFactory<"Trimmed", string, TrimmedError> = (
+  parent,
+) =>
+  brand(
+    "Trimmed",
+    parent,
+    (value) =>
+      value === value.trim()
+        ? ok()
+        : err<TrimmedError>({ type: "Trimmed", value }),
+    (error) =>
+      `The value ${safelyStringifyUnknownValue(error.value)} must be trimmed.`,
+  );
+
+/**
+ * Error returned when {@link trimmed} rejects a string.
+ *
+ * @group String
+ */
+export interface TrimmedError extends TypeError<"Trimmed"> {
+  readonly value: string;
+}
+
+/**
+ * A {@link String} without surrounding whitespace.
+ *
+ * This Type validates that a string is already trimmed; it does not modify the
+ * value. Use {@link trim} to normalize a string. Because an empty string is
+ * valid, this Type is useful as an intermediate boundary for input controls
+ * that trim their values before domain validation. If an empty string is
+ * invalid, use {@link NonEmptyTrimmedString}.
+ *
+ * @group String
+ */
+export const TrimmedString = /*#__PURE__*/ trimmed(String);
+export type TrimmedString = typeof TrimmedString.Output;
+
+/**
+ * Trims a string and returns a {@link TrimmedString}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, trim } from "@evolu/common";
+ *
+ * assertEqual(trim("  Evolu  "), "Evolu");
+ * ```
+ *
+ * @group String
+ */
+export const trim = (value: string): TrimmedString =>
+  value.trim() as 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));
  *
- * assertOk(Trimmed.fromUnknown("Evolu"), "Evolu");
+ * 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 const trimmed: BrandFactory<"Trimmed", string, TrimmedError> = (
-  parent,
-) =>
-  brand(
-    "Trimmed",
-    parent,
-    (value) =>
-      value === value.trim()
-        ? ok()
-        : err<TrimmedError>({ type: "Trimmed", value }),
-    (error) =>
-      `The value ${safelyStringifyUnknownValue(error.value)} must be trimmed.`,
-  );
+export const startsWith = <Prefix extends string>(
+  prefix: Prefix & ValidateLiteral<Prefix>,
+): BrandFactory<`StartsWith${Prefix}`, string, StartsWithError<Prefix>> => {
+  const name = `StartsWith${prefix}` as const;
+
+  return (parent) =>
+    brand(
+      name,
+      parent,
+      (value) =>
+        value.startsWith(prefix)
+          ? ok()
+          : err<StartsWithError<Prefix>>({
+              type: name,
+              value,
+              prefix,
+            }),
+      (error) =>
+        `The value ${safelyStringifyUnknownValue(error.value)} must start with ${safelyStringifyUnknownValue(error.prefix)}.`,
+    );
+};
 
 /**
- * Error returned when {@link trimmed} rejects a string.
+ * Error returned when {@link startsWith} rejects a string.
  *
  * @group String
  */
-export interface TrimmedError extends TypeError<"Trimmed"> {
+export interface StartsWithError<
+  Prefix extends string = string,
+> extends TypeError<`StartsWith${Prefix}`> {
   readonly value: string;
+  readonly prefix: Prefix;
 }
 
 /**
- * A {@link String} without surrounding whitespace.
+ * Decodes a prefixed string with another {@link Type} and restores the prefix
+ * when encoding.
  *
- * This Type validates that a string is already trimmed; it does not modify the
- * value. Use {@link trim} to normalize a string. Because an empty string is
- * valid, this Type is useful as an intermediate boundary for input controls
- * that trim their values before domain validation. If an empty string is
- * invalid, use {@link NonEmptyTrimmedString}.
+ * 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.
  *
- * @group String
- */
-export const TrimmedString = /*#__PURE__*/ trimmed(String);
-export type TrimmedString = typeof TrimmedString.Output;
-
-/**
- * Trims a string and returns a {@link TrimmedString}.
+ * 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, trim } from "@evolu/common";
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   ConstantCaseIdentifier,
+ *   prefixed,
+ *   PortFromString,
+ *   type Port,
+ * } from "@evolu/common";
  *
- * assertEqual(trim("  Evolu  "), "Evolu");
+ * 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 const trim = (value: string): TrimmedString =>
-  value.trim() as TrimmedString;
+export 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> => {
+    // A literal prefix makes the generated names concrete and distinct.
+    const source = startsWith<Prefix>(prefix)(
+      String as ValidateBrandParent<`StartsWith${Prefix}`, typeof String>,
+    );
+
+    return transform<
+      `Prefixed${Prefix}`,
+      typeof source,
+      T,
+      typeof source.Output
+    >(
+      `Prefixed${prefix}` as ValidateChildTypeName<
+        `Prefixed${Prefix}`,
+        typeof source
+      >,
+      source,
+      type,
+      {
+        // The Input guard permits any string; concatenation establishes the prefix brand.
+        from: (value) => ok(value.slice(prefix.length) as T["Input"]),
+        to: (value) => `${prefix}${value}` as typeof source.Output,
+      },
+    );
+  };
+
+/**
+ * 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`.
@@ -5611,6 +6972,7 @@ export interface LengthError<
  * 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);
@@ -5803,7 +7165,13 @@ export const base64UrlToUint8Array = (value: Base64Url): Uint8Array =>
   base64UrlStringToUint8Array(value);
 
 /**
- * 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
  */
@@ -6593,6 +7961,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);
@@ -6657,6 +8026,68 @@ export const zeroNonNegativeInt = /*#__PURE__*/ NonNegativeInt.orThrow(0);
 export const PositiveInt = /*#__PURE__*/ positive(NonNegativeInt);
 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 const IntFromString = /*#__PURE__*/ transform(
+  "IntFromString",
+  String,
+  Int,
+  {
+    from: (value): Result<number, IntFromStringError> =>
+      /^-?\d+$/u.test(value)
+        ? ok(globalThis.Number(value))
+        : err({ type: "IntFromString", value }),
+    to: (value) =>
+      globalThis.Object.is(value, -0) ? "-0" : globalThis.String(value),
+  },
+  (error) =>
+    `The value ${safelyStringifyUnknownValue(error.value)} is not a decimal integer.`,
+);
+
 /**
  * Minimum {@link PositiveInt} value.
  *
@@ -6898,6 +8329,65 @@ export interface LessThanOrEqualToError<
   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 const Port = /*#__PURE__*/ brand(
+  "Port",
+  /*#__PURE__*/ lessThanOrEqualTo(65535)(NonNegativeInt),
+);
+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 const PortFromString = /*#__PURE__*/ transform(
+  "PortFromString",
+  IntFromString,
+  Port,
+  { from: ok, to: identity },
+);
+
 /**
  * Finite {@link Number} from zero to one, inclusive.
  *
@@ -7248,6 +8738,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);
@@ -7476,6 +8967,7 @@ export interface BetweenError<
  *
  * const UserId = brand("UserId", String);
  * const UserIds = array(UserId);
+ *
  * const result = UserIds.from.parent(["ada", "grace"]);
  *
  * assertType<
@@ -7484,6 +8976,7 @@ export interface BetweenError<
  * >();
  * assertOk(result, ["ada", "grace"]);
  * assertOk(UserIds.fromUnknown(["ada", "grace"]), ["ada", "grace"]);
+ *
  * const invalid = UserIds.fromUnknown("ada");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -9238,7 +10731,7 @@ const validateTupleItems = (
   );
 
 /**
- * Decimal digit from `"0"` to `"9"`.
+ * Decimal integer string from `"0"` to `"9"`.
  *
  * @group String
  */
@@ -9257,7 +10750,7 @@ export const Digit = /*#__PURE__*/ union(
 export type Digit = typeof Digit.Output;
 
 /**
- * Decimal digit from `"1"` to `"9"`.
+ * Decimal integer string from `"1"` to `"9"`.
  *
  * @group String
  */
@@ -9275,7 +10768,7 @@ export const Digit1To9 = /*#__PURE__*/ union(
 export type Digit1To9 = typeof Digit1To9.Output;
 
 /**
- * Decimal string from `"1"` to `"6"`.
+ * Decimal integer string from `"1"` to `"6"`.
  *
  * @group String
  */
@@ -9283,11 +10776,29 @@ export const Digit1To6 = /*#__PURE__*/ union("1", "2", "3", "4", "5", "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 const Digit1To23 = /*#__PURE__*/ union(
+export const Digit1To23: UnionType<
+  readonly [
+    typeof Digit1To9,
+    TemplateLiteralType<readonly ["1", typeof Digit]>,
+    TemplateLiteralType<
+      readonly [
+        "2",
+        UnionType<
+          readonly [
+            LiteralType<"0">,
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">,
+          ]
+        >,
+      ]
+    >,
+  ]
+> = /*#__PURE__*/ union(
   Digit1To9,
   /*#__PURE__*/ templateLiteral("1", Digit),
   /*#__PURE__*/ templateLiteral("2", /*#__PURE__*/ union("0", "1", "2", "3")),
@@ -9295,11 +10806,31 @@ export const Digit1To23 = /*#__PURE__*/ union(
 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 const Digit1To51 = /*#__PURE__*/ union(
+export 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">]>]
+    >,
+  ]
+> = /*#__PURE__*/ union(
   Digit1To9,
   /*#__PURE__*/ templateLiteral(/*#__PURE__*/ union("1", "2", "3", "4"), Digit),
   /*#__PURE__*/ templateLiteral("5", /*#__PURE__*/ union("0", "1")),
@@ -9307,22 +10838,45 @@ export const Digit1To51 = /*#__PURE__*/ union(
 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 const Digit1To99 = /*#__PURE__*/ union(
+export const Digit1To99: UnionType<
+  readonly [
+    typeof Digit1To9,
+    TemplateLiteralType<readonly [typeof Digit1To9, typeof Digit]>,
+  ]
+> = /*#__PURE__*/ union(
   Digit1To9,
   /*#__PURE__*/ templateLiteral(Digit1To9, 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 const Digit1To59 = /*#__PURE__*/ union(
+export const Digit1To59: UnionType<
+  readonly [
+    typeof Digit1To9,
+    TemplateLiteralType<
+      readonly [
+        UnionType<
+          readonly [
+            LiteralType<"1">,
+            LiteralType<"2">,
+            LiteralType<"3">,
+            LiteralType<"4">,
+            LiteralType<"5">,
+          ]
+        >,
+        typeof Digit,
+      ]
+    >,
+  ]
+> = /*#__PURE__*/ union(
   Digit1To9,
   /*#__PURE__*/ templateLiteral(
     /*#__PURE__*/ union("1", "2", "3", "4", "5"),
@@ -9645,6 +11199,7 @@ export { _Object as Object };
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -9680,6 +11235,7 @@ export { _Object as Object };
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -10290,28 +11846,389 @@ export interface OptionalProperty<T extends TypeNode> {
  * });
  * ```
  *
- * @group Objects
+ * @group Objects
+ */
+export const optional = <T extends TypeNode>(
+  type: ValidateOptionalPropertyType<T>,
+): OptionalProperty<T> => createOptionalProperty(type as T);
+
+declare const optionalPropertySymbolType: unique symbol;
+const optionalPropertySymbol: typeof optionalPropertySymbolType =
+  /*#__PURE__*/ globalThis.Symbol() as typeof optionalPropertySymbolType;
+
+const createOptionalProperty = <T extends TypeNode>(
+  type: T,
+): OptionalProperty<T> =>
+  ({
+    type,
+    [optionalPropertySymbol]: true,
+  }) as OptionalProperty<T>;
+
+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 const optional = <T extends TypeNode>(
-  type: ValidateOptionalPropertyType<T>,
-): OptionalProperty<T> => createOptionalProperty(type as T);
+export 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 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 function withDefault<
+  T extends TypeNode,
+  const Value extends NoInfer<T["Output"]>,
+>(
+  type: T & ValidateDefaultType<T>,
+  value: Value,
+): WithDefaultType<T, Value, "replace">;
+export 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">;
+export function withDefault(
+  property: TypeNode | OptionalProperty<TypeNode>,
+  value: unknown,
+  { strategy }: { readonly strategy?: string } = {},
+): TypeNode | WithDefaultProperty<TypeNode, unknown, "replace" | "preserve"> {
+  assert(
+    strategy === undefined || strategy === "preserve",
+    'withDefault strategy must be omitted or "preserve".',
+  );
+  const optionalInput = optionalPropertySymbol in property;
+  const type = (optionalInput ? property.type : property) as RuntimeTypeNode;
+  assert(
+    type.is(value),
+    `withDefault value must be an Output of ${type.name}.`,
+  );
+  const originals = new Set([
+    ...(optionalInput ? ["missing"] : []),
+    ...(type.is(null) ? ["null"] : []),
+    ...(type.is(undefined) ? ["undefined"] : []),
+  ]);
+  const supplied = createRootType(
+    "DefaultSupplied",
+    (candidate): Result<unknown, TypeError<"DefaultValue">> =>
+      (strategy === undefined && globalThis.Object.is(candidate, value)) ||
+      (candidate !== null && candidate !== undefined && type.is(candidate))
+        ? ok(candidate)
+        : err({ type: "DefaultValue" }),
+    () =>
+      "The value must be a non-nullish Output of its Type or, in replacement mode, the configured default.",
+  );
+  const defaultValue = createRootType(
+    "DefaultValue",
+    (candidate): Result<unknown, TypeError<"DefaultValue">> =>
+      type.is(candidate) &&
+      (globalThis.Object.is(candidate, value) ||
+        (Data.is(value) && Data.is(candidate) && eqData(candidate, value)))
+        ? ok(candidate)
+        : err({ type: "DefaultValue" }),
+    () => "A preserved default must equal the configured default value.",
+  );
+  const output = (strategy === undefined
+    ? supplied
+    : discriminatedUnion(
+        "defaultUsed",
+        object({ value: supplied, defaultUsed: literal(false) }),
+        object({
+          value: defaultValue,
+          defaultUsed: literal(true),
+          original: createRootType(
+            "DefaultOriginal",
+            (candidate): Result<string, TypeError<"DefaultOriginal">> =>
+              typeof candidate === "string" && originals.has(candidate)
+                ? ok(candidate)
+                : err({ type: "DefaultOriginal" }),
+            () =>
+              "The original absence must be handled by this default declaration.",
+          ),
+        }),
+      )) as unknown as RuntimeTypeNode;
+  const ownGetTypeIssues = output[getRuntimeTypeIssuesSymbol];
+  const outputWithIssues: RuntimeTypeNode = {
+    ...output,
+    [outputValidationSymbol]: (value: unknown, options?: ValidationOptions) => {
+      const result = output[outputValidationSymbol](value, options);
+      return result.ok
+        ? result
+        : err({ type: "WithDefault", outputError: result.error });
+    },
+    [getRuntimeTypeIssuesSymbol]: (error, mode) =>
+      error.type === "WithDefault" && "outputError" in error
+        ? ownGetTypeIssues(error.outputError as TypeError, mode)
+        : type[getRuntimeTypeIssuesSymbol](error, mode),
+  };
+
+  const operations: RuntimeDefaultOperations = {
+    output: outputWithIssues,
+    createObject: createDefaultObjectType,
+    partial: (type) =>
+      createOptionalProperty(
+        strategy === "preserve"
+          ? withDefault(type as unknown as typeof Unknown, value, {
+              strategy,
+            })
+          : withDefault(type as unknown as typeof Unknown, value),
+      ),
+    decode: (candidate) => {
+      const original =
+        candidate === missingDefaultValue
+          ? "missing"
+          : candidate === null
+            ? "null"
+            : candidate === undefined
+              ? "undefined"
+              : undefined;
+      const effective = original === undefined ? candidate : value;
+      return strategy === undefined
+        ? effective
+        : original === undefined
+          ? { value: effective, defaultUsed: false }
+          : { value: effective, defaultUsed: true, original };
+    },
+    encode: (candidate: unknown) => {
+      if (strategy === undefined) return candidate;
+      const preserved = candidate as Defaulted<unknown>;
+      if (!preserved.defaultUsed) return preserved.value;
+      switch (preserved.original) {
+        case "missing":
+          return missingDefaultValue;
+        case "null":
+          return null;
+        case "undefined":
+          return undefined;
+      }
+    },
+  };
 
-const optionalPropertySymbol = /*#__PURE__*/ globalThis.Symbol();
+  if (optionalInput) {
+    return {
+      type,
+      value,
+      strategy: strategy ?? "replace",
+      [defaultPropertySymbol]: operations,
+    } as unknown as WithDefaultProperty<
+      TypeNode,
+      unknown,
+      "replace" | "preserve"
+    >;
+  }
 
-const createOptionalProperty = <T extends TypeNode>(
-  type: T,
-): OptionalProperty<T> =>
-  ({
+  const fromOwn = (value: unknown) => ok(operations.decode(value));
+  const fromParent = mapRuntimeOperations(
+    type[fromSymbol],
+    (operation) => (value: never, options) =>
+      flatMapResult(operation(value, options), fromOwn),
+  );
+
+  return createTypeNode(
+    "WithDefault",
     type,
-    [optionalPropertySymbol]: true,
-  }) as OptionalProperty<T>;
+    (value, options) =>
+      flatMapResult(type.fromUnknown(value, options), fromOwn),
+    operations.output.is,
+    operations.output[outputValidationSymbol],
+    createFromOperation(fromParent),
+    operations.encode,
+    operations.output[getRuntimeTypeIssuesSymbol],
+  );
+}
 
-type ValidateOptionalPropertyType<T extends TypeNode> =
-  IsUnion<T> extends false
-    ? T extends ConcreteTypeNode
-      ? T
-      : ObjectPropertyTypeError
-    : ObjectPropertyTypeError;
+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;
+const defaultPropertySymbol: typeof defaultPropertySymbolType =
+  /*#__PURE__*/ globalThis.Symbol() as typeof defaultPropertySymbolType;
+const missingDefaultValue = /*#__PURE__*/ globalThis.Symbol();
+
+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.
@@ -10319,6 +12236,15 @@ type ValidateOptionalPropertyType<T extends TypeNode> =
  * @group Objects
  */
 export type ObjectProps = Readonly<
+  Record<
+    string,
+    | TypeNode
+    | OptionalProperty<TypeNode>
+    | WithDefaultProperty<TypeNode, unknown, "replace" | "preserve">
+  >
+>;
+
+type ObjectValueProps = Readonly<
   Record<string, TypeNode | OptionalProperty<TypeNode>>
 >;
 
@@ -10330,7 +12256,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
@@ -10418,6 +12347,7 @@ type ObjectProperty = ObjectProps[string];
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -10453,6 +12383,7 @@ type ObjectProperty = ObjectProps[string];
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -10468,7 +12399,7 @@ type ObjectProperty = ObjectProps[string];
  *
  * @group Objects
  */
-export function object<const Props extends ObjectProps>(
+export function object<const Props extends ObjectValueProps>(
   props: Props,
   ...validation: [ObjectValidationError<Props>] extends [never]
     ? []
@@ -10493,6 +12424,7 @@ export function object<const Props extends ObjectProps>(
  *   { authorization: String },
  *   record(String, String),
  * );
+ *
  * const result = RequestHeaders.fromUnknown({
  *   authorization: "Bearer token",
  *   "x-request-id": "request-1",
@@ -10506,7 +12438,7 @@ export function object<const Props extends ObjectProps>(
  * ```
  */
 export function object<
-  const Props extends ObjectProps,
+  const Props extends ObjectValueProps,
   const Rest extends RecordTypeNode & ConcreteTypeNode,
 >(
   props: Props,
@@ -10525,6 +12457,34 @@ export function object<
   Props,
   Rest extends ObjectRecordTypeNode ? Rest : never
 >;
+/** Creates an Object Type with explicit defaults for optional inputs. */
+export 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 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>;
 export function object(props: ObjectProps, recordType?: unknown): TypeNode {
   return createObjectType(
     snapshotObjectProps(props),
@@ -10537,6 +12497,14 @@ const createObjectType = (
   recordType?: RuntimeRecordTypeNode,
 ): ObjectTypeNode => {
   const runtimeProps = props as Readonly<Record<string, RuntimeObjectProperty>>;
+  const defaultProperty =
+    globalThis.Object.values(runtimeProps).find(isDefaultProperty);
+  if (defaultProperty) {
+    return defaultProperty[defaultPropertySymbol].createObject(
+      props,
+      recordType,
+    );
+  }
   const keys = globalThis.Object.keys(runtimeProps);
 
   const validate = (
@@ -10933,6 +12901,100 @@ const createObjectType = (
   );
 };
 
+const createDefaultObjectType = (
+  props: ObjectProps,
+  recordType: RuntimeRecordTypeNode | undefined,
+): ObjectTypeNode => {
+  const inputProps = createMutableRecord<string, ObjectProperty>();
+  const outputProps = createMutableRecord<string, ObjectProperty>();
+  const defaults = new Map<string, RuntimeDefaultOperations>();
+
+  for (const [key, property] of globalThis.Object.entries(props)) {
+    if (isDefaultProperty(property as RuntimeObjectProperty)) {
+      const defaultProperty = property as WithDefaultProperty<
+        TypeNode,
+        unknown,
+        "replace" | "preserve"
+      >;
+      inputProps[key] = createOptionalProperty(defaultProperty.type);
+      outputProps[key] = defaultProperty[defaultPropertySymbol].output;
+      defaults.set(key, defaultProperty[defaultPropertySymbol]);
+    } else {
+      inputProps[key] = property;
+      const type = objectPropertyToType(property as RuntimeObjectProperty);
+      const output = createRootType(
+        type.name,
+        type[outputValidationSymbol],
+        type.formatError,
+        type[getRuntimeTypeIssuesSymbol],
+      );
+      outputProps[key] =
+        optionalPropertySymbol in property
+          ? createOptionalProperty(output)
+          : output;
+    }
+  }
+
+  const source = createObjectType(
+    inputProps,
+    recordType,
+  ) as unknown as RuntimeTypeNode;
+  // The object parent validates only its input structure and root value Types.
+  const parent = getTerminalRuntimeNode(source);
+  const output = createObjectType(
+    outputProps,
+    recordType,
+  ) as unknown as RuntimeTypeNode;
+  const finish = (value: unknown): Result<unknown> => {
+    const result = createMutableRecord(
+      value as Readonly<Record<string, unknown>>,
+    );
+    for (const [key, operations] of defaults) {
+      result[key] = operations.decode(
+        globalThis.Object.hasOwn(result, key)
+          ? result[key]
+          : missingDefaultValue,
+      );
+    }
+    return ok(result);
+  };
+  const fromInput = getTerminalRuntimeNode(source[fromSymbol]);
+  const fromParent: RuntimeOperation<Result<unknown, TypeError>> = (
+    value: never,
+    options,
+  ) => flatMapResult(fromInput(value, options), finish);
+  const to = (value: never): unknown => {
+    const result = createMutableRecord(
+      value as Readonly<Record<string, unknown>>,
+    );
+    for (const [key, operations] of defaults) {
+      const original = operations.encode(result[key] as never);
+      if (original === missingDefaultValue) delete result[key];
+      else result[key] = original;
+    }
+    return source[encoderSymbol](result as never);
+  };
+
+  return createTypeNode<ObjectTypeNode>(
+    "Object",
+    parent,
+    (value, options) =>
+      flatMapResult(source.fromUnknown(value, options), finish),
+    output.is,
+    output[outputValidationSymbol],
+    createFromOperation(fromParent),
+    to,
+    createObjectRuntimeTypeIssues(
+      source.formatError,
+      props as Readonly<Record<string, RuntimeObjectProperty>>,
+      recordType,
+    ),
+    recordType
+      ? { props, record: recordType as unknown as RecordTypeNode }
+      : { props },
+  );
+};
+
 // Read descriptors instead of spreading so accessors are not invoked,
 // non-enumerable declarations are retained, and later mutations are isolated.
 const snapshotObjectProps = (
@@ -10992,9 +13054,9 @@ 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>;
@@ -11002,10 +13064,10 @@ type ObjectRecordPropertyValidationError<
 type ObjectRecordPropertyTypeError<
   Props extends ObjectProps,
   ValueType extends TypeNode,
-> = [ObjectPropertyType<Props[keyof Props]>["Input"]] extends [
+> = [DefaultableObjectPropertyType<Props[keyof Props]>["Input"]] extends [
   ValueType["Input"],
 ]
-  ? [ObjectPropertyType<Props[keyof Props]>["Output"]] extends [
+  ? [DefaultableObjectPropertyType<Props[keyof Props]>["Output"]] extends [
       ValueType["Output"],
     ]
     ? ObjectRecordCanonicalInputTypeError
@@ -11014,10 +13076,10 @@ type ObjectRecordPropertyTypeError<
 
 type ObjectPropertyValidationError<Property extends ObjectProperty> =
   IsUnion<Property> extends false
-    ? Property extends OptionalProperty<infer T extends TypeNode>
-      ? ObjectPropertyTypeValidationError<T>
-      : Property extends TypeNode
-        ? ObjectPropertyTypeValidationError<Property>
+    ? Property extends TypeNode
+      ? ObjectPropertyTypeValidationError<Property>
+      : Property extends { readonly type: infer T extends TypeNode }
+        ? ObjectPropertyTypeValidationError<T>
         : ObjectPropertyTypeError
     : ObjectPropertyTypeError;
 
@@ -11109,15 +13171,83 @@ type ObjectRecordCanonicalInputTypeError = CompileTimeError<
 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 }
+    : {});
+
 // `fromUnknown` can report Object root errors plus declared-property child,
 // missing, access, and excess/Record-rest errors. When Object has a parent, its
 // own `Error` contains only the child and rest errors remaining after that
 // parent validated the Object structure.
-type StrictObjectType<Props extends ObjectProps> = Type<
+type StrictObjectType<Props extends ObjectValueProps> = Type<
   "Object",
   StrictObjectShape<Props, "Input">,
   StrictObjectShape<Props, "Output">,
@@ -11136,7 +13266,7 @@ type StrictObjectType<Props extends ObjectProps> = Type<
 };
 
 type ObjectWithRecordType<
-  Props extends ObjectProps,
+  Props extends ObjectValueProps,
   Rest extends ObjectRecordTypeNode,
 > = Type<
   "Object",
@@ -11159,7 +13289,7 @@ type ObjectWithRecordType<
   ObjectWithRecordReflection<Props, Rest>;
 
 type StrictObjectShape<
-  Props extends ObjectProps,
+  Props extends ObjectValueProps,
   Field extends "Input" | "Output" | "CanonicalInput",
 > = keyof Props extends never
   ? Readonly<Record<string, never>>
@@ -11176,7 +13306,7 @@ type StrictObjectShape<
     };
 
 type ObjectWithRecordShape<
-  Props extends ObjectProps,
+  Props extends ObjectValueProps,
   Rest extends ObjectRecordTypeNode,
   Field extends "Input" | "Output" | "CanonicalInput",
 > = keyof Props extends never
@@ -11184,7 +13314,7 @@ type ObjectWithRecordShape<
   : ObjectDeclaredShape<Props, Field> & ObjectRestShape<Rest, Field>;
 
 type ObjectDeclaredShape<
-  Props extends ObjectProps,
+  Props extends ObjectValueProps,
   Field extends "Input" | "Output" | "CanonicalInput",
 > = Simplify<
   {
@@ -11210,25 +13340,25 @@ type ObjectTypeField<
   Field extends "Input" | "Output" | "CanonicalInput",
 > = Field extends "CanonicalInput" ? CanonicalInputOf<T> : T[Field];
 
-type RequiredObjectKeys<Props extends ObjectProps> = Exclude<
+type RequiredObjectKeys<Props extends ObjectValueProps> = Exclude<
   keyof Props,
   OptionalObjectKeys<Props>
 >;
 
-type OptionalObjectKeys<Props extends ObjectProps> = {
+type OptionalObjectKeys<Props extends ObjectValueProps> = {
   readonly [Key in keyof Props]: Props[Key] extends OptionalProperty<TypeNode>
     ? Key
     : never;
 }[keyof Props];
 
-type ObjectPropertyType<Property extends ObjectProperty> =
+type ObjectPropertyType<Property extends ObjectValueProps[string]> =
   Property extends OptionalProperty<infer T> ? T : Property;
 
-type ObjectFromParentPropertyErrors<Props extends ObjectProps> = {
+type ObjectFromParentPropertyErrors<Props extends ObjectValueProps> = {
   readonly [Key in keyof Props]: TypeFromError<ObjectPropertyType<Props[Key]>>;
 };
 
-type StrictRootObjectType<Props extends ObjectProps> = Type<
+type StrictRootObjectType<Props extends ObjectValueProps> = Type<
   "Object",
   StrictObjectShape<Props, "Input">,
   StrictObjectShape<Props, "Output">,
@@ -11243,7 +13373,7 @@ type StrictRootObjectType<Props extends ObjectProps> = Type<
 };
 
 type RootObjectWithRecordType<
-  Props extends ObjectProps,
+  Props extends ObjectValueProps,
   Rest extends ObjectRecordTypeNode,
 > = Type<
   "Object",
@@ -11258,16 +13388,16 @@ type RootObjectWithRecordType<
 > &
   ObjectWithRecordReflection<Props, Rest>;
 
-type StrictObjectParents<Props extends ObjectProps> = ObjectPropertyType<
+type StrictObjectParents<Props extends ObjectValueProps> = ObjectPropertyType<
   Props[keyof Props]
 >["parent"];
 
 type ObjectWithRecordParents<
-  Props extends ObjectProps,
+  Props extends ObjectValueProps,
   Rest extends ObjectRecordTypeNode,
 > = ObjectPropertyType<Props[keyof Props]>["parent"] | Rest["parent"];
 
-type RootObjectProps<Props extends ObjectProps> = {
+type RootObjectProps<Props extends ObjectValueProps> = {
   readonly [Key in keyof Props]: Props[Key] extends OptionalProperty<infer T>
     ? OptionalProperty<RootType<T>>
     : Props[Key] extends TypeNode
@@ -11281,20 +13411,20 @@ type RootObjectRecord<Rest extends ObjectRecordTypeNode> = RecordType<
 >;
 
 interface ObjectWithRecordReflection<
-  Props extends ObjectProps,
+  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
@@ -11474,16 +13604,31 @@ type ObjectRestFromParentError<Rest extends ObjectRecordTypeNode | undefined> =
     : never;
 
 type RuntimeObjectProperty =
-  RuntimeTypeNode | OptionalProperty<RuntimeTypeNode>;
+  | RuntimeTypeNode
+  | OptionalProperty<RuntimeTypeNode>
+  | WithDefaultProperty<RuntimeTypeNode, unknown, "replace" | "preserve">;
 
 const isOptionalProperty = (
   property: RuntimeObjectProperty,
 ): property is OptionalProperty<RuntimeTypeNode> =>
   optionalPropertySymbol in property;
 
+const isDefaultProperty = (
+  property: RuntimeObjectProperty,
+): property is WithDefaultProperty<
+  RuntimeTypeNode,
+  unknown,
+  "replace" | "preserve"
+> => defaultPropertySymbol in property;
+
 const objectPropertyToType = (
   property: RuntimeObjectProperty,
-): RuntimeTypeNode => (isOptionalProperty(property) ? property.type : property);
+): RuntimeTypeNode =>
+  isDefaultProperty(property)
+    ? property[defaultPropertySymbol].output
+    : isOptionalProperty(property)
+      ? property.type
+      : property;
 
 interface RuntimeObjectPropertyErrors {
   [key: string]: TypeError;
@@ -11501,7 +13646,8 @@ const createRecordPropertyError = <Error extends TypeError>(
  * 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
  *
@@ -11535,9 +13681,11 @@ export const partial = <const Props extends ObjectProps>(
 
   for (const key of globalThis.Object.keys(source)) {
     const property = source[key] as RuntimeObjectProperty;
-    partialProps[key] = isOptionalProperty(property)
-      ? property
-      : createOptionalProperty(property);
+    partialProps[key] = isDefaultProperty(property)
+      ? property[defaultPropertySymbol].partial(property.type)
+      : isOptionalProperty(property)
+        ? property
+        : createOptionalProperty(property);
   }
 
   return createObjectType(partialProps) as unknown as ObjectType<
@@ -11551,11 +13699,17 @@ export const partial = <const Props extends ObjectProps>(
  * @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;
 };
 
 /**
@@ -11602,7 +13756,7 @@ export const nullableToOptional = <const Props extends ObjectProps>(
   for (const key of globalThis.Object.keys(source)) {
     const property = source[key] as RuntimeObjectProperty;
 
-    if (isOptionalProperty(property)) {
+    if (isOptionalProperty(property) || isDefaultProperty(property)) {
       optionalProps[key] = property;
       continue;
     }
@@ -11661,7 +13815,10 @@ export const omit = <
   const Keys extends ReadonlyArray<keyof Props>,
   Rest extends ObjectRecordTypeNode | undefined = undefined,
 >(
-  objectType: ObjectType<Props, Rest>,
+  objectType: {
+    readonly props: Props;
+    readonly record?: Rest;
+  } & NoInfer<ObjectType<Props, Rest>>,
   ...keys: Keys &
     ([ValidateOmitKeys<Keys>] extends [never]
       ? unknown
@@ -11705,6 +13862,198 @@ type OmitKeyConcreteTypeError = CompileTimeError<
   "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 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> => {
+    const runtimeKey = key as unknown as RuntimeTypeNode;
+    const runtimeOutput = type as unknown as RuntimeTypeNode;
+    const props = createMutableRecord<string, ObjectProperty>();
+    const outputKeyByInputKey = new Map<string, string>();
+    const inputKeyByOutputKey = new Map<string, string>();
+
+    for (const outputKey of globalThis.Object.keys(type.props)) {
+      assert(
+        runtimeKey.is(outputKey),
+        `Invalid object schema key ${safelyStringifyUnknownValue(outputKey)} for ${key.name}.`,
+      );
+      const inputKey = runtimeKey.to(outputKey as never) as string;
+      assert(
+        !outputKeyByInputKey.has(inputKey),
+        `Duplicate encoded object key ${safelyStringifyUnknownValue(inputKey)}.`,
+      );
+      const decoded = runtimeKey.fromUnknown(inputKey, firstValidationOptions);
+      assert(
+        decoded.ok && decoded.value === outputKey,
+        "An object key codec must decode its encoding to the declared key.",
+      );
+      props[inputKey] = type.props[outputKey];
+      outputKeyByInputKey.set(inputKey, outputKey);
+      inputKeyByOutputKey.set(outputKey, inputKey);
+    }
+
+    const input = createObjectType(props) as unknown as RuntimeTypeNode;
+    const fromUnknown = (
+      value: unknown,
+      options = firstValidationOptions,
+    ): Result<unknown, TypeError> => {
+      const result = input.fromUnknown(value, options);
+      if (!result.ok) return err({ type: "ObjectKeys", error: result.error });
+      const output = createMutableRecord();
+      for (const [inputKey, value] of globalThis.Object.entries(
+        result.value as Record<string, unknown>,
+      )) {
+        output[outputKeyByInputKey.get(inputKey)!] = value;
+      }
+      return ok(output);
+    };
+    const to: RuntimeEncoder = (value: never) => {
+      const encoded = runtimeOutput[encoderSymbol](value) as Record<
+        string,
+        unknown
+      >;
+      const input = createMutableRecord();
+      for (const [key, value] of globalThis.Object.entries(encoded)) {
+        input[inputKeyByOutputKey.get(key)!] = value;
+      }
+      return input;
+    };
+    const validateOutput: RuntimeOutputValidation = (value, options) => {
+      const result = runtimeOutput[outputValidationSymbol](value, options);
+      return result.ok
+        ? result
+        : err({ type: "ObjectKeys", outputError: result.error });
+    };
+    const getTypeIssues: RuntimeGetTypeIssues = (error, mode) => {
+      if ("outputError" in error) {
+        return runtimeOutput[getRuntimeTypeIssuesSymbol](
+          error.outputError as TypeError,
+          mode,
+        );
+      }
+      return input[getRuntimeTypeIssuesSymbol](
+        (error as ObjectKeysError<T>).error,
+        mode,
+      );
+    };
+    return createTypeNode<ObjectKeysType<Key, T>>(
+      "ObjectKeys",
+      Unknown,
+      fromUnknown,
+      runtimeOutput.is,
+      validateOutput,
+      createFromOperation(fromUnknown),
+      to,
+      getTypeIssues,
+      { key, output: type },
+    );
+  };
+
+/**
+ * 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.
  *
@@ -11821,7 +14170,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
@@ -11880,6 +14231,7 @@ export function typed<
  * } from "@evolu/common";
  *
  * const Open = typed("Open", { label: String }, record(String, String));
+ *
  * const result = Open.fromUnknown({
  *   type: "Open",
  *   label: "Ready",
@@ -12088,6 +14440,7 @@ type TypedTypePropertyError = CompileTimeError<
  * };
  *
  * assertEqual(describeNext({ ok: true, value: "item" }), "Value: item");
+ *
  * assertEqual(
  *   describeNext({
  *     ok: false,
@@ -12095,6 +14448,7 @@ type TypedTypePropertyError = CompileTimeError<
  *   }),
  *   "Done: complete",
  * );
+ *
  * assertEqual(
  *   describeNext({
  *     ok: false,
@@ -14480,7 +16834,10 @@ export const json = <T extends ConcreteTypeNode, Name extends TypeName>(
   const BrandedJson = {
     ...typeNode,
     from,
-    orThrow: mapRuntimeResult(fromInput, getOrThrow),
+    orThrow: createRuntimeOrThrow(
+      fromInput,
+      (typeNode as unknown as RuntimeTypeNode).formatError,
+    ),
     orNull: mapRuntimeResult(fromInput, getOrNull),
   } as BrandType<typeof Json, Name, JsonTypeError>;