@evolu/common 8.9.0 → 8.10.0

package/src/Type.test.ts

@@ -15,6 +15,12 @@ import {
   assertThrowsInstanceOf,
   assertTrue,
 } from "./Assert.ts";
+import {
+  formatCapitalizedError,
+  formatUncapitalizedError,
+  formatUppercasedError,
+  formatLowercasedError,
+} from "./intl/_en.ts";
 import * as cs from "./intl/cs.ts";
 import {
   allResult,
@@ -36,15 +42,54 @@ import {
   between,
   BigInt,
   Boolean,
+  BooleanFromString,
   brand,
+  CamelCaseIdentifier,
+  CamelCaseIdentifierFromConstantCaseIdentifier,
+  camelCaseToPascalCase,
+  camelCaseToSnakeCase,
+  camelCaseToKebabCase,
+  camelCaseToConstantCase,
+  pascalCaseToCamelCase,
+  pascalCaseToSnakeCase,
+  pascalCaseToKebabCase,
+  pascalCaseToConstantCase,
+  snakeCaseToCamelCase,
+  snakeCaseToPascalCase,
+  snakeCaseToKebabCase,
+  snakeCaseToConstantCase,
+  kebabCaseToCamelCase,
+  kebabCaseToPascalCase,
+  kebabCaseToSnakeCase,
+  kebabCaseToConstantCase,
+  constantCaseToCamelCase,
+  constantCaseToPascalCase,
+  constantCaseToSnakeCase,
+  constantCaseToKebabCase,
+  ConstantCaseIdentifier,
+  identifier,
+  KebabCaseIdentifier,
+  PascalCaseIdentifier,
+  SnakeCaseIdentifier,
+  capitalize,
   capitalized,
+  uncapitalize,
+  uncapitalized,
+  uppercase,
+  uppercased,
+  lowercase,
+  lowercased,
   CapitalizedString,
+  UncapitalizedString,
+  UppercasedString,
+  LowercasedString,
   instanceOf,
   objectTag,
   createId,
   createIdAsUuidv7,
   createIdFromString,
   createType,
+  createTypeWithError,
   Data,
   Date,
   DateIso,
@@ -66,6 +111,7 @@ import {
   greaterThanOrEqualTo,
   int,
   Int,
+  IntFromString,
   Int64,
   Int64FromInt64String,
   Int64String,
@@ -121,10 +167,13 @@ import {
   Null,
   nullishOr,
   nullOr,
+  withDefault,
+  type Defaulted,
   nullableToOptional,
   Number,
   Object,
   object,
+  objectKeys,
   omit,
   onePositiveInt,
   optional,
@@ -135,12 +184,16 @@ import {
   PositiveFiniteNumber,
   PositiveInt,
   PositiveNumber,
+  Port,
+  PortFromString,
+  prefixed,
   Ratio,
   record,
   regex,
   result,
   nextResult,
   set,
+  startsWith,
   String,
   Symbol,
   SimplePassword,
@@ -174,8 +227,8 @@ import {
   type ArrayType,
   type BrandFactory,
   type BrandType,
+  type StartsWithError,
   type Base64UrlError,
-  type CapitalizedError,
   type DataError,
   type DataIssue,
   type DataType,
@@ -190,8 +243,12 @@ import {
   type ExtractTyped,
   type FiniteError,
   type GreaterThanError,
+  type IdentifierCasing,
+  type IdentifierError,
   type InferErrors,
   type InferType,
+  type TypeIssue,
+  typeErrorToIssues,
   type InstanceConstructor,
   type IsData,
   type InstanceOfError,
@@ -295,6 +352,8 @@ import {
   type UnionMemberError,
   type UnionType,
   type ValidationOptions,
+  type ValidateLiteral,
+  type ValidateOutput,
 } from "./Type.ts";
 
 const createNullRecord = <T extends object>(entries: T): T =>
@@ -463,7 +522,14 @@ describe("Type", () => {
       Base64Url,
       BigInt,
       Boolean,
+      BooleanFromString,
+      CamelCaseIdentifier,
+      CamelCaseIdentifierFromConstantCaseIdentifier,
       CapitalizedString,
+      UncapitalizedString,
+      UppercasedString,
+      LowercasedString,
+      ConstantCaseIdentifier,
       Data,
       Date,
       DateIso,
@@ -482,6 +548,7 @@ describe("Type", () => {
       Id,
       IdBytes,
       Int,
+      IntFromString,
       Int64,
       Int64FromInt64String,
       Int64String,
@@ -490,6 +557,7 @@ describe("Type", () => {
       JsonObject,
       JsonValue,
       JsonValueFromJson,
+      KebabCaseIdentifier,
       NegativeDecimalString,
       NegativeInt,
       NegativeNumber,
@@ -510,12 +578,16 @@ describe("Type", () => {
       Null,
       Number,
       Object,
+      PascalCaseIdentifier,
       PositiveDecimalString,
       PositiveFiniteNumber,
       PositiveInt,
       PositiveNumber,
+      Port,
+      PortFromString,
       Ratio,
       SimplePassword,
+      SnakeCaseIdentifier,
       String,
       Symbol,
       TrimmedString,
@@ -593,7 +665,11 @@ describe("Type", () => {
       "Between6-7",
       "BigInt",
       "Boolean",
+      "BooleanFromString",
+      "CamelCaseIdentifier",
+      "CamelCaseIdentifierFromConstantCaseIdentifier",
       "Capitalized",
+      "ConstantCaseIdentifier",
       "Data",
       "Date",
       "DateIso",
@@ -612,6 +688,7 @@ describe("Type", () => {
       "Int64",
       "Int64FromInt64String",
       "Int64String",
+      "IntFromString",
       "IntrospectionChild",
       "IntrospectionKey",
       "IntrospectionRegex",
@@ -619,13 +696,16 @@ describe("Type", () => {
       "Json",
       "JsonValue",
       "JsonValueFromJson",
+      "KebabCaseIdentifier",
       "Length16",
       "Length4",
       "LessThan200",
       "LessThan3",
       "LessThanOrEqualTo1",
       "LessThanOrEqualTo4",
+      "LessThanOrEqualTo65535",
       "Literal",
+      "Lowercased",
       "Map",
       "MaxLength100",
       "MaxLength1000",
@@ -648,12 +728,16 @@ describe("Type", () => {
       "Number",
       "NumberFromString",
       "Object",
+      "PascalCaseIdentifier",
+      "Port",
+      "PortFromString",
       "Positive",
       "PositiveDecimalString",
       "Ratio",
       "Record",
       "Set",
       "SimplePassword",
+      "SnakeCaseIdentifier",
       "String",
       "Symbol",
       "TemplateLiteral",
@@ -661,8 +745,10 @@ describe("Type", () => {
       "Tuple",
       "UInt64",
       "Uint8Array",
+      "Uncapitalized",
       "Union",
       "Unknown",
+      "Uppercased",
       "UrlSafeString",
     ] as const;
 
@@ -1076,11 +1162,108 @@ describe("Type operations", () => {
   it("map only errors returned after the typed Input boundary", () => {
     const error = { type: "Positive", value: 0 } as const;
 
-    assertAssertionError(() => PositiveNumber.orThrow(0), "getOrThrow", error);
+    assertAssertionError(
+      () => PositiveNumber.orThrow(0),
+      PositiveNumber.formatError(error),
+      error,
+    );
     assertSame(PositiveNumber.orNull(0), null);
   });
 });
 
+describe("Type.orThrow", () => {
+  it("formats a returned validation error once and preserves its identity", () => {
+    const cause = { type: "Text", value: "invalid" } as const;
+    const decode = mock.fn(() => err(cause));
+    const format = mock.fn(
+      (_error: typeof cause) => "Expected configured text.",
+    );
+    const Text = transform(
+      "Text",
+      String,
+      String,
+      {
+        from: decode,
+        to: (value) => value,
+      },
+      format,
+    );
+
+    const thrown = assertThrowsInstanceOf(() => Text.orThrow("invalid"), Error);
+
+    assertEqual(thrown.message, "Expected configured text.");
+    assertSame(thrown.cause, cause);
+    assertEqual(decode.mock.callCount(), 1);
+    assertEqual(format.mock.callCount(), 1);
+    assertSame(format.mock.calls[0]?.arguments[0], cause);
+  });
+});
+
+describe("typeErrorToIssues", () => {
+  it("formats collected errors without decoding again", () => {
+    const decode = mock.fn((value: string) => ok(value));
+    const Text = transform("Text", String, String, {
+      from: decode,
+      to: (value) => value,
+    });
+    const Model = object({ text: Text, counts: array(IntFromString) });
+    const result = Model.fromUnknown(
+      { text: "ok", counts: ["bad", "worse"] },
+      { errors: "all" },
+    );
+    assertErr(result);
+    assertEqual(typeErrorToIssues(Model, result.error), [
+      {
+        path: ["counts", 0],
+        message: 'The value "bad" is not a decimal integer.',
+      },
+      {
+        path: ["counts", 1],
+        message: 'The value "worse" is not a decimal integer.',
+      },
+    ]);
+    assertEqual(decode.mock.callCount(), 1);
+  });
+
+  it("retains root paths and only the errors collected during decoding", () => {
+    const root = String.fromUnknown(1);
+    assertErr(root);
+    const issues = typeErrorToIssues(String, root.error);
+    assertType<typeof issues, NonEmptyReadonlyArray<TypeIssue>>();
+    assertEqual(issues, [{ path: [], message: "A value 1 is not a string." }]);
+    const Values = array(IntFromString);
+    const result = Values.fromUnknown(["bad", "worse"]);
+    assertErr(result);
+    assertEqual(typeErrorToIssues(Values, result.error), [
+      { path: [0], message: 'The value "bad" is not a decimal integer.' },
+    ]);
+  });
+
+  it("uses localized messages for nested issues", () => {
+    const Model = object({ labels: array(minLength(1)(String)) });
+    const LocalizedModel = localizeTypes(
+      { Model },
+      {
+        cs: {
+          Array: cs.formatArrayError,
+          MinLength1: cs.formatMinLengthError,
+          Object: cs.formatObjectError,
+          String: cs.formatStringError,
+        },
+      },
+    ).cs.Model;
+    const result = LocalizedModel.fromUnknown(
+      { labels: [1, ""] },
+      { errors: "all" },
+    );
+    assertErr(result);
+    assertEqual(typeErrorToIssues(LocalizedModel, result.error), [
+      { path: ["labels", 0], message: "Hodnota 1 musí být text." },
+      { path: ["labels", 1], message: "Text nesmí být prázdný." },
+    ]);
+  });
+});
+
 describe("Standard Schema", () => {
   it("infers the exact Input and Output", () => {
     const _NumberFromString = setupNumberFromString();
@@ -1302,7 +1485,11 @@ describe("Standard Schema", () => {
     assertEqual(result, {
       issues: [
         {
-          message: "A value does not match any allowed variant.",
+          message: [
+            "A value does not match any allowed variant.",
+            "- 0: String: A value null is not a string.",
+            "- 1: Number: A value null is not a number.",
+          ].join("\n"),
           path: ["value"],
         },
       ],
@@ -1702,6 +1889,158 @@ describe("localizeTypes", () => {
     );
   });
 
+  it("preserves configured defaults while localizing their Types", () => {
+    const defaultValue = { enabled: true };
+    const Selected = createType(
+      "Selected",
+      (value): Result<typeof defaultValue, TypeError<"Selected">> =>
+        value === defaultValue ? ok(defaultValue) : err({ type: "Selected" }),
+      () => "Expected the selected object.",
+    );
+    const Model = object({
+      replaced: withDefault(optional(Selected), defaultValue),
+      preserved: withDefault(optional(Selected), defaultValue, {
+        strategy: "preserve",
+      }),
+    });
+    const formatters = {
+      test: {
+        Object: () => "Localized Object.",
+        Selected: () => "Localized Selected.",
+      },
+    };
+    const localized = localizeTypes({ Model, Selected }, formatters).test;
+
+    for (const types of [
+      localized,
+      localizeTypes(localized, formatters).test,
+    ]) {
+      for (const property of [
+        types.Model.props.replaced,
+        types.Model.props.preserved,
+      ]) {
+        assertSame(property.value, defaultValue);
+        assertSame(property.type, types.Selected);
+        assertTrue(property.type.is(property.value));
+      }
+
+      const Reconstructed = object(types.Model.props);
+      const decoded = Reconstructed.orThrow({});
+      assertSame(decoded.replaced, defaultValue);
+      assertSame(decoded.preserved.value, defaultValue);
+      assertEqual(Reconstructed.to(decoded), { replaced: defaultValue });
+
+      const invalid = Reconstructed.fromUnknown({ replaced: {} });
+      assertErr(invalid);
+      assertEqual(
+        Reconstructed.formatError(invalid.error),
+        "Localized Selected.",
+      );
+    }
+  });
+
+  it("keeps configured default data opaque", () => {
+    const cyclicObject: { self?: unknown } = {};
+    cyclicObject.self = cyclicObject;
+    const cyclicArray: Array<unknown> = [];
+    cyclicArray.push(cyclicArray);
+    const accessor = globalThis.Object.defineProperty({}, "value", {
+      enumerable: true,
+      get: () => {
+        throw new Error("A default getter must not be read.");
+      },
+    });
+
+    for (const defaultValue of [
+      cyclicObject,
+      cyclicArray,
+      accessor,
+      String,
+      { "~evolu/instance": "Type" },
+    ]) {
+      const Model = object({
+        replaced: withDefault(optional(Unknown), defaultValue),
+        preserved: withDefault(optional(Unknown), defaultValue, {
+          strategy: "preserve",
+        }),
+      });
+      const localized = localizeTypes(
+        { Model },
+        { test: { Object: () => "Localized Object." } },
+      ).test.Model;
+
+      assertSame(localized.props.replaced.value, defaultValue);
+      assertSame(localized.props.preserved.value, defaultValue);
+      const decoded = localized.orThrow({});
+      assertSame(decoded.replaced, defaultValue);
+      assertSame(decoded.preserved.value, defaultValue);
+      const encoded = localized.to(decoded);
+      assertSame(encoded.replaced, defaultValue);
+      assertFalse(globalThis.Object.hasOwn(encoded, "preserved"));
+    }
+  });
+
+  it("retains localized errors when making defaulted properties partial", () => {
+    const Model = object({
+      replaced: withDefault(optional(Boolean), true),
+      preserved: withDefault(optional(Boolean), true, {
+        strategy: "preserve",
+      }),
+      ordinary: optional(Boolean),
+    });
+    const first = localizeTypes(
+      { Model },
+      {
+        test: {
+          Boolean: () => "First Boolean.",
+          Object: () => "First Object.",
+        },
+      },
+    ).test.Model;
+    const second = localizeTypes(
+      { Model: first },
+      {
+        test: {
+          Boolean: () => "Second Boolean.",
+          Object: () => "Second Object.",
+        },
+      },
+    ).test.Model;
+
+    for (const [model, message] of [
+      [first, "First Boolean."],
+      [second, "Second Boolean."],
+    ] as const) {
+      const Partial = partial(model.props);
+      const input = { replaced: "bad", preserved: "bad", ordinary: "bad" };
+      const result = Partial.fromUnknown(input, { errors: "all" });
+      assertErr(result);
+      const issues = ["replaced", "preserved", "ordinary"].map((key) => ({
+        path: [key],
+        message,
+      }));
+      assertEqual(typeErrorToIssues(Partial, result.error), issues);
+      assertEqual(Partial.formatError(result.error), message);
+      assertEqual(Partial["~standard"].validate(input), { issues });
+      assertSame(Partial.props.replaced.type.parent, model.props.replaced.type);
+      assertSame(
+        Partial.props.preserved.type.parent,
+        model.props.preserved.type,
+      );
+
+      assertOk(Partial.fromUnknown({}), {});
+      assertEqual(Partial.to({}), {});
+      const supplied = { replaced: false, preserved: false, ordinary: false };
+      const decoded = Partial.orThrow(supplied);
+      assertEqual(decoded, {
+        replaced: false,
+        preserved: { value: false, defaultUsed: false },
+        ordinary: false,
+      });
+      assertEqual(Partial.to(decoded), supplied);
+    }
+  });
+
   it("preserves localized child errors when composed afterward", async () => {
     const LocalizedString = localizeTypes(
       { String },
@@ -1832,6 +2171,11 @@ describe("localizeTypes", () => {
     assertEqual(types.Strings.to(["Evolu"]), ["Evolu"]);
 
     const positiveError = { type: "Positive", value: 0 } as const;
+    assertAssertionError(
+      () => types.PositiveNumber.orThrow(0),
+      "Localized Positive.",
+      positiveError,
+    );
     for (const operation of [
       () => types.PositiveNumber.from(0 as PositiveNumber),
       () => types.PositiveNumber.to(0 as PositiveNumber),
@@ -1960,7 +2304,7 @@ describe("localizeTypes", () => {
     >();
   });
 
-  it("lets a Union own its complete failure and localizes its members", () => {
+  it("localizes a Union summary and its retained member failures", () => {
     const Value = union(String, Number);
     const types = localizeTypes(
       { Value },
@@ -1976,7 +2320,10 @@ describe("localizeTypes", () => {
     const stringResult = types.Value.members[0].fromUnknown(1);
 
     assertErr(result);
-    assertEqual(types.Value.formatError(result.error), "Localized Union.");
+    assertEqual(
+      types.Value.formatError(result.error),
+      "Localized Union.\n- 0: String: Localized String.",
+    );
     assertFalse(globalThis.Object.is(types.Value.members[0], String));
     assertFalse(globalThis.Object.is(types.Value.members[1], Number));
     assertErr(stringResult);
@@ -2003,6 +2350,49 @@ describe("localizeTypes", () => {
     >();
   });
 
+  it("localizes nested Union details and can localize the result again", async () => {
+    const Value = object({
+      field: union(object({ count: union(String, Number) }), Null),
+    });
+    const localized = localizeTypes(
+      { Value },
+      {
+        first: {
+          Object: () => "Object one.",
+          String: () => "String one.",
+          Number: () => "Number one.",
+          Literal: () => "Literal one.",
+          Union: () => "Union one.",
+        },
+      },
+    ).first;
+    const second = localizeTypes(localized, {
+      second: {
+        Object: () => "Object two.",
+        String: () => "String two.",
+        Number: () => "Number two.",
+        Literal: () => "Literal two.",
+        Union: () => "Union two.",
+      },
+    }).second;
+    const input = { field: { count: false } };
+    const result = second.Value.fromUnknown(input, { errors: "all" });
+    assertErr(result);
+    const message = [
+      "Union two.",
+      '- 0: Object["count"]: Union two.',
+      "  - 0: String: String two.",
+      "  - 1: Number: Number two.",
+      "- 1: Literal: Literal two.",
+    ].join("\n");
+    const issues = [{ path: ["field"], message }];
+    assertEqual(second.Value.formatError(result.error), message);
+    assertEqual(typeErrorToIssues(second.Value, result.error), issues);
+    assertEqual(await second.Value["~standard"].validate(input), { issues });
+    assertFalse(localized.Value.formatError(result.error).includes("two."));
+    assertFalse(Value.formatError(result.error).includes("two."));
+  });
+
   it("localizes TemplateLiteral captures and their reflected Tuple", () => {
     const Part = literal("a");
     const Value = templateLiteralParser(Part);
@@ -3191,6 +3581,149 @@ describe("createType", () => {
   });
 });
 
+describe("createTypeWithError", () => {
+  it("delegates validation and error collection without callback options", () => {
+    const Syntax = object({ name: String, count: Number });
+    interface ModelError extends TypeError<"Model"> {
+      readonly cause: InferErrors<typeof Syntax>;
+      readonly value: unknown;
+    }
+    const mapError = mock.fn(
+      (cause: InferErrors<typeof Syntax>, value: unknown): ModelError => ({
+        type: "Model",
+        cause,
+        value,
+      }),
+    );
+    const Model = createTypeWithError("Model", Syntax, mapError, (error) => {
+      assertType<typeof error, ModelError>();
+      return "Invalid model.";
+    });
+    assertType<typeof Model.Input, typeof Syntax.Output>();
+    assertType<typeof Model.Output, typeof Syntax.Output>();
+    assertType<typeof Model.CanonicalInput, typeof Syntax.Output>();
+    assertType<InferErrors<typeof Model>, ModelError>();
+    assertType<typeof Model.parent, null>();
+    assertSame(Model.parent, null);
+
+    const valid = { name: "Evolu", count: 1 };
+    for (const result of [Model.fromUnknown(valid), Model.from(valid)]) {
+      assertOk(result);
+      assertSame(result.value, valid);
+    }
+    assertSame(Model.to(valid), valid);
+    assertSame(Model.orThrow(valid), valid);
+    assertSame(Model.orNull(valid), valid);
+    assertTrue(Model.is(valid));
+    assertType(Model, valid);
+    assertEqual(Model["~standard"].validate(valid), { value: valid });
+    assertSame(mapError.mock.callCount(), 0);
+
+    const invalid = { name: 1, count: "bad" };
+    for (const options of [
+      undefined,
+      { errors: "first" },
+      { errors: "all" },
+    ] as const) {
+      const result = Model.fromUnknown(invalid, options);
+      const source = Syntax.fromUnknown(invalid, options);
+      assertErr(result);
+      assertErr(source);
+      assertEqual(result.error, {
+        type: "Model",
+        cause: source.error,
+        value: invalid,
+      });
+      assertSame(result.error.value, invalid);
+      assertEqual(Model.formatError(result.error), "Invalid model.");
+      assertEqual(typeErrorToIssues(Model, result.error), [
+        { path: [], message: "Invalid model." },
+      ]);
+    }
+    assertFalse(Model.is(invalid));
+    const standard = Model["~standard"].validate(invalid);
+    assertEqual(standard, {
+      issues: [{ path: [], message: "Invalid model." }],
+    });
+    const collected = mapError.mock.calls.at(-1)!.arguments[0];
+    assertEqual(collected, {
+      type: "Object",
+      reason: {
+        kind: "Properties",
+        errors: {
+          name: { type: "TypeOf", expected: "String", value: 1 },
+          count: { type: "TypeOf", expected: "Number", value: "bad" },
+        },
+      },
+    });
+    assertAssertionError(
+      () =>
+        Model.from(invalid as unknown as typeof Model.Output, {
+          errors: "all",
+        }),
+      "Expected Model.",
+      { type: "Model", cause: collected, value: invalid },
+    );
+  });
+
+  it("preserves all alternatives inside localized structural Types", () => {
+    const Value = createTypeWithError(
+      "Value",
+      union(String, Number),
+      (cause) => ({ type: "Value" as const, cause }),
+      () => "Invalid value.",
+    );
+    const { custom } = localizeTypes(
+      { Settings: object({ value: Value }) },
+      { custom: { Object: () => "Object.", Value: () => "Custom value." } },
+    );
+    const result = custom.Settings.fromUnknown(
+      { value: false },
+      { errors: "all" },
+    );
+    assertErr(result);
+    assertTrue(result.error.reason.kind === "Properties");
+    const error = result.error.reason.errors.value;
+    assertTrue(error?.type === "Value");
+    assertEqual(error.cause.errors.length, 2);
+    assertEqual(typeErrorToIssues(custom.Settings, result.error), [
+      { path: ["value"], message: "Custom value." },
+    ]);
+  });
+
+  it("rejects transforming sources and incompatible error names", () => {
+    const compileTimeAssertions = (
+      uncertain: typeof String | typeof Number,
+    ) => {
+      createTypeWithError(
+        "Value",
+        // @ts-expect-error Source Type must use identity encoding.
+        BooleanFromString,
+        (cause) => ({ type: "Value" as const, cause }),
+        () => "Invalid value.",
+      );
+      createTypeWithError(
+        "Value",
+        // @ts-expect-error Output Type must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
+        uncertain,
+        (cause) => ({ type: "Value" as const, cause }),
+        () => "Invalid value.",
+      );
+      createTypeWithError(
+        "Value",
+        String,
+        // @ts-expect-error The mapped error discriminant must match the Type name "Value".
+        () => ({ type: "Other" as const }),
+        () => "Invalid value.",
+      );
+    };
+    assertType<
+      typeof compileTimeAssertions,
+      (uncertain: typeof String | typeof Number) => void
+    >();
+  });
+});
+
 describe("transform", () => {
   it("creates a Type between encoded and output Types", () => {
     const NumberFromString = setupNumberFromString();
@@ -4432,7 +4965,47 @@ describe("instanceOf", () => {
   });
 });
 
+it("ValidateOutput accepts concrete Types and rejects unions of Type nodes", () => {
+  const defineOutput = <T extends AnyType>(type: T & ValidateOutput<T>): T =>
+    type;
+  const Value = union(String, Number);
+  assertSame(defineOutput(Value), Value);
+  assertType<ValidateOutput<typeof String>, typeof String>();
+  assertType<ValidateOutput<typeof Value>, typeof Value>();
+  const uncertain = String as typeof String | typeof Number;
+  const reject = () => {
+    // @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);
+  };
+  assertType<typeof reject, () => void>();
+});
+
 describe("literal", () => {
+  it("exposes its compile-time literal guard for other factories", () => {
+    assertType<ValidateLiteral<"APP_">, "APP_">();
+    assertType<ValidateLiteral<42>, 42>();
+    assertType<ValidateLiteral<42n>, 42n>();
+    assertType<ValidateLiteral<true>, true>();
+    assertType<ValidateLiteral<null>, null>();
+    assertType<ValidateLiteral<undefined>, undefined>();
+
+    const definePrefix = <Prefix extends string>(
+      prefix: Prefix & ValidateLiteral<Prefix>,
+    ): Prefix => prefix;
+    assertEqual(definePrefix("APP_"), "APP_");
+    const reject = () => {
+      // @ts-expect-error Expected must be one concrete literal value.
+      definePrefix("APP_" as string);
+      // @ts-expect-error Expected must be one concrete literal value.
+      definePrefix("APP_" as "APP_" | "OTHER_");
+      // @ts-expect-error Expected must be one concrete literal value.
+      definePrefix(TrimmedString.orThrow("APP_"));
+      // @ts-expect-error Expected must be one concrete literal value.
+      definePrefix("APP_" as `APP_${string}`);
+    };
+    assertType<typeof reject, () => void>();
+  });
+
   const Hello = literal("Hello");
 
   it("creates a Literal Type with its primitive Type as parent", () => {
@@ -4494,7 +5067,10 @@ describe("literal", () => {
 
     assertEqual(Hello.orThrow("Hello"), "Hello");
     const error = assertThrowsInstanceOf(() => Hello.orThrow("World"), Error);
-    assertTrue(error.message.includes("getOrThrow"));
+    assertEqual(
+      error.message,
+      Hello.formatError({ type: "Literal", expected: "Hello", value: "World" }),
+    );
     assertEqual(Hello.orNull("Hello"), "Hello");
     assertSame(Hello.orNull("World"), null);
   });
@@ -5094,7 +5670,7 @@ describe("union", () => {
     }
   });
 
-  it("formats one message without enumerating member errors", () => {
+  it("formats retained member errors in one message", () => {
     const result = StringOrNumber.fromUnknown(true, { errors: "all" });
 
     assertErr(result, {
@@ -5113,7 +5689,11 @@ describe("union", () => {
 
     assertEqual(
       StringOrNumber.formatError(result.error),
-      "A value does not match any allowed variant.",
+      [
+        "A value does not match any allowed variant.",
+        "- 0: String: A value true is not a string.",
+        "- 1: Number: A value true is not a number.",
+      ].join("\n"),
     );
     assertType<
       Parameters<typeof StringOrNumber.formatError>[0],
@@ -5121,6 +5701,120 @@ describe("union", () => {
     >();
   });
 
+  describe("error reporting", () => {
+    it("formats only retained failures without validating again", () => {
+      let calls = 0;
+      const Counted = brand(
+        "Counted",
+        String,
+        (): Result<void, TypeError<"Counted">> => {
+          calls++;
+          return err({ type: "Counted" });
+        },
+        () => "Counted failure.",
+      );
+      const Value = undefinedOr(Counted);
+      const result = Value.fromUnknown("invalid");
+      assertErr(result);
+      const expected =
+        "A value does not match any allowed variant.\n- 0: Counted: Counted failure.";
+
+      assertEqual(Value.formatError(result.error), expected);
+      assertEqual(typeErrorToIssues(Value, result.error), [
+        { path: [], message: expected },
+      ]);
+      assertEqual(calls, 1);
+
+      const thrown = assertThrowsInstanceOf(
+        () => Value.orThrow("invalid"),
+        Error,
+      );
+      assertEqual(thrown.message, expected);
+      assertEqual(thrown.cause, result.error);
+      assertEqual(calls, 2);
+    });
+
+    it("keeps nested alternatives inside one issue at the enclosing path", async () => {
+      const Value = object({
+        config: union(
+          object({ ports: array(undefinedOr(PortFromString)) }),
+          Null,
+        ),
+      });
+      const input = { config: { ports: ["65536"] } };
+      const result = Value.fromUnknown(input, { errors: "all" });
+      assertErr(result);
+      const issues = typeErrorToIssues(Value, result.error);
+      assertLength(issues, 1);
+      assertEqual(issues[0].path, ["config"]);
+      assertTrue(
+        issues[0].message.includes(
+          '- 0: Object["ports"][0]: A value does not match any allowed variant.\n  - 0: PortFromString:',
+        ),
+      );
+      assertTrue(
+        issues[0].message.includes(
+          "The value 65536 must be less than or equal to 65535.",
+        ),
+      );
+      assertEqual(Value.formatError(result.error), issues[0].message);
+      assertEqual(await Value["~standard"].validate(input), { issues });
+    });
+
+    it("renders symbol member paths without adding them to the union path", () => {
+      const Value = union(object({}), Null);
+      const result = Value.fromUnknown({
+        [globalThis.Symbol.for("setting")]: "bad",
+      });
+      assertErr(result);
+      const issues = typeErrorToIssues(Value, result.error);
+      assertLength(issues, 1);
+      assertEqual(issues[0].path, []);
+      assertTrue(issues[0].message.includes("- 0: Object[Symbol(setting)]:"));
+    });
+
+    it("uses the correct member pipeline at parent boundaries", () => {
+      const Value = undefinedOr(PortFromString);
+      const input = Value.parent.fromUnknown(42);
+      assertErr(input);
+      assertEqual(
+        Value.parent.formatError(input.error),
+        [
+          "A value does not match any allowed variant.",
+          "- 0: String: A value 42 is not a string.",
+        ].join("\n"),
+      );
+
+      const remaining = Value.from.parent("65536", { errors: "all" });
+      assertErr(remaining);
+      assertEqual(
+        Value.formatError(remaining.error),
+        [
+          "A value does not match any allowed variant.",
+          "- 0: PortFromString: The value 65536 must be less than or equal to 65535.",
+        ].join("\n"),
+      );
+    });
+
+    it("preserves specific failures through nullish defaults", () => {
+      for (const Value of [
+        withDefault(nullOr(PortFromString), Port.orThrow(4000)),
+        withDefault(undefinedOr(PortFromString), Port.orThrow(4000)),
+        withDefault(nullishOr(PortFromString), Port.orThrow(4000)),
+      ]) {
+        const error = assertThrowsInstanceOf(
+          () => Value.orThrow("65536"),
+          Error,
+        );
+        assertTrue(
+          error.message.includes(
+            "The value 65536 must be less than or equal to 65535.",
+          ),
+        );
+      }
+    });
+  });
+
   it("cannot fail when one member is infallible", () => {
     const StringOrUnknown = union(String, Unknown);
     const result = StringOrUnknown.fromUnknown(true);
@@ -5378,7 +6072,13 @@ describe("union", () => {
     );
     assertSame(Value.orNull(input), null);
     const error = assertThrowsInstanceOf(() => Value.orThrow(input), Error);
-    assertTrue(error.message.includes("getOrThrow"));
+    assertEqual(
+      error.message,
+      [
+        "A value does not match any allowed variant.",
+        '- 0: Literal: The value "World" is not strictly equal to the expected literal: Hello.',
+      ].join("\n"),
+    );
   });
 
   it("validates only the remaining Type after a validated Union through from.parent", () => {
@@ -7080,7 +7780,7 @@ describe("brand", () => {
       assertType<typeof value, typeof Label.Output>();
       assertType<Parameters<typeof Label.orThrow>[0], typeof Label.Input>();
       validations.length = 0;
-      assertAssertionError(() => Label.orThrow(" value "), "getOrThrow", {
+      assertAssertionError(() => Label.orThrow(" value "), "TrimmedString", {
         type: "TrimmedString",
         value: " value ",
       });
@@ -7357,22 +8057,301 @@ describe("brand", () => {
   });
 });
 
-describe("BrandFactory", () => {
-  interface NonEmptyError extends TypeError<"NonEmpty"> {
-    readonly value: { readonly length: number };
+describe("Text casing", () => {
+  const cases = [
+    {
+      type: CapitalizedString,
+      convert: capitalize,
+      input: "hello WORLD",
+      expected: "Hello WORLD",
+      description: "capitalized",
+    },
+    {
+      type: UncapitalizedString,
+      convert: uncapitalize,
+      input: "Hello WORLD",
+      expected: "hello WORLD",
+      description: "uncapitalized",
+    },
+    {
+      type: UppercasedString,
+      convert: uppercase,
+      input: "hello World",
+      expected: "HELLO WORLD",
+      description: "uppercased",
+    },
+    {
+      type: LowercasedString,
+      convert: lowercase,
+      input: "Hello WORLD",
+      expected: "hello world",
+      description: "lowercased",
+    },
+  ] as const;
+
+  for (const { type, convert, input, expected, description } of cases) {
+    it(`validates ${description} text without changing it`, () => {
+      assertOk(type.fromUnknown(expected), expected);
+      assertOk(type.from.parent(expected), expected);
+      assertEqual(type.to("123"), "123");
+      assertErr(type.fromUnknown(input), { type: type.name, value: input });
+      assertErr(type.fromUnknown(123), {
+        type: "TypeOf",
+        expected: "String",
+        value: 123,
+      });
+      for (const value of ["", "123", "😀", " ", "\uD800", "\uDC00"]) {
+        assertOk(type.fromUnknown(value), value);
+        assertEqual(convert(value), value);
+      }
+      assertEqual(convert(input), expected);
+      assertEqual(convert(expected), expected);
+    });
   }
 
-  const createNonEmpty = () => {
-    const validations: Array<{ readonly length: number }> = [];
-    const nonEmpty: BrandFactory<
-      "NonEmpty",
-      { readonly length: number },
-      NonEmptyError
-    > = (parent) =>
-      brand(
-        "NonEmpty",
-        parent,
-        (value) => {
+  it("uses intrinsic types and accepts known literals directly", () => {
+    assertType<CapitalizedString, Capitalize<string>>();
+    assertType<UncapitalizedString, Uncapitalize<string>>();
+    assertType<UppercasedString, Uppercase<string>>();
+    assertType<LowercasedString, Lowercase<string>>();
+    assertType<ReturnType<typeof capitalize>, Capitalize<string>>();
+    assertType<ReturnType<typeof uncapitalize>, Uncapitalize<string>>();
+    assertType<ReturnType<typeof uppercase>, Uppercase<string>>();
+    assertType<ReturnType<typeof lowercase>, Lowercase<string>>();
+    const title: CapitalizedString = "Hello world";
+    const sentence: UncapitalizedString = "hello WORLD";
+    const shout: UppercasedString = "HELLO WORLD";
+    const quiet: LowercasedString = "hello world";
+    assertOk(CapitalizedString.fromUnknown(title), title);
+    assertOk(UncapitalizedString.fromUnknown(sentence), sentence);
+    assertOk(UppercasedString.fromUnknown(shout), shout);
+    assertOk(LowercasedString.fromUnknown(quiet), quiet);
+    // @ts-expect-error A lowercase initial does not satisfy Capitalize<string>.
+    const _title: CapitalizedString = "hello";
+    // @ts-expect-error An uppercase initial does not satisfy Uncapitalize<string>.
+    const _sentence: UncapitalizedString = "Hello";
+    // @ts-expect-error A lowercase character does not satisfy Uppercase<string>.
+    const _shout: UppercasedString = "HELLo";
+    // @ts-expect-error An uppercase character does not satisfy Lowercase<string>.
+    const _quiet: LowercasedString = "hellO";
+  });
+
+  it("infers converted literals, unions, and runtime strings", () => {
+    const capital = capitalize("hello");
+    const uncapital = uncapitalize("Hello");
+    const upper = uppercase("hello");
+    const lower = lowercase("HELLO");
+    assertType<typeof capital, "Hello">();
+    assertType<typeof uncapital, "hello">();
+    assertType<typeof upper, "HELLO">();
+    assertType<typeof lower, "hello">();
+    assertEqual(
+      [capital, uncapital, upper, lower],
+      ["Hello", "hello", "HELLO", "hello"],
+    );
+
+    for (const value of ["hello", "WORLD"] as const) {
+      const capital = capitalize(value);
+      const uncapital = uncapitalize(value);
+      const upper = uppercase(value);
+      const lower = lowercase(value);
+      assertType<typeof capital, "Hello" | "WORLD">();
+      assertType<typeof uncapital, "hello" | "wORLD">();
+      assertType<typeof upper, "HELLO" | "WORLD">();
+      assertType<typeof lower, "hello" | "world">();
+    }
+
+    const value = String.orThrow("Hello");
+    const runtimeCapital = capitalize(value);
+    const runtimeUncapital = uncapitalize(value);
+    const runtimeUpper = uppercase(value);
+    const runtimeLower = lowercase(value);
+    assertType<typeof runtimeCapital, Capitalize<string>>();
+    assertType<typeof runtimeUncapital, Uncapitalize<string>>();
+    assertType<typeof runtimeUpper, Uppercase<string>>();
+    assertType<typeof runtimeLower, Lowercase<string>>();
+
+    const astralCapital = capitalize("𐐨x");
+    const astralUncapital = uncapitalize("𐐀X");
+    const expandedUpper = uppercase("ß");
+    const expandedLower = lowercase("İ");
+    assertType<typeof astralCapital, "𐐀x">();
+    assertType<typeof astralUncapital, "𐐨X">();
+    assertType<typeof expandedUpper, "SS">();
+    assertType<typeof expandedLower, "i\u0307">();
+    assertEqual(
+      [astralCapital, astralUncapital, expandedUpper, expandedLower],
+      ["𐐀x", "𐐨X", "SS", "i\u0307"],
+    );
+  });
+
+  it("matches TS7 Unicode mappings and handles expansions and uncased initials", () => {
+    assertType<Capitalize<"𐐨x">, "𐐀x">();
+    assertType<Uncapitalize<"𐐀X">, "𐐨X">();
+    assertType<Uppercase<"ß">, "SS">();
+    assertType<Lowercase<"İ">, "i\u0307">();
+    // @ts-expect-error A lowercase astral initial does not satisfy Capitalize<string>.
+    const _lowerAstral: CapitalizedString = "𐐨x";
+    // @ts-expect-error An uppercase astral initial does not satisfy Uncapitalize<string>.
+    const _upperAstral: UncapitalizedString = "𐐀x";
+    assertEqual(capitalize("𐐨x"), "𐐀x");
+    assertEqual(uncapitalize("𐐀X"), "𐐨X");
+    assertEqual(capitalize("ßabc"), "SSabc");
+    assertEqual(uncapitalize("İABC"), "i\u0307ABC");
+    assertEqual(uppercase("Straße"), "STRASSE");
+    assertEqual(lowercase("ΟΣ"), "ος");
+    assertEqual(capitalize("e\u0301clair"), "E\u0301clair");
+    assertEqual(uncapitalize("E\u0301CLAIR"), "e\u0301CLAIR");
+    for (const { type, convert } of cases) {
+      for (const input of [
+        "𐐨𐐀",
+        "ßİ",
+        "ffile",
+        "Džuro",
+        "ΟΣ",
+        "😀hello",
+        " hello",
+        "1ABC",
+        "\uD800x",
+        "\uDC00X",
+      ]) {
+        const output = convert(input);
+        assertTrue(type.is(output));
+        assertEqual(convert(output), output);
+      }
+    }
+    assertOk(CapitalizedString.fromUnknown("😀hello"), "😀hello");
+    assertOk(UncapitalizedString.fromUnknown("😀HELLO"), "😀HELLO");
+    assertErr(CapitalizedString.fromUnknown("𐐨x"));
+    assertErr(UncapitalizedString.fromUnknown("𐐀x"));
+  });
+
+  it("preserves parent constraints during validation and drops them during conversion", () => {
+    const Short = maxLength(1)(String);
+    const Capitalized = capitalized(Short);
+    const Uncapitalized = uncapitalized(Short);
+    const Uppercased = uppercased(Short);
+    const Lowercased = lowercased(Short);
+    assertType<
+      typeof Capitalized.Output,
+      string & Brand<"MaxLength1"> & Capitalize<string>
+    >();
+    assertType<
+      typeof Uncapitalized.Output,
+      string & Brand<"MaxLength1"> & Uncapitalize<string>
+    >();
+    assertType<
+      typeof Uppercased.Output,
+      string & Brand<"MaxLength1"> & Uppercase<string>
+    >();
+    assertType<
+      typeof Lowercased.Output,
+      string & Brand<"MaxLength1"> & Lowercase<string>
+    >();
+    assertType<
+      InferErrors<typeof Capitalized>,
+      typeof Short.Error | typeof String.Error | typeof Capitalized.Error
+    >();
+    for (const [type, valid] of [
+      [Capitalized, "A"],
+      [Uncapitalized, "a"],
+      [Uppercased, "A"],
+      [Lowercased, "a"],
+    ] as const) {
+      assertSame(type.parent, Short);
+      assertOk(type.fromUnknown(valid), valid);
+      assertErr(type.fromUnknown(valid.repeat(2)), {
+        type: "MaxLength1",
+        value: valid.repeat(2),
+        max: 1,
+      });
+    }
+    const sharpS = Short.orThrow("ß");
+    const dottedI = Short.orThrow("İ");
+    const capital = capitalize(sharpS);
+    const uncapital = uncapitalize(dottedI);
+    const upper = uppercase(sharpS);
+    const lower = lowercase(dottedI);
+    assertEqual(capital, "SS");
+    assertEqual(uncapital, "i\u0307");
+    assertEqual(upper, "SS");
+    assertEqual(lower, "i\u0307");
+    // @ts-expect-error Capitalization does not retain the MaxLength1 brand.
+    const _capital: typeof sharpS = capital;
+    // @ts-expect-error Uncapitalization does not retain the MaxLength1 brand.
+    const _uncapital: typeof dottedI = uncapital;
+    // @ts-expect-error Uppercasing does not retain the MaxLength1 brand.
+    const _upper: typeof sharpS = upper;
+    // @ts-expect-error Lowercasing does not retain the MaxLength1 brand.
+    const _lower: typeof dottedI = lower;
+  });
+
+  it("preserves a parent's decoding and encoding", () => {
+    const PrefixedString = transform("PrefixedString", String, String, {
+      from: (value) => ok(value.slice(1)),
+      to: (value) => `!${value}`,
+    });
+    for (const [type, value] of [
+      [capitalized(PrefixedString), "Hello"],
+      [uncapitalized(PrefixedString), "hello"],
+      [uppercased(PrefixedString), "HELLO"],
+      [lowercased(PrefixedString), "hello"],
+    ] as const) {
+      const result = type.fromUnknown(`!${value}`);
+      assertOk(result);
+      assertEqual(result.value, value);
+      assertEqual(type.to("123"), "!123");
+      assertErr(type.fromUnknown(null));
+    }
+  });
+
+  it("formats casing errors and matches the default English messages", () => {
+    assertEqual(
+      formatUncapitalizedError({ type: "Uncapitalized", value: "Hello" }),
+      'The value "Hello" must not start with an uppercase letter.',
+    );
+    assertEqual(
+      cs.formatUncapitalizedError({ type: "Uncapitalized", value: "Hello" }),
+      'Hodnota "Hello" nesmí začínat velkým písmenem.',
+    );
+    assertEqual(
+      formatCapitalizedError({ type: "Capitalized", value: "hello" }),
+      CapitalizedString.formatError({ type: "Capitalized", value: "hello" }),
+    );
+    assertEqual(
+      formatUncapitalizedError({ type: "Uncapitalized", value: "Hello" }),
+      UncapitalizedString.formatError({
+        type: "Uncapitalized",
+        value: "Hello",
+      }),
+    );
+    assertEqual(
+      formatUppercasedError({ type: "Uppercased", value: "Hello" }),
+      UppercasedString.formatError({ type: "Uppercased", value: "Hello" }),
+    );
+    assertEqual(
+      formatLowercasedError({ type: "Lowercased", value: "Hello" }),
+      LowercasedString.formatError({ type: "Lowercased", value: "Hello" }),
+    );
+  });
+});
+
+describe("BrandFactory", () => {
+  interface NonEmptyError extends TypeError<"NonEmpty"> {
+    readonly value: { readonly length: number };
+  }
+
+  const createNonEmpty = () => {
+    const validations: Array<{ readonly length: number }> = [];
+    const nonEmpty: BrandFactory<
+      "NonEmpty",
+      { readonly length: number },
+      NonEmptyError
+    > = (parent) =>
+      brand(
+        "NonEmpty",
+        parent,
+        (value) => {
           validations.push(value);
 
           return value.length > 0 ? ok() : err({ type: "NonEmpty", value });
@@ -7613,81 +8592,1048 @@ describe("BrandFactory", () => {
   });
 
   describe("Type Factory", () => {
-    describe("capitalized", () => {
+    describe("identifier", () => {
+      const formats = [
+        {
+          type: CamelCaseIdentifier,
+          casing: "camelCase",
+          valid: [
+            "a",
+            "a0",
+            "http2Port",
+            "v2beta",
+            "v2Beta",
+            "maxOwnerBytes",
+            "httpUrl",
+            "httpURL",
+            "aBC",
+          ],
+          invalid: ["Http2Port", "HTTP2_PORT", "http_port", "http-port"],
+        },
+        {
+          type: PascalCaseIdentifier,
+          casing: "PascalCase",
+          valid: [
+            "A",
+            "A0",
+            "Http2Port",
+            "V2beta",
+            "V2Beta",
+            "MaxOwnerBytes",
+            "HttpUrl",
+            "HttpURL",
+            "ABC",
+          ],
+          invalid: ["http2Port", "HTTP2_PORT", "http_port", "http-port"],
+        },
+        {
+          type: SnakeCaseIdentifier,
+          casing: "snake_case",
+          valid: [
+            "a",
+            "a0",
+            "http2_port",
+            "v2beta",
+            "v2_beta",
+            "max_owner_bytes",
+            "http_url",
+            "http_u_r_l",
+            "a_b_c",
+          ],
+          invalid: [
+            "HTTP2_PORT",
+            "httpPort",
+            "http-port",
+            "_port",
+            "port_",
+            "http__port",
+            "http_2_port",
+          ],
+        },
+        {
+          type: KebabCaseIdentifier,
+          casing: "kebab-case",
+          valid: [
+            "a",
+            "a0",
+            "http2-port",
+            "v2beta",
+            "v2-beta",
+            "max-owner-bytes",
+            "http-url",
+            "http-u-r-l",
+            "a-b-c",
+          ],
+          invalid: [
+            "HTTP2-PORT",
+            "httpPort",
+            "http_port",
+            "-port",
+            "port-",
+            "http--port",
+            "http-2-port",
+          ],
+        },
+        {
+          type: ConstantCaseIdentifier,
+          casing: "CONSTANT_CASE",
+          valid: [
+            "A",
+            "A0",
+            "HTTP2_PORT",
+            "V2BETA",
+            "V2_BETA",
+            "MAX_OWNER_BYTES",
+            "HTTP_URL",
+            "HTTP_U_R_L",
+            "A_B_C",
+          ],
+          invalid: [
+            "http2_port",
+            "httpPort",
+            "HTTP-PORT",
+            "_PORT",
+            "PORT_",
+            "HTTP__PORT",
+            "HTTP_2_PORT",
+          ],
+        },
+      ] as const;
+
+      for (const { type, casing, valid, invalid } of formats) {
+        it(`${type.name} accepts only its complete ASCII grammar`, () => {
+          for (const value of valid) {
+            assertOk(type.fromUnknown(value), value);
+            assertTrue(type.is(value));
+          }
+          for (const value of [
+            ...invalid,
+            "",
+            "0",
+            "2FA",
+            "2fa",
+            " hello",
+            "hello ",
+            "hello world",
+            "HELLO WORLD",
+            "hello.world",
+            "HELLO.WORLD",
+            "déjà",
+            "DÉJÀ",
+            "𐐀x",
+            "😀",
+            "a\u0301",
+            "A\u0301",
+            ...valid.flatMap((value) =>
+              ["\n", "\r", "\r\n", "\t", "\0", "\u2028", "\u2029"].map(
+                (suffix) => value + suffix,
+              ),
+            ),
+          ]) {
+            assertErr(type.fromUnknown(value), {
+              type: type.name,
+              casing,
+              value,
+            });
+            assertFalse(type.is(value));
+          }
+          assertErr(type.fromUnknown(123), {
+            type: "TypeOf",
+            expected: "String",
+            value: 123,
+          });
+          const empty = type.fromUnknown("");
+          assertErr(empty);
+          assertEqual(
+            typeErrorToIssues(type, empty.error)[0]?.message,
+            `The value "" is not a ${casing} identifier.`,
+          );
+        });
+      }
+
+      it("exposes distinct brands and composes validation constraints", () => {
+        assertType<
+          CamelCaseIdentifier,
+          string & Brand<"CamelCaseIdentifier">
+        >();
+        assertType<
+          PascalCaseIdentifier,
+          string & Brand<"PascalCaseIdentifier">
+        >();
+        assertType<
+          SnakeCaseIdentifier,
+          string & Brand<"SnakeCaseIdentifier">
+        >();
+        assertType<
+          KebabCaseIdentifier,
+          string & Brand<"KebabCaseIdentifier">
+        >();
+        assertType<
+          ConstantCaseIdentifier,
+          string & Brand<"ConstantCaseIdentifier">
+        >();
+        assertType<
+          IdentifierError<"camelCase">["type"],
+          "CamelCaseIdentifier"
+        >();
+        assertType<IdentifierError["casing"], IdentifierCasing>();
+
+        const ShortCamel = identifier("camelCase")(maxLength(3)(String));
+        assertType<
+          typeof ShortCamel.Output,
+          string & Brand<"MaxLength3"> & Brand<"CamelCaseIdentifier">
+        >();
+        assertOk(ShortCamel.fromUnknown("aBC"), "aBC");
+        assertErr(ShortCamel.fromUnknown("long"), {
+          type: "MaxLength3",
+          value: "long",
+          max: 3,
+        });
+        assertErr(ShortCamel.fromUnknown("Ab"), {
+          type: "CamelCaseIdentifier",
+          casing: "camelCase",
+          value: "Ab",
+        });
+        assertOk(
+          identifier("PascalCase")(maxLength(3)(String)).fromUnknown("ABC"),
+          "ABC",
+        );
+        assertOk(
+          identifier("snake_case")(maxLength(3)(String)).fromUnknown("a_b"),
+          "a_b",
+        );
+        assertOk(
+          identifier("kebab-case")(maxLength(3)(String)).fromUnknown("a-b"),
+          "a-b",
+        );
+        assertOk(
+          identifier("CONSTANT_CASE")(maxLength(3)(String)).fromUnknown("A_B"),
+          "A_B",
+        );
+      });
+    });
+
+    describe("naming conversions", () => {
+      const conversions = [
+        {
+          from: "CamelCase",
+          to: "PascalCase",
+          convert: (value: string) =>
+            camelCaseToPascalCase(CamelCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "CamelCase",
+          to: "SnakeCase",
+          convert: (value: string) =>
+            camelCaseToSnakeCase(CamelCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "CamelCase",
+          to: "KebabCase",
+          convert: (value: string) =>
+            camelCaseToKebabCase(CamelCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "CamelCase",
+          to: "ConstantCase",
+          convert: (value: string) =>
+            camelCaseToConstantCase(CamelCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "PascalCase",
+          to: "CamelCase",
+          convert: (value: string) =>
+            pascalCaseToCamelCase(PascalCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "PascalCase",
+          to: "SnakeCase",
+          convert: (value: string) =>
+            pascalCaseToSnakeCase(PascalCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "PascalCase",
+          to: "KebabCase",
+          convert: (value: string) =>
+            pascalCaseToKebabCase(PascalCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "PascalCase",
+          to: "ConstantCase",
+          convert: (value: string) =>
+            pascalCaseToConstantCase(PascalCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "SnakeCase",
+          to: "CamelCase",
+          convert: (value: string) =>
+            snakeCaseToCamelCase(SnakeCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "SnakeCase",
+          to: "PascalCase",
+          convert: (value: string) =>
+            snakeCaseToPascalCase(SnakeCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "SnakeCase",
+          to: "KebabCase",
+          convert: (value: string) =>
+            snakeCaseToKebabCase(SnakeCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "SnakeCase",
+          to: "ConstantCase",
+          convert: (value: string) =>
+            snakeCaseToConstantCase(SnakeCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "KebabCase",
+          to: "CamelCase",
+          convert: (value: string) =>
+            kebabCaseToCamelCase(KebabCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "KebabCase",
+          to: "PascalCase",
+          convert: (value: string) =>
+            kebabCaseToPascalCase(KebabCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "KebabCase",
+          to: "SnakeCase",
+          convert: (value: string) =>
+            kebabCaseToSnakeCase(KebabCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "KebabCase",
+          to: "ConstantCase",
+          convert: (value: string) =>
+            kebabCaseToConstantCase(KebabCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "ConstantCase",
+          to: "CamelCase",
+          convert: (value: string) =>
+            constantCaseToCamelCase(ConstantCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "ConstantCase",
+          to: "PascalCase",
+          convert: (value: string) =>
+            constantCaseToPascalCase(ConstantCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "ConstantCase",
+          to: "SnakeCase",
+          convert: (value: string) =>
+            constantCaseToSnakeCase(ConstantCaseIdentifier.orThrow(value)),
+        },
+        {
+          from: "ConstantCase",
+          to: "KebabCase",
+          convert: (value: string) =>
+            constantCaseToKebabCase(ConstantCaseIdentifier.orThrow(value)),
+        },
+      ] as const;
+
+      it("preserves the exact spelling for every pair of formats", () => {
+        const spellings = [
+          {
+            CamelCase: "maxOwnerBytes",
+            PascalCase: "MaxOwnerBytes",
+            SnakeCase: "max_owner_bytes",
+            KebabCase: "max-owner-bytes",
+            ConstantCase: "MAX_OWNER_BYTES",
+          },
+          {
+            CamelCase: "http2Port",
+            PascalCase: "Http2Port",
+            SnakeCase: "http2_port",
+            KebabCase: "http2-port",
+            ConstantCase: "HTTP2_PORT",
+          },
+          {
+            CamelCase: "httpUrl",
+            PascalCase: "HttpUrl",
+            SnakeCase: "http_url",
+            KebabCase: "http-url",
+            ConstantCase: "HTTP_URL",
+          },
+          {
+            CamelCase: "httpURL",
+            PascalCase: "HttpURL",
+            SnakeCase: "http_u_r_l",
+            KebabCase: "http-u-r-l",
+            ConstantCase: "HTTP_U_R_L",
+          },
+          {
+            CamelCase: "aBC",
+            PascalCase: "ABC",
+            SnakeCase: "a_b_c",
+            KebabCase: "a-b-c",
+            ConstantCase: "A_B_C",
+          },
+          {
+            CamelCase: "v2Beta",
+            PascalCase: "V2Beta",
+            SnakeCase: "v2_beta",
+            KebabCase: "v2-beta",
+            ConstantCase: "V2_BETA",
+          },
+          {
+            CamelCase: "v2beta",
+            PascalCase: "V2beta",
+            SnakeCase: "v2beta",
+            KebabCase: "v2beta",
+            ConstantCase: "V2BETA",
+          },
+          {
+            CamelCase: "a",
+            PascalCase: "A",
+            SnakeCase: "a",
+            KebabCase: "a",
+            ConstantCase: "A",
+          },
+          {
+            CamelCase: "a0B2c",
+            PascalCase: "A0B2c",
+            SnakeCase: "a0_b2c",
+            KebabCase: "a0-b2c",
+            ConstantCase: "A0_B2C",
+          },
+          {
+            CamelCase: "max2faAttempts",
+            PascalCase: "Max2faAttempts",
+            SnakeCase: "max2fa_attempts",
+            KebabCase: "max2fa-attempts",
+            ConstantCase: "MAX2FA_ATTEMPTS",
+          },
+        ];
+        for (const values of spellings) {
+          for (const { from, to, convert } of conversions) {
+            assertEqual(convert(values[from]), values[to]);
+          }
+        }
+      });
+
+      it("round-trips generated word sequences through every format", () => {
+        const words = ["a", "b", "z", "a0", "b2", "ab", "z9a", "http2", "url"];
+        const formats = {
+          CamelCase: CamelCaseIdentifier,
+          PascalCase: PascalCaseIdentifier,
+          SnakeCase: SnakeCaseIdentifier,
+          KebabCase: KebabCaseIdentifier,
+          ConstantCase: ConstantCaseIdentifier,
+        };
+        for (const first of words) {
+          for (const second of words) {
+            for (const third of words) {
+              const parts = [first, second, third];
+              const titled = parts.map(
+                (word) => word.charAt(0).toUpperCase() + word.slice(1),
+              );
+              const spellings = {
+                CamelCase: first + titled.slice(1).join(""),
+                PascalCase: titled.join(""),
+                SnakeCase: parts.join("_"),
+                KebabCase: parts.join("-"),
+                ConstantCase: parts.join("_").toUpperCase(),
+              };
+              for (const { from, to, convert } of conversions) {
+                const converted = convert(spellings[from]);
+                assertTrue(formats[to].is(converted));
+                assertEqual(converted, spellings[to]);
+                const reverse = conversions.find(
+                  (conversion) =>
+                    conversion.from === to && conversion.to === from,
+                );
+                nodeAssert.ok(reverse);
+                assertEqual(reverse.convert(converted), spellings[from]);
+              }
+            }
+          }
+        }
+      });
+
+      it("requires the source brand and returns only the destination brand", () => {
+        assertType<
+          Parameters<typeof camelCaseToPascalCase>[0],
+          CamelCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof camelCaseToPascalCase>,
+          PascalCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof camelCaseToSnakeCase>[0],
+          CamelCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof camelCaseToSnakeCase>,
+          SnakeCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof camelCaseToKebabCase>[0],
+          CamelCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof camelCaseToKebabCase>,
+          KebabCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof camelCaseToConstantCase>[0],
+          CamelCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof camelCaseToConstantCase>,
+          ConstantCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof pascalCaseToCamelCase>[0],
+          PascalCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof pascalCaseToCamelCase>,
+          CamelCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof pascalCaseToSnakeCase>[0],
+          PascalCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof pascalCaseToSnakeCase>,
+          SnakeCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof pascalCaseToKebabCase>[0],
+          PascalCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof pascalCaseToKebabCase>,
+          KebabCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof pascalCaseToConstantCase>[0],
+          PascalCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof pascalCaseToConstantCase>,
+          ConstantCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof snakeCaseToCamelCase>[0],
+          SnakeCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof snakeCaseToCamelCase>,
+          CamelCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof snakeCaseToPascalCase>[0],
+          SnakeCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof snakeCaseToPascalCase>,
+          PascalCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof snakeCaseToKebabCase>[0],
+          SnakeCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof snakeCaseToKebabCase>,
+          KebabCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof snakeCaseToConstantCase>[0],
+          SnakeCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof snakeCaseToConstantCase>,
+          ConstantCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof kebabCaseToCamelCase>[0],
+          KebabCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof kebabCaseToCamelCase>,
+          CamelCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof kebabCaseToPascalCase>[0],
+          KebabCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof kebabCaseToPascalCase>,
+          PascalCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof kebabCaseToSnakeCase>[0],
+          KebabCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof kebabCaseToSnakeCase>,
+          SnakeCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof kebabCaseToConstantCase>[0],
+          KebabCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof kebabCaseToConstantCase>,
+          ConstantCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof constantCaseToCamelCase>[0],
+          ConstantCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof constantCaseToCamelCase>,
+          CamelCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof constantCaseToPascalCase>[0],
+          ConstantCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof constantCaseToPascalCase>,
+          PascalCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof constantCaseToSnakeCase>[0],
+          ConstantCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof constantCaseToSnakeCase>,
+          SnakeCaseIdentifier
+        >();
+        assertType<
+          Parameters<typeof constantCaseToKebabCase>[0],
+          ConstantCaseIdentifier
+        >();
+        assertType<
+          ReturnType<typeof constantCaseToKebabCase>,
+          KebabCaseIdentifier
+        >();
+        const short = maxLength(3)(CamelCaseIdentifier).orThrow("aBC");
+        const constant = camelCaseToConstantCase(short);
+        assertEqual(constant, "A_B_C");
+        assertType<typeof constant, ConstantCaseIdentifier>();
+        const compileTimeAssertions = () => {
+          // @ts-expect-error Requires the CamelCaseIdentifier brand.
+          camelCaseToPascalCase("example");
+          // @ts-expect-error Requires the CamelCaseIdentifier brand.
+          camelCaseToSnakeCase("example");
+          // @ts-expect-error Requires the CamelCaseIdentifier brand.
+          camelCaseToKebabCase("example");
+          // @ts-expect-error Requires the CamelCaseIdentifier brand.
+          camelCaseToConstantCase("example");
+          // @ts-expect-error Requires the PascalCaseIdentifier brand.
+          pascalCaseToCamelCase("example");
+          // @ts-expect-error Requires the PascalCaseIdentifier brand.
+          pascalCaseToSnakeCase("example");
+          // @ts-expect-error Requires the PascalCaseIdentifier brand.
+          pascalCaseToKebabCase("example");
+          // @ts-expect-error Requires the PascalCaseIdentifier brand.
+          pascalCaseToConstantCase("example");
+          // @ts-expect-error Requires the SnakeCaseIdentifier brand.
+          snakeCaseToCamelCase("example");
+          // @ts-expect-error Requires the SnakeCaseIdentifier brand.
+          snakeCaseToPascalCase("example");
+          // @ts-expect-error Requires the SnakeCaseIdentifier brand.
+          snakeCaseToKebabCase("example");
+          // @ts-expect-error Requires the SnakeCaseIdentifier brand.
+          snakeCaseToConstantCase("example");
+          // @ts-expect-error Requires the KebabCaseIdentifier brand.
+          kebabCaseToCamelCase("example");
+          // @ts-expect-error Requires the KebabCaseIdentifier brand.
+          kebabCaseToPascalCase("example");
+          // @ts-expect-error Requires the KebabCaseIdentifier brand.
+          kebabCaseToSnakeCase("example");
+          // @ts-expect-error Requires the KebabCaseIdentifier brand.
+          kebabCaseToConstantCase("example");
+          // @ts-expect-error Requires the ConstantCaseIdentifier brand.
+          constantCaseToCamelCase("example");
+          // @ts-expect-error Requires the ConstantCaseIdentifier brand.
+          constantCaseToPascalCase("example");
+          // @ts-expect-error Requires the ConstantCaseIdentifier brand.
+          constantCaseToSnakeCase("example");
+          // @ts-expect-error Requires the ConstantCaseIdentifier brand.
+          constantCaseToKebabCase("example");
+          // @ts-expect-error ConstantCaseIdentifier does not prove the CamelCaseIdentifier brand.
+          camelCaseToSnakeCase(constant);
+          // @ts-expect-error Conversion does not retain the input's MaxLength3 brand.
+          const _short: string & Brand<"MaxLength3"> = constant;
+          // @ts-expect-error Uppercase text does not prove the ConstantCaseIdentifier grammar.
+          const _constant: ConstantCaseIdentifier =
+            "HTTP PORT" as Uppercase<string>;
+        };
+        assertType<typeof compileTimeAssertions, () => void>();
+      });
+    });
+
+    describe("trimmed", () => {
       it("is a reusable Brand Factory", () => {
         assertType<
-          typeof capitalized,
-          BrandFactory<"Capitalized", string, CapitalizedError>
+          typeof trimmed,
+          BrandFactory<"Trimmed", string, TrimmedError>
+        >();
+      });
+
+      describe("Type", () => {
+        describe("TrimmedString", () => {
+          it("accepts only strings without surrounding whitespace", () => {
+            assertEqual(TrimmedString.from.parent("Evolu"), ok("Evolu"));
+            assertEqual(
+              TrimmedString.from.parent(" Evolu "),
+              err({ type: "Trimmed", value: " Evolu " }),
+            );
+            assertEqual(
+              TrimmedString.formatError({
+                type: "Trimmed",
+                value: " Evolu ",
+              }),
+              'The value " Evolu " must be trimmed.',
+            );
+            assertType<
+              typeof TrimmedString.Output,
+              string & Brand<"Trimmed">
+            >();
+          });
+        });
+      });
+    });
+
+    describe("trim", () => {
+      it("returns a TrimmedString", () => {
+        const value = trim(" Evolu ");
+
+        assertEqual(value, "Evolu");
+        assertType<typeof value, TrimmedString>();
+      });
+    });
+
+    describe("startsWith", () => {
+      it("preserves the full string and parent constraints", () => {
+        const Parent = maxLength(12)(TrimmedString);
+        const AppName = startsWith("APP_")(Parent);
+        const input = Parent.orThrow("APP_PORT");
+        const result = AppName.from.parent(input);
+
+        assertOk(result, input);
+        assertSame(result.value, input);
+        assertSame(AppName.to(result.value), input);
+        assertSame(AppName.parent, Parent);
+        assertEqual(AppName.name, "StartsWithAPP_");
+        assertType<typeof AppName.name, "StartsWithAPP_">();
+        assertType<typeof AppName.parent, typeof Parent>();
+        assertType<
+          typeof AppName.Output,
+          typeof Parent.Output & Brand<"StartsWithAPP_">
+        >();
+        assertType<typeof AppName.Error, StartsWithError<"APP_">>();
+        assertType<
+          Parameters<typeof AppName.from.parent>[0],
+          typeof Parent.Output
+        >();
+        assertErr(AppName.fromUnknown(" APP_PORT"), {
+          type: "Trimmed",
+          value: " APP_PORT",
+        });
+        assertErr(AppName.fromUnknown("APP_LONG_NAME"), {
+          type: "MaxLength12",
+          value: "APP_LONG_NAME",
+          max: 12,
+        });
+        assertErr(AppName.fromUnknown(1), {
+          type: "TypeOf",
+          expected: "String",
+          value: 1,
+        });
+      });
+
+      it("matches the exact prefix at the start without removing it", () => {
+        const AppName = startsWith("APP_")(String);
+        for (const value of ["APP_", "APP_PORT", "APP_APP_PORT", "APP_\n"]) {
+          assertOk(AppName.fromUnknown(value), value);
+        }
+        for (const value of ["", "APP", "app_PORT", "XAPP_PORT"]) {
+          assertErr(AppName.fromUnknown(value), {
+            type: "StartsWithAPP_",
+            value,
+            prefix: "APP_",
+          });
+        }
+        assertEqual(
+          AppName.formatError({
+            type: "StartsWithAPP_",
+            value: "PORT",
+            prefix: "APP_",
+          }),
+          'The value "PORT" must start with "APP_".',
+        );
+      });
+
+      it("accepts an empty prefix and matches punctuation and Unicode literally", () => {
+        const AnyString = startsWith("")(String);
+        for (const value of ["", "PORT", "\n", "😀"]) {
+          assertOk(AnyString.fromUnknown(value), value);
+        }
+        assertErr(startsWith("")(TrimmedString).fromUnknown(" "));
+        assertOk(
+          startsWith("[a].*")(String).fromUnknown("[a].*value"),
+          "[a].*value",
+        );
+        assertErr(startsWith("[a].*")(String).fromUnknown("abc"));
+        assertOk(startsWith("😀:")(String).fromUnknown("😀:value"), "😀:value");
+        assertErr(startsWith("é")(String).fromUnknown("e\u0301"));
+      });
+
+      it("validates transformed parent output and preserves its encoder", () => {
+        const Parent = transform("LowercasePrefixInput", String, String, {
+          from: (value) => ok(value.toLowerCase()),
+          to: (value) => value.toUpperCase(),
+        });
+        const AppName = startsWith("app_")(Parent);
+        const result = AppName.fromUnknown("APP_PORT");
+
+        assertOk(result, "app_port");
+        assertEqual(AppName.to(result.value), "APP_PORT");
+        assertErr(AppName.fromUnknown("OTHER_PORT"), {
+          type: "StartsWithapp_",
+          value: "other_port",
+          prefix: "app_",
+        });
+      });
+
+      it("requires a concrete prefix and keeps different prefix brands distinct", () => {
+        const AppName = startsWith("APP_")(String);
+        const OtherName = startsWith("OTHER_")(String);
+        const otherName = OtherName.orThrow("OTHER_PORT");
+        const widened = globalThis.String("APP_");
+        const unionPrefix = "APP_" as "APP_" | "OTHER_";
+        const branded = TrimmedString.orThrow("APP_");
+        const templatePrefix = "APP_" as `APP_${string}`;
+        const compileTimeAssertions = () => {
+          // @ts-expect-error Expected must be one concrete literal value.
+          startsWith(widened);
+          // @ts-expect-error Expected must be one concrete literal value.
+          startsWith(unionPrefix);
+          // @ts-expect-error Expected must be one concrete literal value.
+          startsWith(branded);
+          // @ts-expect-error Expected must be one concrete literal value.
+          startsWith(templatePrefix);
+          // @ts-expect-error The parent Type must output strings.
+          startsWith("APP_")(Number);
+          // @ts-expect-error Error type must not duplicate an error inherited from the parent Type.
+          startsWith("APP_")(AppName);
+          // @ts-expect-error OTHER_ values do not carry the StartsWithAPP_ brand.
+          AppName.from(otherName);
+        };
+
+        assertType<
+          typeof compileTimeAssertions extends (
+            ...args: Array<never>
+          ) => unknown
+            ? true
+            : false,
+          true
+        >();
+      });
+    });
+
+    describe("prefixed", () => {
+      it("preserves the suffix Type and applies its constraints after stripping", () => {
+        const Suffix = maxLength(4)(ConstantCaseIdentifier);
+        const Key = prefixed("app:")(Suffix);
+        const result = Key.fromUnknown("app:PORT");
+
+        assertOk(result, "PORT");
+        assertEqual(Key.to(result.value), "app:PORT");
+        assertSame(Key.output, Suffix);
+        assertEqual(Key.name, "Prefixedapp:");
+        assertEqual(Key.parent.name, "StartsWithapp:");
+        assertType<typeof Key.Output, typeof Suffix.Output>();
+        assertType<typeof Key.output, typeof Suffix>();
+        assertType<typeof Key.name, "Prefixedapp:">();
+        assertType<
+          typeof Key.Error,
+          TransformOutputError<
+            "Prefixedapp:",
+            IdentifierError<"CONSTANT_CASE"> | MaxLengthError<4>
+          >
+        >();
+        assertType<
+          Parameters<typeof Key.from.parent>[0],
+          string & Brand<"StartsWithapp:">
+        >();
+        assertType<Parameters<typeof Key.from.parent.parent>[0], string>();
+        assertType<Parameters<typeof Key.from>[0], typeof Suffix.Output>();
+        assertType<
+          ReturnType<typeof Key.to>,
+          string & Brand<"StartsWithapp:">
         >();
+        assertOk(Key.from.parent(Key.parent.orThrow("app:PORT")), "PORT");
+        assertOk(Key.from.parent.parent("app:PORT"), "PORT");
+        assertOk(Key.from(result.value), result.value);
+        assertTrue(Key.is("PORT"));
+        assertFalse(Key.is("app:PORT"));
+        assertErr(Key.fromUnknown("app:PORTS"), {
+          type: "Prefixedapp:",
+          outputError: { type: "MaxLength4", value: "PORTS", max: 4 },
+        });
       });
 
-      describe("Type", () => {
-        describe("CapitalizedString", () => {
-          it("accepts only capitalized strings", () => {
-            assertEqual(CapitalizedString.from.parent("Evolu"), ok("Evolu"));
-            assertEqual(
-              CapitalizedString.from.parent("evolu"),
-              err({ type: "Capitalized", value: "evolu" }),
-            );
-            assertEqual(CapitalizedString.from.parent("𐐀x"), ok("𐐀x"));
-            assertEqual(
-              CapitalizedString.from.parent("𐐨x"),
-              err({ type: "Capitalized", value: "𐐨x" }),
-            );
-            assertEqual(
-              CapitalizedString.formatError({
-                type: "Capitalized",
-                value: "evolu",
-              }),
-              'The value "evolu" must be capitalized.',
-            );
-            assertType<
-              typeof CapitalizedString.Output,
-              string & Brand<"Capitalized">
-            >();
-          });
+      it("reports prefix and suffix errors through their existing formatters", () => {
+        const Key = prefixed("APP_")(ConstantCaseIdentifier);
+        for (const value of ["PORT", "app_PORT", "XAPP_PORT"]) {
+          const result = Key.fromUnknown(value);
+          assertErr(result, { type: "StartsWithAPP_", value, prefix: "APP_" });
+          assertEqual(
+            Key.formatError(result.error),
+            `The value "${value}" must start with "APP_".`,
+          );
+        }
+        assertErr(Key.fromUnknown(1), {
+          type: "TypeOf",
+          expected: "String",
+          value: 1,
+        });
+        const invalid = Key.fromUnknown("APP_port");
+        assertErr(invalid, {
+          type: "PrefixedAPP_",
+          outputError: {
+            type: "ConstantCaseIdentifier",
+            value: "port",
+            casing: "CONSTANT_CASE",
+          },
         });
+        assertEqual(typeErrorToIssues(Key, invalid.error), [
+          {
+            path: [],
+            message: 'The value "port" is not a CONSTANT_CASE identifier.',
+          },
+        ]);
+        assertErr(Key.fromUnknown("APP_"));
       });
-    });
 
-    describe("trimmed", () => {
-      it("is a reusable Brand Factory", () => {
-        assertType<
-          typeof trimmed,
-          BrandFactory<"Trimmed", string, TrimmedError>
-        >();
-      });
+      it("runs the wrapped decoder and canonical encoder for non-string Outputs", () => {
+        const Setting = prefixed("port:")(PortFromString);
+        const result = Setting.fromUnknown("port:04000");
 
-      describe("Type", () => {
-        describe("TrimmedString", () => {
-          it("accepts only strings without surrounding whitespace", () => {
-            assertEqual(TrimmedString.from.parent("Evolu"), ok("Evolu"));
-            assertEqual(
-              TrimmedString.from.parent(" Evolu "),
-              err({ type: "Trimmed", value: " Evolu " }),
-            );
-            assertEqual(
-              TrimmedString.formatError({
-                type: "Trimmed",
-                value: " Evolu ",
-              }),
-              'The value " Evolu " must be trimmed.',
-            );
-            assertType<
-              typeof TrimmedString.Output,
-              string & Brand<"Trimmed">
-            >();
-          });
+        assertOk(result, 4000);
+        assertType<typeof result.value, Port>();
+        assertEqual(Setting.to(result.value), "port:4000");
+        assertOk(Setting.fromUnknown(Setting.to(result.value)), result.value);
+        assertErr(Setting.fromUnknown("port:65536"), {
+          type: "Prefixedport:",
+          outputError: {
+            type: "PortFromString",
+            outputError: {
+              type: "LessThanOrEqualTo65535",
+              value: 65536,
+              max: 65535,
+            },
+          },
         });
+        assertTrue(Setting.is(4000));
+        assertFalse(Setting.is("port:4000"));
       });
-    });
 
-    describe("trim", () => {
-      it("returns a TrimmedString", () => {
-        const value = trim(" Evolu ");
+      it("removes one literal prefix, including empty and Unicode prefixes", () => {
+        const Empty = prefixed("")(String);
+        for (const value of ["", "PORT", "\n"]) {
+          assertOk(Empty.fromUnknown(value), value);
+          assertEqual(Empty.to(value), value);
+        }
+        const App = prefixed("APP_")(String);
+        assertOk(App.fromUnknown("APP_"), "");
+        assertOk(App.fromUnknown("APP_APP_PORT"), "APP_PORT");
+        assertEqual(App.to("APP_PORT"), "APP_APP_PORT");
+        const Unicode = prefixed("😀:")(String);
+        assertOk(Unicode.fromUnknown("😀:PORT"), "PORT");
+        assertEqual(Unicode.to("PORT"), "😀:PORT");
+        const Punctuation = prefixed("[a].*")(String);
+        assertOk(Punctuation.fromUnknown("[a].*PORT"), "PORT");
+        assertEqual(Punctuation.to("PORT"), "[a].*PORT");
+        assertErr(Punctuation.fromUnknown("abcPORT"));
+      });
 
-        assertEqual(value, "Evolu");
-        assertType<typeof value, TrimmedString>();
+      it("composes nested prefixes in both directions", () => {
+        const Nested = prefixed("outer/")(prefixed("inner/")(PortFromString));
+        const result = Nested.fromUnknown("outer/inner/04000");
+        assertOk(result, 4000);
+        assertEqual(Nested.to(result.value), "outer/inner/4000");
+        assertErr(Nested.fromUnknown("outer/4000"));
+
+        const Repeated = prefixed("APP_")(prefixed("APP_")(String));
+        assertOk(Repeated.fromUnknown("APP_APP_PORT"), "PORT");
+        assertEqual(Repeated.to("PORT"), "APP_APP_PORT");
+
+        const Literal = prefixed("APP_")(literal("PORT"));
+        assertOk(Literal.fromUnknown("APP_PORT"), "PORT");
+        assertErr(Literal.fromUnknown("APP_OTHER"));
+        assertEqual(Literal.to("PORT"), "APP_PORT");
+        assertType<typeof Literal.Output, "PORT">();
+      });
+
+      it("decodes and encodes record keys without filtering mismatched prefixes", () => {
+        const Settings = record(
+          prefixed("APP_")(ConstantCaseIdentifier),
+          String,
+        );
+        const result = Settings.fromUnknown({ APP_PORT: "4000" });
+        assertOk(result, { PORT: "4000" });
+        assertEqual(Settings.to(result.value), { APP_PORT: "4000" });
+        assertErr(Settings.fromUnknown({ PORT: "4000" }));
+      });
+
+      it("rejects uncertain prefixes and Types without a string input boundary", () => {
+        const widened = globalThis.String("APP_");
+        const unionPrefix = "APP_" as "APP_" | "OTHER_";
+        const branded = TrimmedString.orThrow("APP_");
+        const templatePrefix = "APP_" as `APP_${string}`;
+        const uncertain = String as
+          typeof String | typeof ConstantCaseIdentifier;
+        const Setting = prefixed("port:")(PortFromString);
+        const LiteralRoot = createType(
+          "LiteralRoot",
+          (value): Result<"PORT", TypeError<"LiteralRoot">> =>
+            value === "PORT" ? ok(value) : err({ type: "LiteralRoot" }),
+          () => "Expected PORT.",
+        );
+        const compileTimeAssertions = () => {
+          // @ts-expect-error Expected must be one concrete literal value.
+          prefixed(widened);
+          // @ts-expect-error Expected must be one concrete literal value.
+          prefixed(unionPrefix);
+          // @ts-expect-error Expected must be one concrete literal value.
+          prefixed(branded);
+          // @ts-expect-error Expected must be one concrete literal value.
+          prefixed(templatePrefix);
+          // @ts-expect-error The wrapped Type must have string Input and CanonicalInput.
+          prefixed("APP_")(Number);
+          // @ts-expect-error The wrapped Type must have string Input and CanonicalInput.
+          prefixed("APP_")(object({ port: Port }));
+          // @ts-expect-error Output Type must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
+          prefixed("APP_")(uncertain);
+          // @ts-expect-error Prefixed Type Input must accept every string.
+          prefixed("APP_")(LiteralRoot);
+          // @ts-expect-error The typed parent boundary requires the StartsWithport: brand.
+          Setting.from.parent("port:4000");
+          // @ts-expect-error Encoding requires a validated Port, not a plain number.
+          Setting.to(4000);
+        };
+        assertType<
+          typeof compileTimeAssertions extends (
+            ...args: Array<never>
+          ) => unknown
+            ? true
+            : false,
+          true
+        >();
       });
     });
 
@@ -8869,6 +10815,97 @@ describe("BrandFactory", () => {
         });
       });
 
+      describe("Port", () => {
+        it("accepts integer ports including zero and both range boundaries", () => {
+          for (const value of [0, 1, 4000, 65535]) {
+            assertOk(Port.fromUnknown(value), value);
+            const port = Port.orThrow(value);
+            assertType<typeof port, Port>();
+            assertSame(Port.to(port), value);
+          }
+          assertSame(Port.orThrow(-0), -0);
+          assertType<
+            Port,
+            NonNegativeInt & Brand<"LessThanOrEqualTo65535"> & Brand<"Port">
+          >();
+          // @ts-expect-error A number does not carry the Port brand.
+          const _port: Port = 4000;
+        });
+
+        it("rejects values outside the port domain", () => {
+          assertErr(Port.fromUnknown(-1), { type: "NonNegative", value: -1 });
+          assertErr(Port.fromUnknown(65536), {
+            type: "LessThanOrEqualTo65535",
+            value: 65536,
+            max: 65535,
+          });
+          assertErr(Port.fromUnknown(4000.5), { type: "Int", value: 4000.5 });
+          for (const value of ["4000", null, NaN, Infinity, -Infinity]) {
+            assertErr(Port.fromUnknown(value));
+          }
+        });
+      });
+
+      describe("PortFromString", () => {
+        it("reuses decimal integer parsing and encodes validated ports", () => {
+          for (const [input, output] of [
+            ["0", 0],
+            ["04000", 4000],
+            ["65535", 65535],
+          ] as const) {
+            assertOk(PortFromString.fromUnknown(input), output);
+            const port = PortFromString.orThrow(input);
+            assertType<typeof port, Port>();
+            assertEqual(PortFromString.to(port), globalThis.String(output));
+          }
+          assertOk(PortFromString.from.parent(Int.orThrow(4000)), 4000);
+          assertEqual(PortFromString.to(Port.orThrow(4000)), "4000");
+          assertSame(PortFromString.orThrow("-0"), -0);
+          assertEqual(PortFromString.to(Port.orThrow(-0)), "-0");
+        });
+
+        it("preserves parsing errors and formats port range errors", () => {
+          for (const value of [
+            "",
+            "http",
+            " 4000",
+            "+4000",
+            "4000.5",
+            "4e3",
+            "0x10",
+          ]) {
+            assertErr(PortFromString.fromUnknown(value), {
+              type: "IntFromString",
+              value,
+            });
+          }
+          assertErr(PortFromString.fromUnknown(4000));
+          assertErr(PortFromString.fromUnknown("9007199254740992"));
+          const negative = PortFromString.fromUnknown("-1");
+          assertErr(negative, {
+            type: "PortFromString",
+            outputError: { type: "NonNegative", value: -1 },
+          });
+          assertEqual(
+            PortFromString.formatError(negative.error),
+            "The value -1 must be non-negative (>= 0).",
+          );
+          const tooLarge = PortFromString.fromUnknown("65536");
+          assertErr(tooLarge, {
+            type: "PortFromString",
+            outputError: {
+              type: "LessThanOrEqualTo65535",
+              value: 65536,
+              max: 65535,
+            },
+          });
+          assertEqual(
+            PortFromString.formatError(tooLarge.error),
+            "The value 65536 must be less than or equal to 65535.",
+          );
+        });
+      });
+
       describe("Ratio", () => {
         it("accepts finite numbers from zero to one", () => {
           assertEqual(Ratio.from.parent.parent.parent.parent.parent(0), ok(0));
@@ -11053,7 +13090,7 @@ describe("array", () => {
       const value: ReadonlyArray<number> = [1, 2];
 
       assertSame(UserIds.orThrow(value), value);
-      assertAssertionError(() => UserIds.orThrow([1, -2, 3]), "getOrThrow", {
+      assertAssertionError(() => UserIds.orThrow([1, -2, 3]), "PositiveInt", {
         type: "Array",
         reason: {
           kind: "Items",
@@ -11072,7 +13109,7 @@ describe("array", () => {
       const { UserIds } = setupUserIds();
       assertAssertionError(
         () => UserIds.orThrow([0, -1], { errors: "all" }),
-        "getOrThrow",
+        "PositiveInt",
         {
           type: "Array",
           reason: {
@@ -13731,26 +15768,541 @@ describe("record", () => {
           kind: "Entries",
           issues: [{ kind: "NonEnumerable", key: "allowed" }],
         },
-      }),
-      'A Record property "allowed" must be enumerable.',
+      }),
+      'A Record property "allowed" must be enumerable.',
+    );
+    assertEqual(
+      Transformed.formatError({
+        type: "Record",
+        reason: {
+          kind: "Entries",
+          issues: [
+            {
+              kind: "Collision",
+              key: "a",
+              previousKey: "A",
+              outputKey: "a",
+            },
+          ],
+        },
+      }),
+      'Record keys "A" and "a" decode to the same key "a".',
+    );
+  });
+});
+
+describe("withDefault", () => {
+  it("accepts nullish defaults when they belong to the wrapped Output", () => {
+    const Nullable = withDefault(nullOr(Boolean), null);
+    assertType<typeof Nullable.Output, boolean | null>();
+    assertOk(Nullable.fromUnknown(null), null);
+    assertEqual(Nullable.to(null), null);
+    assertOk(Nullable.fromUnknown(Nullable.to(false)), false);
+
+    const UndefinedDefault = withDefault(undefinedOr(Boolean), undefined, {
+      strategy: "preserve",
+    });
+    assertType<
+      typeof UndefinedDefault.Output,
+      Defaulted<boolean, undefined, "undefined">
+    >();
+    const decoded = UndefinedDefault.fromUnknown(undefined);
+    assertOk(decoded, {
+      value: undefined,
+      defaultUsed: true,
+      original: "undefined",
+    });
+    assertSame(UndefinedDefault.to(decoded.value), undefined);
+    assertOk(
+      UndefinedDefault.fromUnknown(UndefinedDefault.to(decoded.value)),
+      decoded.value,
+    );
+
+    const Model = object({
+      value: withDefault(optional(nullOr(Boolean)), null, {
+        strategy: "preserve",
+      }),
+    });
+    const missing = Model.fromUnknown({});
+    assertOk(missing, {
+      value: { value: null, defaultUsed: true, original: "missing" },
+    });
+    assertEqual(Model.to(missing.value), {});
+    assertOk(Model.fromUnknown({ value: null }), {
+      value: { value: null, defaultUsed: true, original: "null" },
+    });
+  });
+
+  it("reuses configured object defaults by reference", () => {
+    const defaultValue = { enabled: true };
+    const Value = nullOr(object({ enabled: Boolean }));
+    const Replaced = withDefault(Value, defaultValue);
+    const Preserved = withDefault(Value, defaultValue, {
+      strategy: "preserve",
+    });
+
+    assertSame(Replaced.orThrow(null), defaultValue);
+    assertSame(Replaced.orThrow(null), defaultValue);
+    assertSame(Preserved.orThrow(null).value, defaultValue);
+    assertSame(Preserved.orThrow(null).value, defaultValue);
+  });
+
+  describe("replace", () => {
+    it("accepts object defaults directly, including objects with a value property", () => {
+      const Value = withDefault(nullOr(object({ value: Boolean })), {
+        value: true,
+      });
+
+      assertType<typeof Value.Output.value, boolean>();
+      assertOk(Value.fromUnknown(null), { value: true });
+      assertOk(Value.fromUnknown({ value: false }), { value: false });
+      assertEqual(Value.to({ value: true }), { value: true });
+    });
+
+    it("defaults only decoded absence and emits supplied canonical data", () => {
+      const Value = withDefault(nullishOr(BooleanFromString), true);
+
+      assertType<typeof Value.Output, boolean>();
+      assertType<typeof Value.Input, string | null | undefined>();
+      for (const input of [null, undefined, "true"]) {
+        assertOk(Value.fromUnknown(input), true);
+      }
+      assertOk(Value.fromUnknown("false"), false);
+      assertErr(Value.fromUnknown("wrong"));
+      assertEqual(Value.to(true), "true");
+      assertEqual(Value.to(false), "false");
+      assertOk(Value.fromUnknown(Value.to(false)), false);
+      assertOk(Value.from.parent(null), true);
+      assertEqual(Value.to.parent(true), true);
+      assertFalse(Value.is(null));
+      assertThrowsInstanceOf(() => Value.to(null as never), Error);
+    });
+
+    it("makes optional input required in the output without accepting undefined", () => {
+      const Model = object({
+        enabled: withDefault(optional(Boolean), true),
+      });
+
+      assertType<typeof Model.Input.enabled, boolean | undefined>();
+      assertType<typeof Model.Output.enabled, boolean>();
+      assertOk(Model.fromUnknown({}), { enabled: true });
+      assertOk(Model.from.parent({}), { enabled: true });
+      assertOk(Model.parent.fromUnknown({}), {});
+      assertErr(Model.fromUnknown({ enabled: undefined }));
+      assertErr(Model.fromUnknown({ enabled: null }));
+      assertFalse(Model.is({}));
+      assertTrue(Model.is({ enabled: false }));
+      assertEqual(Model.to({ enabled: true }), { enabled: true });
+      assertOk(Model.fromUnknown(Model.to({ enabled: false })), {
+        enabled: false,
+      });
+    });
+  });
+
+  describe("preserve", () => {
+    it("distinguishes all absence states and explicit values equal to the default", () => {
+      const Model = object({
+        enabled: withDefault(optional(nullishOr(BooleanFromString)), true, {
+          strategy: "preserve",
+        }),
+      });
+      assertType<typeof Model.Output.enabled, Defaulted<boolean, true>>();
+      const cases = [
+        [{}, { value: true, defaultUsed: true, original: "missing" }],
+        [
+          { enabled: null },
+          { value: true, defaultUsed: true, original: "null" },
+        ],
+        [
+          { enabled: undefined },
+          { value: true, defaultUsed: true, original: "undefined" },
+        ],
+        [{ enabled: "true" }, { value: true, defaultUsed: false }],
+        [{ enabled: "false" }, { value: false, defaultUsed: false }],
+      ] as const;
+
+      for (const [input, enabled] of cases) {
+        const result = Model.fromUnknown(input);
+        assertOk(result, { enabled });
+        assertTrue(Model.is(result.value));
+        const encoded = Model.to(result.value);
+        assertEqual(encoded, input);
+        assertOk(Model.fromUnknown(encoded), result.value);
+        assertEqual(
+          globalThis.Object.hasOwn(encoded, "enabled"),
+          globalThis.Object.hasOwn(input, "enabled"),
+        );
+      }
+      assertOk(Model.from.parent({ enabled: "false" }), {
+        enabled: { value: false, defaultUsed: false },
+      });
+    });
+
+    it("narrows original states and rejects impossible output shapes", () => {
+      const Value = withDefault(nullOr(Boolean), true, {
+        strategy: "preserve",
+      });
+      assertType<typeof Value.Output, Defaulted<boolean, true, "null">>();
+      assertOk(Value.fromUnknown(null), {
+        value: true,
+        defaultUsed: true,
+        original: "null",
+      });
+      assertEqual(
+        Value.to({ value: true, defaultUsed: true, original: "null" }),
+        null,
+      );
+      assertFalse(
+        Value.is({ value: false, defaultUsed: true, original: "null" }),
+      );
+      assertFalse(
+        Value.is({ value: true, defaultUsed: true, original: "undefined" }),
+      );
+      assertFalse(
+        Value.is({ value: true, defaultUsed: true, original: "missing" }),
+      );
+      assertFalse(Value.is({ value: null, defaultUsed: false }));
+      assertFalse(
+        Value.is({ value: true, defaultUsed: false, original: "null" }),
+      );
+      const error = assertThrowsInstanceOf(
+        () =>
+          Value.to({
+            value: false,
+            defaultUsed: true,
+            original: "null",
+          } as never),
+        Error,
+      );
+      assertTrue(error.message.length > 0);
+      assertEqual(
+        Value.formatError(error.cause as never),
+        "A preserved default must equal the configured default value.",
+      );
+      for (const [output, message] of [
+        [
+          { value: null, defaultUsed: false },
+          "The value must be a non-nullish Output of its Type or, in replacement mode, the configured default.",
+        ],
+        [
+          { value: true, defaultUsed: true, original: "missing" },
+          "The original absence must be handled by this default declaration.",
+        ],
+      ] as const) {
+        const invalid = assertThrowsInstanceOf(
+          () => Value.to(output as never),
+          Error,
+        );
+        assertEqual(Value.formatError(invalid.cause as never), message);
+      }
+    });
+
+    it("compares structured defaults by value", () => {
+      const Value = withDefault(
+        nullOr(object({ enabled: Boolean })),
+        { enabled: true },
+        { strategy: "preserve" },
+      );
+      const output = {
+        value: { enabled: true },
+        defaultUsed: true,
+        original: "null",
+      } as const;
+      assertTrue(Value.is(output));
+      assertEqual(Value.to(output), null);
+      assertOk(Value.fromUnknown(null), output);
+      assertFalse(Value.is({ ...output, value: { enabled: false } }));
+    });
+
+    it("also validates preserved default values against the wrapped Type", () => {
+      const selected = { enabled: true };
+      const Selected = createType(
+        "Selected",
+        (value): Result<typeof selected, TypeError<"Selected">> =>
+          value === selected ? ok(selected) : err({ type: "Selected" }),
+        () => "Expected the selected object.",
+      );
+      const Value = withDefault(nullOr(Selected), selected, {
+        strategy: "preserve",
+      });
+      assertTrue(
+        Value.is({ value: selected, defaultUsed: true, original: "null" }),
+      );
+      assertFalse(
+        Value.is({
+          value: { ...selected },
+          defaultUsed: true,
+          original: "null",
+        }),
+      );
+    });
+
+    it("uses decoded absence rather than raw input spelling", () => {
+      const Input = transform("AbsentString", String, nullOr(Boolean), {
+        from: (value) => ok(value === "absent" ? null : value === "true"),
+        to: (value) => (value === null ? "absent" : value ? "true" : "false"),
+      });
+      const Value = withDefault(Input, false, { strategy: "preserve" });
+      const decoded = Value.fromUnknown("absent");
+      assertOk(decoded, { value: false, defaultUsed: true, original: "null" });
+      assertEqual(Value.to(decoded.value), "absent");
+      assertOk(Value.fromUnknown("other"), {
+        value: false,
+        defaultUsed: false,
+      });
+    });
+  });
+
+  describe("composition", () => {
+    it("round-trips through arrays and JSON", () => {
+      const Values = array(
+        withDefault(undefinedOr(BooleanFromString), false, {
+          strategy: "preserve",
+        }),
+      );
+      const values = Values.fromUnknown([undefined, "true"]);
+      assertOk(values, [
+        { value: false, defaultUsed: true, original: "undefined" },
+        { value: true, defaultUsed: false },
+      ]);
+      assertEqual(Values.to(values.value), [undefined, "true"]);
+      assertOk(Values.from.parent([undefined, true]), values.value);
+
+      const Model = object({
+        enabled: withDefault(optional(Boolean), true, { strategy: "preserve" }),
+      });
+      const [ModelJson, modelToJson, jsonToModel] = json(
+        Model,
+        "DefaultSettingsJson",
+      );
+      const missing = jsonToModel(ModelJson.orThrow("{}"));
+      assertEqual(missing, {
+        enabled: { value: true, defaultUsed: true, original: "missing" },
+      });
+      assertEqual(modelToJson(missing), "{}");
+      assertEqual(jsonToModel(modelToJson(missing)), missing);
+      assertFalse(
+        Model.is({
+          enabled: { value: false, defaultUsed: true, original: "missing" },
+        }),
+      );
+    });
+
+    it("composes nested objects, ordinary optional fields, and rest records", () => {
+      const Model = object({
+        inner: object({
+          enabled: withDefault(optional(BooleanFromString), true, {
+            strategy: "preserve",
+          }),
+          count: Int64FromInt64String,
+          note: optional(String),
+        }),
+      });
+      const decoded = Model.fromUnknown({ inner: { count: "42" } });
+      assertOk(decoded, {
+        inner: {
+          enabled: { value: true, defaultUsed: true, original: "missing" },
+          count: 42n,
+        },
+      });
+      assertEqual(Model.to(decoded.value), { inner: { count: "42" } });
+
+      const Open = object(
+        {
+          enabled: withDefault(optional(Boolean), true),
+        },
+        record(String, Boolean),
+      );
+      assertOk(Open.fromUnknown({ other: false }), {
+        enabled: true,
+        other: false,
+      });
+      assertEqual(Open.to({ enabled: true, other: false }), {
+        enabled: true,
+        other: false,
+      });
+      assertErr(Open.fromUnknown({ other: "false" }));
+    });
+
+    it("partial disables missing defaults for non-nullish Types in both strategies", () => {
+      const Replaced = partial({
+        enabled: withDefault(optional(Boolean), true),
+      });
+      const Preserved = partial({
+        enabled: withDefault(optional(Boolean), true, { strategy: "preserve" }),
+      });
+
+      assertType<typeof Replaced.Output.enabled, boolean | undefined>();
+      assertType<
+        typeof Preserved.Output.enabled,
+        Defaulted<boolean, true, never> | undefined
+      >();
+      assertOk(Replaced.fromUnknown({}), {});
+      assertOk(Preserved.fromUnknown({}), {});
+      assertOk(Replaced.fromUnknown({ enabled: false }), { enabled: false });
+      const supplied = Preserved.orThrow({ enabled: false });
+      assertEqual(supplied, { enabled: { value: false, defaultUsed: false } });
+      assertEqual(Preserved.to(supplied), { enabled: false });
+      assertEqual(Replaced.to({}), {});
+      assertEqual(Preserved.to({}), {});
+      assertErr(Replaced.fromUnknown({ enabled: undefined }));
+      assertErr(Preserved.fromUnknown({ enabled: null }));
+    });
+
+    it("partial makes missing outputs optional and retains defaults for present null", () => {
+      const Model = partial({
+        enabled: withDefault(optional(nullOr(Boolean)), true, {
+          strategy: "preserve",
+        }),
+      });
+      assertType<
+        typeof Model.Output.enabled,
+        Defaulted<boolean, true, "null"> | undefined
+      >();
+      assertOk(Model.fromUnknown({}), {});
+      const decoded = Model.fromUnknown({ enabled: null });
+      assertOk(decoded, {
+        enabled: { value: true, defaultUsed: true, original: "null" },
+      });
+      assertEqual(Model.to(decoded.value), { enabled: null });
+    });
+
+    it("partial retains replacement defaults for present null", () => {
+      const Model = partial({
+        enabled: withDefault(optional(nullOr(Boolean)), true),
+      });
+
+      assertType<typeof Model.Output.enabled, boolean | undefined>();
+      assertOk(Model.fromUnknown({}), {});
+      assertOk(Model.fromUnknown({ enabled: null }), { enabled: true });
+      assertOk(Model.fromUnknown({ enabled: false }), { enabled: false });
+      assertEqual(Model.to({ enabled: true }), { enabled: true });
+      assertEqual(Model.to({}), {});
+    });
+
+    it("retains error paths, all errors, and never reads accessors", () => {
+      const Model = object({
+        enabled: withDefault(optional(BooleanFromString), true, {
+          strategy: "preserve",
+        }),
+        count: Int64FromInt64String,
+      });
+      const failed = Model.fromUnknown(
+        { enabled: "bad", count: "bad" },
+        { errors: "all" },
+      );
+      assertErr(failed);
+      const issues = typeErrorToIssues(Model, failed.error);
+      assertEqual(
+        issues.map((issue) => issue.path),
+        [["enabled"], ["count"]],
+      );
+      assertTrue(Model.formatError(failed.error).length > 0);
+      const invalidUnion = withDefault(nullOr(BooleanFromString), true, {
+        strategy: "preserve",
+      });
+      const result = invalidUnion.fromUnknown("bad");
+      assertErr(result);
+      assertTrue(invalidUnion.formatError(result.error).length > 0);
+
+      let reads = 0;
+      const input = {
+        get enabled() {
+          reads++;
+          return "true";
+        },
+        count: "42",
+      };
+      assertErr(Model.fromUnknown(input));
+      assertEqual(reads, 0);
+      assertErr(Model.fromUnknown({ extra: 1, count: "42" }));
+      assertErr(Model.fromUnknown(null));
+      assertErr(Model.fromUnknown([]));
+      assertThrowsInstanceOf(
+        () =>
+          Model.to({
+            enabled: { value: true, defaultUsed: false },
+            count: 0 as never,
+          }),
+        Error,
+      );
+    });
+  });
+
+  it("rejects invalid declarations and explicit replacement strategies", () => {
+    assertThrowsInstanceOf(
+      () => withDefault(optional(Boolean), null as never),
+      Error,
     );
-    assertEqual(
-      Transformed.formatError({
-        type: "Record",
-        reason: {
-          kind: "Entries",
-          issues: [
-            {
-              kind: "Collision",
-              key: "a",
-              previousKey: "A",
-              outputKey: "a",
-            },
-          ],
-        },
-      }),
-      'Record keys "A" and "a" decode to the same key "a".',
+    assertThrowsInstanceOf(
+      () => withDefault(nullOr(Boolean), "true" as never),
+      Error,
     );
+    for (const strategy of ["replace", "other"]) {
+      for (const property of [Boolean, optional(Boolean)]) {
+        const error = assertThrowsInstanceOf(
+          () =>
+            withDefault(property as never, true, {
+              strategy: strategy as never,
+            }),
+          Error,
+        );
+        assertEqual(
+          error.message,
+          'withDefault strategy must be omitted or "preserve".',
+        );
+      }
+    }
+    if (false as boolean) {
+      // @ts-expect-error withDefault requires an optional property or a Type whose Output includes null or undefined.
+      withDefault(Boolean, true);
+      // @ts-expect-error withDefault requires an optional property or a Type whose Output includes null or undefined.
+      withDefault(Boolean, true, { strategy: "preserve" });
+      // @ts-expect-error A Boolean default must be a decoded boolean.
+      withDefault(nullOr(BooleanFromString), "true");
+      // @ts-expect-error A Boolean default cannot be null.
+      withDefault(optional(Boolean), null);
+      // @ts-expect-error The default value is required.
+      withDefault(optional(Boolean));
+      // @ts-expect-error A Boolean default must be passed directly, not wrapped in options.
+      withDefault(optional(Boolean), { value: true });
+      // @ts-expect-error The third argument must explicitly request preservation.
+      withDefault(optional(Boolean), true, {});
+      // @ts-expect-error Explicit replacement strategies are not accepted.
+      withDefault(optional(Boolean), true, { strategy: "replace" });
+      // @ts-expect-error Explicit replacement strategies are not accepted.
+      withDefault(nullOr(Boolean), true, { strategy: "replace" });
+      const replacement = { strategy: "replace" } as const;
+      // @ts-expect-error Explicit replacement strategies are not accepted, including in variables.
+      withDefault(optional(Boolean), true, replacement);
+      // @ts-expect-error Explicit replacement strategies are not accepted, including in variables.
+      withDefault(nullOr(Boolean), true, replacement);
+      const uncertain = optional(Boolean) as OptionalProperty<
+        typeof Boolean | typeof String
+      >;
+      // @ts-expect-error Property must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
+      withDefault(uncertain, true);
+      const erased = optional(Boolean) as OptionalProperty<TypeNode>;
+      // @ts-expect-error Property must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
+      withDefault(erased, true);
+      const Conflicting = createType(
+        "WithDefault",
+        (_value): Result<boolean, TypeError<"WithDefault">> =>
+          err({ type: "WithDefault" }),
+        () => "Invalid flag.",
+      );
+      // @ts-expect-error Error type must not duplicate an error inherited from the parent Type.
+      withDefault(Conflicting, true);
+      // @ts-expect-error Error type must not duplicate an error inherited from the parent Type.
+      withDefault(optional(Conflicting), true, { strategy: "preserve" });
+      // @ts-expect-error Output properties with defaults are required.
+      const invalid: typeof objectWithDefault.Output = {};
+      void invalid;
+    }
+    const objectWithDefault = object({
+      value: withDefault(optional(Boolean), true),
+    });
+    assertOk(objectWithDefault.fromUnknown({}), { value: true });
   });
 });
 
@@ -16223,60 +18775,126 @@ describe("object", () => {
       >();
     });
 
-    it("omit removes declared properties and preserves an Object Record", () => {
-      const User = object({ name: String, age: Number });
-      const WithoutAge = omit(User, "age");
-      const WithoutNameAndAge = omit(User, "name", "age");
-      const keys = ["name", "age"] as const;
-      const Empty = omit(User, ...keys);
+    describe("omit", () => {
+      it("removes declared properties and preserves an Object Record", () => {
+        const User = object({ name: String, age: Number });
+        const WithoutAge = omit(User, "age");
+        const WithoutNameAndAge = omit(User, "name", "age");
+        const keys = ["name", "age"] as const;
+        const Empty = omit(User, ...keys);
 
-      assertEqual(WithoutAge.props, { name: String });
-      assertOk(WithoutAge.fromUnknown({ name: "Ada" }), { name: "Ada" });
-      assertFalse(WithoutAge.fromUnknown({ name: "Ada", age: 1 }).ok);
-      assertType<
-        typeof WithoutAge,
-        ObjectType<{ readonly name: typeof String }>
-      >();
-      assertEqual(WithoutNameAndAge.props, {});
-      assertOk(WithoutNameAndAge.fromUnknown({}), {});
-      assertType<typeof WithoutNameAndAge, ObjectType<{}>>();
-      assertEqual(Empty.props, {});
-      assertType<typeof Empty, ObjectType<{}>>();
-
-      const compileTimeAssertions = (
-        key: "name" | "age",
-        keys: ReadonlyArray<"name" | "age">,
-      ) => {
-        // @ts-expect-error A runtime key must identify one statically known property.
-        omit(User, key);
-        // @ts-expect-error A runtime array does not guarantee which properties are omitted.
-        omit(User, ...keys);
-      };
+        assertEqual(WithoutAge.props, { name: String });
+        assertOk(WithoutAge.fromUnknown({ name: "Ada" }), { name: "Ada" });
+        assertFalse(WithoutAge.fromUnknown({ name: "Ada", age: 1 }).ok);
+        assertType<
+          typeof WithoutAge,
+          ObjectType<{ readonly name: typeof String }>
+        >();
+        assertEqual(WithoutNameAndAge.props, {});
+        assertOk(WithoutNameAndAge.fromUnknown({}), {});
+        assertType<typeof WithoutNameAndAge, ObjectType<{}>>();
+        assertEqual(Empty.props, {});
+        assertType<typeof Empty, ObjectType<{}>>();
+
+        const compileTimeAssertions = (
+          key: "name" | "age",
+          keys: ReadonlyArray<"name" | "age">,
+        ) => {
+          // @ts-expect-error A runtime key must identify one statically known property.
+          omit(User, key);
+          // @ts-expect-error A runtime array does not guarantee which properties are omitted.
+          omit(User, ...keys);
+        };
 
-      const Metadata = object(
-        { name: String, age: Number },
-        record(String, Unknown),
-      );
-      const MetadataWithoutAge = omit(Metadata, "age");
+        const Metadata = object(
+          { name: String, age: Number },
+          record(String, Unknown),
+        );
+        const MetadataWithoutAge = omit(Metadata, "age");
 
-      assertSame(MetadataWithoutAge.record, Metadata.record);
-      assertType<
-        typeof MetadataWithoutAge,
-        ObjectType<
-          { readonly name: typeof String },
-          RecordType<typeof String, typeof Unknown>
-        >
-      >();
-      assertOk(
-        MetadataWithoutAge.fromUnknown({ name: "Ada", age: "unknown" }),
-        { name: "Ada", age: "unknown" },
-      );
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+        assertSame(MetadataWithoutAge.record, Metadata.record);
+        assertType<
+          typeof MetadataWithoutAge,
+          ObjectType<
+            { readonly name: typeof String },
+            RecordType<typeof String, typeof Unknown>
+          >
+        >();
+        assertOk(
+          MetadataWithoutAge.fromUnknown({ name: "Ada", age: "unknown" }),
+          { name: "Ada", age: "unknown" },
+        );
+        assertType<
+          typeof compileTimeAssertions extends (
+            ...args: Array<never>
+          ) => unknown
+            ? true
+            : false,
+          true
+        >();
+      });
+
+      it("retains defaulted fields and can remove every default", () => {
+        const Model = object({
+          enabled: withDefault(optional(Boolean), true),
+          tracked: withDefault(optional(Boolean), false, {
+            strategy: "preserve",
+          }),
+          name: String,
+        });
+        const Defaults = omit(Model, "name");
+        assertType<typeof Defaults.Output.enabled, boolean>();
+        assertType<
+          typeof Defaults.Output.tracked,
+          Defaulted<boolean, false, "missing">
+        >();
+        const decoded = Defaults.orThrow({});
+        assertEqual(decoded, {
+          enabled: true,
+          tracked: { value: false, defaultUsed: true, original: "missing" },
+        });
+        assertEqual(Defaults.to(decoded), { enabled: true });
+        const Named = omit(Model, "enabled", "tracked");
+        assertType<
+          typeof Named,
+          ObjectType<{ readonly name: typeof String }>
+        >();
+        assertOk(Named.fromUnknown({ name: "Ada" }), { name: "Ada" });
+        assertErr(Named.fromUnknown({ name: "Ada", enabled: true }));
+        const Empty = omit(Model, "enabled", "tracked", "name");
+        assertType<typeof Empty, ObjectType<{}>>();
+        assertOk(Empty.fromUnknown({}), {});
+      });
+
+      it("preserves rest record inference when retaining or removing a default", () => {
+        const Model = object(
+          {
+            enabled: withDefault(optional(Boolean), true),
+            name: String,
+          },
+          record(String, Unknown),
+        );
+        const Defaults = omit(Model, "name");
+        assertSame(Defaults.record, Model.record);
+        assertType<typeof Defaults.Output.enabled, boolean>();
+        assertOk(Defaults.fromUnknown({ other: "value" }), {
+          enabled: true,
+          other: "value",
+        });
+        const Named = omit(Model, "enabled");
+        assertType<
+          typeof Named,
+          ObjectType<
+            { readonly name: typeof String },
+            RecordType<typeof String, typeof Unknown>
+          >
+        >();
+        assertSame(Named.record, Model.record);
+        assertOk(Named.fromUnknown({ name: "Ada", enabled: "rest" }), {
+          name: "Ada",
+          enabled: "rest",
+        });
+      });
     });
   });
 });
@@ -19753,6 +22371,39 @@ describe("json", () => {
     }
   });
 
+  it("formats plain and localized orThrow failures without parsing twice", () => {
+    const [ValueJson] = json(String, "ValueJson");
+    const LocalizedValueJson = localizeTypes(
+      { ValueJson },
+      {
+        test: {
+          Json: () => "Localized Json.",
+          String: () => "Localized String.",
+        },
+      },
+    ).test.ValueJson;
+
+    for (const type of [ValueJson, LocalizedValueJson]) {
+      for (const input of ["1", "{"]) {
+        const result = type.fromUnknown(input);
+        assertErr(result);
+        const message = type.formatError(result.error);
+        const parse = mock.method(JSON, "parse");
+
+        try {
+          assertAssertionError(
+            () => type.orThrow(input),
+            message,
+            result.error,
+          );
+          assertEqual(parse.mock.callCount(), 1);
+        } finally {
+          parse.mock.restore();
+        }
+      }
+    }
+  });
+
   it("accepts only Types with a JSON-compatible canonical Input", () => {
     const compileTimeAssertions = () => {
       interface StringTree {
@@ -20463,3 +23114,309 @@ describe("design decisions", () => {
     });
   });
 });
+
+describe("BooleanFromString", () => {
+  it("parses exactly true and false", () => {
+    assertOk(BooleanFromString.fromUnknown("true"), true);
+    assertOk(BooleanFromString.fromUnknown("false"), false);
+
+    assertEqual(BooleanFromString.to(true), "true");
+    assertEqual(BooleanFromString.to(false), "false");
+  });
+
+  it("rejects other strings and non-strings", () => {
+    for (const value of [
+      "TRUE",
+      "False",
+      "1",
+      "0",
+      "yes",
+      "no",
+      "on",
+      "off",
+      " true",
+      "",
+    ]) {
+      const invalid = BooleanFromString.fromUnknown(value);
+      assertErr(invalid, { type: "BooleanFromString", value });
+      assertEqual(
+        BooleanFromString.formatError(invalid.error),
+        `The value ${JSON.stringify(value)} is not a boolean. Use true or false.`,
+      );
+    }
+
+    assertErr(BooleanFromString.fromUnknown(true), {
+      type: "TypeOf",
+      expected: "String",
+      value: true,
+    });
+  });
+});
+
+describe("IntFromString", () => {
+  it("parses decimal integers", () => {
+    assertOk(IntFromString.fromUnknown("4000"), 4000);
+    assertOk(IntFromString.fromUnknown("-1"), -1);
+    assertOk(IntFromString.fromUnknown("007"), 7);
+    assertOk(
+      IntFromString.fromUnknown("9007199254740991"),
+      globalThis.Number.MAX_SAFE_INTEGER,
+    );
+    assertOk(
+      IntFromString.fromUnknown("-9007199254740991"),
+      globalThis.Number.MIN_SAFE_INTEGER,
+    );
+    assertEqual(IntFromString.to(IntFromString.orThrow("42")), "42");
+
+    const negativeZero = IntFromString.orThrow("-0");
+    assertSame(negativeZero, -0);
+    assertEqual(IntFromString.to(negativeZero), "-0");
+
+    {
+      const value = IntFromString.orThrow("1");
+      assertType<typeof value, Int>();
+    }
+  });
+
+  it("rejects non-integer text", () => {
+    for (const value of ["", " 1", "1 ", "+1", "1.5", "1e3", "0x10", "NaN"]) {
+      const invalid = IntFromString.fromUnknown(value);
+      assertErr(invalid, { type: "IntFromString", value });
+      assertEqual(
+        IntFromString.formatError(invalid.error),
+        `The value ${JSON.stringify(value)} is not a decimal integer.`,
+      );
+    }
+  });
+
+  it("validates parsed numbers with Int", () => {
+    for (const value of [
+      "9007199254740992",
+      "9007199254740993",
+      "-9007199254740992",
+      "-9007199254740993",
+    ]) {
+      const number = globalThis.Number(value);
+      const invalid = IntFromString.fromUnknown(value);
+      assertErr(invalid, {
+        type: "IntFromString",
+        outputError: { type: "Int", value: number },
+      });
+      assertEqual(
+        IntFromString.formatError(invalid.error),
+        `The value ${number} must be a safe integer.`,
+      );
+    }
+
+    const value = "9".repeat(309);
+    const invalid = IntFromString.fromUnknown(value);
+    assertErr(invalid, {
+      type: "IntFromString",
+      outputError: {
+        type: "Finite",
+        value: globalThis.Number.POSITIVE_INFINITY,
+      },
+    });
+    assertEqual(
+      IntFromString.formatError(invalid.error),
+      "The value Infinity must be finite.",
+    );
+  });
+});
+
+describe("objectKeys", () => {
+  it("includes missing and excess properties in the error type", () => {
+    const Model = objectKeys(String)(object({ port: Number }));
+    const result = Model.fromUnknown({ extra: 0 }, { errors: "all" });
+    assertErr(result);
+    assertTrue("error" in result.error);
+    const error = result.error.error;
+    assertTrue(error.reason.kind === "Properties");
+    const errors = error.reason.errors;
+
+    assertType<
+      (typeof errors)[string],
+      | TypeOfError<"Number">
+      | ObjectPropertyAccessError
+      | ObjectMissingPropertyError
+      | ObjectExcessPropertyError
+      | undefined
+    >();
+    assertEqual(errors.port, { type: "ObjectMissingProperty" });
+    assertEqual(errors.extra, { type: "ObjectExcessProperty" });
+  });
+
+  it("uses canonical key encodings and retains field codecs and optionality", () => {
+    const Key = prefixed("APP_")(CamelCaseIdentifierFromConstantCaseIdentifier);
+    const Output = object({
+      http2Port: PortFromString,
+      displayName: optional(String),
+    });
+    const Env = objectKeys(Key)(Output);
+    const result = Env.fromUnknown({ APP_HTTP2_PORT: "04000" });
+    assertOk(result, { http2Port: 4000 });
+    assertType<typeof result.value, typeof Output.Output>();
+    assertType(Env, result.value);
+    assertSame(Env.key, Key);
+    assertSame(Env.output, Output);
+    assertEqual(Env.to(result.value), { APP_HTTP2_PORT: "4000" });
+    assertOk(Env.from.parent({ APP_HTTP2_PORT: "4000" }), result.value);
+    assertOk(Env.from(result.value), result.value);
+    assertTrue(Env.is(result.value));
+    assertFalse(Env.is({ http2Port: "4000" }));
+    assertEqual(Env.orNull({ APP_HTTP2_PORT: "invalid" }), null);
+    assertOk(
+      Env.fromUnknown({ APP_HTTP2_PORT: "4000", APP_DISPLAY_NAME: "" }),
+      { http2Port: 4000, displayName: "" },
+    );
+    for (const value of [
+      null,
+      [],
+      { http2Port: "4000" },
+      { APP_HTTP2_PORT: "4000", HOME: "" },
+      { APP_HTTP2_PORT: "4000", APP_DISPLAY_NAME: undefined },
+    ]) {
+      assertErr(Env.fromUnknown(value));
+    }
+    nodeAssert.throws(() => Env.to({ http2Port: 65536 as Port }));
+    const outputError: TransformOutputError<
+      "ObjectKeys",
+      InferErrors<typeof Output>
+    > = {
+      type: "ObjectKeys",
+      outputError: {
+        type: "Object",
+        reason: { kind: "NotObject", value: null },
+      },
+    };
+    assertEqual(typeErrorToIssues(Env, outputError)[0]?.path, []);
+    assertEqual(objectKeys(Key)(object({})).to({}), {});
+  });
+
+  it("preserves external paths, nested paths, descriptors, and unknown-key errors", () => {
+    const [Payload] = json(object({ items: array(Int) }), "ObjectKeysPayload");
+    const Key = prefixed("APP_")(CamelCaseIdentifierFromConstantCaseIdentifier);
+    const Env = objectKeys(Key)(
+      object({ payload: Payload, port: PortFromString }),
+    );
+    const result = Env.fromUnknown(
+      { APP_PAYLOAD: '{"items":["bad"]}', APP_EXTRA: "value" },
+      { errors: "all" },
+    );
+    assertErr(result);
+    assertEqual(
+      typeErrorToIssues(Env, result.error).map(({ path }) => path),
+      [["APP_PAYLOAD", "items", 0], ["APP_PORT"], ["APP_EXTRA"]],
+    );
+    let reads = 0;
+    const accessor = globalThis.Object.defineProperty(
+      { APP_PORT: "4000" },
+      "APP_PAYLOAD",
+      {
+        enumerable: true,
+        get: () => {
+          reads++;
+          return "{}";
+        },
+      },
+    );
+    assertErr(Env.fromUnknown(accessor));
+    assertEqual(reads, 0);
+    assertErr(
+      Env.fromUnknown(
+        globalThis.Object.defineProperty({ APP_PORT: "4000" }, "APP_PAYLOAD", {
+          value: "{}",
+        }),
+      ),
+    );
+    const SpecialKey = transform("SpecialObjectKey", String, String, {
+      from: (value) => ok(value === "__proto__" ? "proto" : value),
+      to: (value) => (value === "proto" ? "__proto__" : value),
+    });
+    const Special = objectKeys(SpecialKey)(
+      object({ proto: String, constructor: optional(String) }),
+    );
+    const special = Special.orThrow({ ["__proto__"]: "safe" });
+    assertEqual(special, { proto: "safe" });
+    assertEqual(Special.to(special), { ["__proto__"]: "safe" });
+    const source = globalThis.Object.assign(globalThis.Object.create(null), {
+      ["__proto__"]: "safe",
+    });
+    assertOk(Special.fromUnknown(source), special);
+  });
+
+  it("rejects invalid keys, duplicate encodings, and broken key codecs at construction", () => {
+    nodeAssert.throws(() =>
+      objectKeys(CamelCaseIdentifierFromConstantCaseIdentifier)(
+        object({ BadKey: String }),
+      ),
+    );
+    const Broken = transform("BrokenObjectKey", String, String, {
+      from: (value) => ok(value),
+      to: () => "first",
+    });
+    nodeAssert.throws(
+      () => objectKeys(Broken)(object({ first: String, second: String })),
+      /Duplicate encoded object key/u,
+    );
+    nodeAssert.throws(
+      () => objectKeys(Broken)(object({ second: String })),
+      /decode its encoding/u,
+    );
+    const Rejecting = transform(
+      "RejectingObjectKey",
+      String,
+      String,
+      {
+        from: () => err({ type: "RejectingObjectKey" as const }),
+        to: (value) => value,
+      },
+      () => "Rejected key.",
+    );
+    nodeAssert.throws(
+      () => objectKeys(Rejecting)(object({ key: String })),
+      /decode its encoding/u,
+    );
+  });
+
+  it("requires string key codecs and a concrete strict object", () => {
+    const reject = () => {
+      // @ts-expect-error Key Output must be string.
+      objectKeys(PortFromString);
+      // @ts-expect-error objectKeys requires a strict Object Type without a record rest.
+      objectKeys(String)(object({}, record(String, String)));
+      // @ts-expect-error objectKeys requires an Object Type.
+      objectKeys(String)(String);
+      const objectType = (true as boolean)
+        ? object({ name: String })
+        : object({ age: Number });
+      // @ts-expect-error Output Type must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
+      objectKeys(String)(objectType);
+    };
+    assertType<typeof reject, () => void>();
+  });
+});
+
+describe("CamelCaseIdentifierFromConstantCaseIdentifier", () => {
+  it("preserves identifier word boundaries in both directions", () => {
+    for (const [encoded, decoded] of [
+      ["PORT", "port"],
+      ["HTTP2_PORT", "http2Port"],
+      ["H_T_T_P", "hTTP"],
+    ]) {
+      const result =
+        CamelCaseIdentifierFromConstantCaseIdentifier.fromUnknown(encoded);
+      assertOk(result, decoded);
+      assertEqual(
+        CamelCaseIdentifierFromConstantCaseIdentifier.to(result.value),
+        encoded,
+      );
+    }
+    assertErr(
+      CamelCaseIdentifierFromConstantCaseIdentifier.fromUnknown("HTTP__PORT"),
+    );
+    assertErr(
+      CamelCaseIdentifierFromConstantCaseIdentifier.fromUnknown("http_PORT"),
+    );
+  });
+});