@evolu/common 8.9.0 → 8.10.0

package/dist/src/Type.js

@@ -341,9 +341,9 @@
  * parameter type. If application code claims an accessor-backed object or an
  * object with excess properties is an Object Output, the assertion throws
  * because the application contract is broken. `orThrow` and `orNull` preserve
- * the assertion at their typed `Input` boundary, then apply {@link getOrThrow}
- * or {@link getOrNull} only to validation failures returned by the remaining
- * pipeline.
+ * the assertion at their typed `Input` boundary. After that boundary, `orThrow`
+ * throws returned validation errors with a formatted message and the original
+ * error as `cause`, while `orNull` maps them to `null`.
  *
  * Consequently, structural representation errors such as sparse Arrays,
  * accessors, and excess properties normally do not enter user-facing validation
@@ -454,12 +454,54 @@ import * as bip39 from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
 import { createMutableArray, } from "./Array.js";
 import { assert, assertNonNullable } from "./Assert.js";
+import { eqData } from "./Eq.js";
 import { identity } from "./Function.js";
-import { createMutableRecord, getObjectKind, isPlainObject } from "./Object.js";
+import { createMutableRecord, getObjectKind, isPlainObject, } from "./Object.js";
 import { hasNodeBuffer } from "./Platform.js";
-import { err, flatMapResult, getOk, getOrNull, getOrThrow, ok, trySync, } from "./Result.js";
+import { err, flatMapResult, getOk, getOrNull, ok, trySync, } from "./Result.js";
 import { safelyStringifyUnknownValue } from "./String.js";
 import { instance, isInstance, } from "./Types.js";
+/**
+ * Converts an error from a {@link Type} into formatted issues with paths.
+ *
+ * Pass the Type that produced the error. This uses its nested and localized
+ * formatters without validating the input again. To retain every issue, decode
+ * with `{ errors: "all" }`; this function cannot recover errors omitted during
+ * validation. A root issue has an empty path.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   IntFromString,
+ *   object,
+ *   typeErrorToIssues,
+ * } from "@evolu/common";
+ *
+ * const Settings = object({ port: IntFromString });
+ *
+ * const result = Settings.fromUnknown({ port: "http" }, { errors: "all" });
+ * assertErr(result);
+ *
+ * assertEqual(typeErrorToIssues(Settings, result.error), [
+ *   {
+ *     path: ["port"],
+ *     message: 'The value "http" is not a decimal integer.',
+ *   },
+ * ]);
+ * ```
+ *
+ * @group Core
+ */
+export const typeErrorToIssues = (type, error) => {
+    const runtimeType = type;
+    return runtimeType[getRuntimeTypeIssuesSymbol](error, "all").map((issue) => ({
+        path: issue.path,
+        message: formatRuntimeTypeIssue(issue),
+    }));
+};
 const outputValidationSymbol = 
 /*#__PURE__*/ globalThis.Symbol();
 const getRuntimeTypeIssuesSymbol = 
@@ -492,6 +534,23 @@ const createCollectionRuntimeTypeIssues = (name, issuesKind, defaultFormatter, g
     });
 };
 const formatDefaultRuntimeTypeIssue = (issue) => issue.formatError(issue.error);
+const formatRuntimeTypeIssue = (issue, formatIssue = formatDefaultRuntimeTypeIssue) => {
+    const summary = formatIssue(issue);
+    if (issue.alternatives === undefined)
+        return summary;
+    return [
+        summary,
+        ...issue.alternatives.flatMap(({ index, name, issues }) => issues.map((issue) => {
+            const path = issue.path
+                .map((key) => typeof key === "string"
+                ? `[${JSON.stringify(key)}]`
+                : `[${globalThis.String(key)}]`)
+                .join("");
+            const message = formatRuntimeTypeIssue(issue, formatIssue).replaceAll("\n", "\n  ");
+            return `- ${index}: ${name}${path}: ${message}`;
+        })),
+    ].join("\n");
+};
 export function assertType(type, value) {
     if (type === undefined)
         return;
@@ -530,6 +589,11 @@ const assertTypeOutput = (name, is, validateOutput, value, options = firstValida
  * that produced them. Different localized Type sets can coexist in separate
  * application or dependency-injection scopes.
  *
+ * A Union formatter supplies the summary of the failure. Retained member
+ * failures are appended using their own localized formatters, with member
+ * indexes, Type names, and paths identifying each alternative. The Union still
+ * produces one issue at its enclosing path.
+ *
  * Localization is scoped to the selected Types instead of a package-wide
  * translation registry. Static imports give bundlers an explicit dependency
  * graph, so unrelated Types, locales, and formatters can be removed. Bundling
@@ -670,17 +734,26 @@ const withFormatError = (source, formatIssue, localizedTypeBySource) => {
     const parent = source.parent
         ? withFormatError(source.parent, formatIssue, localizedTypeBySource)
         : null;
-    const getTypeIssues = (error, mode) => source[getRuntimeTypeIssuesSymbol](error, mode).map((issue) => ({
+    const localizeIssue = (issue) => ({
         ...issue,
         formatError: () => formatIssue(issue),
-    }));
+        ...(issue.alternatives === undefined
+            ? {}
+            : {
+                alternatives: issue.alternatives.map((alternative) => ({
+                    ...alternative,
+                    issues: alternative.issues.map(localizeIssue),
+                })),
+            }),
+    });
+    const getTypeIssues = (error, mode) => source[getRuntimeTypeIssuesSymbol](error, mode).map(localizeIssue);
     const derived = createTypeNode(source.name, parent, source.fromUnknown, source.is, source[outputValidationSymbol], source[fromSymbol], source[encoderSymbol].parent ?? source[encoderSymbol], getTypeIssues, undefined, formatIssue);
     // Localization changes error rendering, not conversion semantics. Preserve
     // specialized public input operations such as json's single-parse Json
     // boundary. Private operation chains on derived still support composition.
     globalThis.Object.assign(derived, {
         from: source.from,
-        orThrow: source.orThrow,
+        orThrow: createRuntimeOrThrow(getTerminalRuntimeNode(source.from), derived.formatError),
         orNull: source.orNull,
     });
     localizedTypeBySource.set(source, derived);
@@ -712,7 +785,12 @@ const localizeTypeReflection = (value, formatIssue, localizedTypeBySource) => {
         return value;
     const localized = globalThis.Object.create(globalThis.Object.getPrototypeOf(value));
     for (const key of Reflect.ownKeys(value)) {
-        localized[key] = localizeTypeReflection(value[key], formatIssue, localizedTypeBySource);
+        const property = value[key];
+        // Configured defaults are opaque data whose identity must be preserved.
+        localized[key] =
+            key === "value" && globalThis.Object.hasOwn(value, defaultPropertySymbol)
+                ? property
+                : localizeTypeReflection(property, formatIssue, localizedTypeBySource);
     }
     return localized;
 };
@@ -728,6 +806,51 @@ const assertRefinementIdentity = (refinement) => (value) => {
     }
     return result;
 };
+/**
+ * Creates a root {@link Type} with a custom error for an existing validator.
+ *
+ * The source must use identity encoding. The new Type accepts its Output as
+ * Input and hides its parent boundaries. Validation and error collection are
+ * delegated automatically; the mapper receives the failure and original value.
+ * The formatter presents the mapped error as one issue.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   createTypeWithError,
+ *   Number,
+ *   String,
+ *   union,
+ *   type TypeError,
+ *   type UnionError,
+ * } from "@evolu/common";
+ *
+ * interface ValueError extends TypeError<"Value"> {
+ *   readonly cause: UnionError;
+ * }
+ *
+ * const Value = createTypeWithError(
+ *   "Value",
+ *   union(String, Number),
+ *   (cause): ValueError => ({ type: "Value", cause }),
+ *   () => "Enter text or a number.",
+ * );
+ *
+ * const result = Value.fromUnknown(false, { errors: "all" });
+ * assertErr(result);
+ * assertEqual(result.error.cause.errors.length, 2);
+ * assertEqual(Value.formatError(result.error), "Enter text or a number.");
+ * ```
+ *
+ * @group Construction
+ */
+export const createTypeWithError = (name, type, mapError, formatError) => createRootType(name, (value, options) => {
+    const result = type.fromUnknown(value, options);
+    return result.ok ? result : err(mapError(result.error, value));
+}, formatError);
 const createRootType = (name, fromUnknown, formatError, getTypeIssues) => {
     const runtimeFormatError = formatError;
     const runtimeGetTypeIssues = getTypeIssues ??
@@ -826,6 +949,11 @@ const fromSymbol =
 const templateLiteralSyntaxSymbol = 
 /*#__PURE__*/ globalThis.Symbol();
 const mapRuntimeResult = (operation, map) => (value, options = firstValidationOptions) => map(operation(value, options), options);
+const createRuntimeOrThrow = (fromInput, formatError) => mapRuntimeResult(fromInput, (result) => {
+    if (result.ok)
+        return result.value;
+    throw new Error(formatError(result.error), { cause: result.error });
+});
 // `map` must return a fresh operation because this function can attach `.parent`.
 const mapRuntimeOperations = (operation, map) => {
     const mapped = map(operation);
@@ -863,7 +991,7 @@ const createTypeNode = (name, parent, fromUnknown, is, validateOutput, from, own
         : ownTo;
     const runtimeFormatError = runtimeParent?.[getRuntimeTypeIssuesSymbol] === getTypeIssues
         ? runtimeParent.formatError
-        : (error) => formatIssue(getTypeIssues(error, "first")[0]);
+        : (error) => formatRuntimeTypeIssue(getTypeIssues(error, "first")[0], formatIssue);
     const typedFrom = addRuntimeAssertions(name, is, validateOutput, parent, from);
     const fromInput = getTerminalRuntimeNode(typedFrom);
     const typedTo = mapRuntimeOperations(to, (operation) => (value) => {
@@ -879,7 +1007,7 @@ const createTypeNode = (name, parent, fromUnknown, is, validateOutput, from, own
         is,
         from: typedFrom,
         to: typedTo,
-        orThrow: mapRuntimeResult(fromInput, getOrThrow),
+        orThrow: createRuntimeOrThrow(fromInput, runtimeFormatError),
         orNull: mapRuntimeResult(fromInput, getOrNull),
         "~standard": createStandardSchemaProps(fromUnknown, getTypeIssues, formatIssue),
         ...additionalProperties,
@@ -899,7 +1027,7 @@ const createStandardSchemaProps = (fromUnknown, getTypeIssues, formatIssue) => (
             ? { value: result.value }
             : {
                 issues: getTypeIssues(result.error, "all").map((issue) => ({
-                    message: formatIssue(issue),
+                    message: formatRuntimeTypeIssue(issue, formatIssue),
                     path: issue.path,
                 })),
             };
@@ -1035,6 +1163,7 @@ export const String = /*#__PURE__*/ createTypeOfType("String");
  * >();
  *
  * assertOk(Age.fromUnknown(122), 122);
+ *
  * const invalid = Age.fromUnknown(200);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -1060,6 +1189,46 @@ export const BigInt = /*#__PURE__*/ createTypeOfType("BigInt");
  * @group Base
  */
 export const Boolean = /*#__PURE__*/ createTypeOfType("Boolean");
+/**
+ * Transforms a boolean spelled as text into a {@link Boolean}.
+ *
+ * This is useful for inputs that carry booleans as text, such as environment
+ * variables, URL query parameters, and form fields. Exactly `true` and `false`
+ * are accepted, the spellings JSON and JavaScript use, so a boolean has one
+ * representation in every source.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   BooleanFromString,
+ * } from "@evolu/common";
+ *
+ * assertOk(BooleanFromString.fromUnknown("true"), true);
+ * assertOk(BooleanFromString.fromUnknown("false"), false);
+ * assertEqual(BooleanFromString.to(true), "true");
+ *
+ * const invalid = BooleanFromString.fromUnknown("yes");
+ * assertErr(invalid, { type: "BooleanFromString", value: "yes" });
+ * assertEqual(
+ *   BooleanFromString.formatError(invalid.error),
+ *   'The value "yes" is not a boolean. Use true or false.',
+ * );
+ * ```
+ *
+ * @group Base
+ */
+export const BooleanFromString = /*#__PURE__*/ transform("BooleanFromString", String, Boolean, {
+    from: (value) => value === "true"
+        ? ok(true)
+        : value === "false"
+            ? ok(false)
+            : err({ type: "BooleanFromString", value }),
+    to: (value) => (value ? "true" : "false"),
+}, (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a boolean. Use true or false.`);
 /**
  * A JavaScript symbol {@link Type}.
  *
@@ -1188,6 +1357,7 @@ export const instanceOf = (constructor) => {
  *
  * assertType<typeof Ready.Output, "ready">();
  * assertOk(Ready.fromUnknown("ready"), "ready");
+ *
  * const invalid = Ready.fromUnknown("pending");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -1241,9 +1411,8 @@ export function union(...typesOrLiterals) {
     const inputMembers = members.map(getTerminalRuntimeNode);
     const inputFrom = createUnionValidation(inputMembers, (member, value, options) => member.fromUnknown(value, options));
     const inputValidateOutput = createUnionValidation(inputMembers, (member, value, options) => member[outputValidationSymbol](value, options));
-    const defaultFormatter = (() => "A value does not match any allowed variant.");
-    const getTypeIssues = (error) => singleRuntimeTypeIssue("Union", error, defaultFormatter);
-    const input = createTypeNode("Union", null, inputFrom, (value) => inputMembers.some((member) => member.is(value)), inputValidateOutput, ok, identity, getTypeIssues);
+    const getTypeIssues = createUnionRuntimeTypeIssues(members);
+    const input = createTypeNode("Union", null, inputFrom, (value) => inputMembers.some((member) => member.is(value)), inputValidateOutput, ok, identity, createUnionRuntimeTypeIssues(inputMembers));
     const fromUnknown = createUnionValidation(members, (member, value, options) => member.fromUnknown(value, options));
     const validateOutput = createUnionValidation(members, (member, value, options) => member[outputValidationSymbol](value, options));
     const memberFromInputs = members.map((member) => getTerminalRuntimeNode(member[fromSymbol]));
@@ -1259,6 +1428,19 @@ export function union(...typesOrLiterals) {
     };
     return createTypeNode("Union", input, fromUnknown, (value) => members.some((member) => member.is(value)), validateOutput, from, to, getTypeIssues, { members, [templateLiteralSyntaxSymbol]: true });
 }
+const createUnionRuntimeTypeIssues = (members) => (error) => [
+    {
+        name: "Union",
+        error,
+        path: [],
+        formatError: () => "A value does not match any allowed variant.",
+        alternatives: error.errors.map(({ index, error }) => ({
+            index,
+            name: members[index].name,
+            issues: members[index][getRuntimeTypeIssuesSymbol](error, "all"),
+        })),
+    },
+];
 const createUnionValidation = (members, validateMember) => (value, options = firstValidationOptions) => {
     let errors;
     for (let index = 0; index < members.length; index++) {
@@ -1398,6 +1580,7 @@ const isRuntimeUnionTypeNode = (type) => type.name === "Union" && "members" in t
  * assertOk(result, ["cs", "CZ"]);
  * const locale = result.value;
  * assertType<typeof locale, SupportedLocale>();
+ *
  * const invalid = SupportedLocale.fromUnknown("cs/CZ");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -1775,115 +1958,673 @@ export function brand(name, parent, validate, formatError) {
  *
  * ```ts
  * import {
- *   assertEqual,
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   Data,
+ *   DateIso,
+ * } from "@evolu/common";
+ *
+ * const value = "2023-01-01T12:00:00.000Z";
+ * assertOk(DateIso.fromUnknown(value), value);
+ *
+ * const invalid = DateIso.fromUnknown("2023-01-01");
+ * assertErr(invalid);
+ * assertType(Data, invalid.error);
+ * assertEqual(invalid.error, {
+ *   type: "DateIso",
+ *   value: "2023-01-01",
+ * });
+ * ```
+ *
+ * @group String
+ */
+export const DateIso = /*#__PURE__*/ brand("DateIso", String, (value) => value.length === 24 && new globalThis.Date(value).toJSON() === value
+    ? ok()
+    : err({ type: "DateIso", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a canonical ISO date-time string.`);
+/**
+ * Safely transforms a {@link Date} into a canonical {@link DateIso}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertOk, DateIsoFromDate } from "@evolu/common";
+ *
+ * const date = new Date("2025-01-01T12:00:00.000Z");
+ * const result = DateIsoFromDate.fromUnknown(date);
+ *
+ * assertOk(result, "2025-01-01T12:00:00.000Z");
+ * assertEqual(DateIsoFromDate.to(result.value), date);
+ * ```
+ *
+ * @group String
+ */
+export const DateIsoFromDate = /*#__PURE__*/ transform("DateIsoFromDate", Date, DateIso, {
+    from: (value) => trySync(() => globalThis.Date.prototype.toISOString.call(value), () => ({ type: "DateIsoFromDate", value })),
+    to: (value) => new globalThis.Date(value),
+}, () => "The Date cannot be represented as DateIso.");
+/**
+ * Signed 64-bit {@link BigInt}.
+ *
+ * @group Number
+ */
+export const Int64 = /*#__PURE__*/ brand("Int64", BigInt, (value) => globalThis.BigInt.asIntN(64, value) === value
+    ? ok()
+    : err({ type: "Int64", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a valid signed 64-bit integer (Int64).`);
+/**
+ * Unsigned 64-bit {@link BigInt}.
+ *
+ * @group Number
+ */
+export const UInt64 = /*#__PURE__*/ brand("UInt64", BigInt, (value) => globalThis.BigInt.asUintN(64, value) === value
+    ? ok()
+    : err({ type: "UInt64", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a valid unsigned 64-bit integer (UInt64).`);
+/**
+ * Adds identifier validation in a naming convention to an existing string Type.
+ *
+ * An identifier is one or more ASCII words, each starting with a letter and
+ * continuing with letters or digits. camelCase and PascalCase start every word
+ * after the first with an uppercase letter, so `httpUrl` has two words and
+ * `httpURL` has four. snake_case, kebab-case, and CONSTANT_CASE put exactly one
+ * separator between words. Validation keeps the spelling and rejects empty
+ * strings, whitespace, punctuation, and non-ASCII characters.
+ *
+ * Words never start with a digit. Identifier grammars in most languages forbid
+ * a leading digit, and camelCase cannot mark a word boundary before one, so the
+ * rule applies to every word and keeps every conversion exact. Join an
+ * abbreviation such as `2FA` to the previous word, as in `MAX2FA_ATTEMPTS` and
+ * `max2faAttempts`, or spell the number out, as in `TWO_FACTOR_SECRET`.
+ *
+ * Convert validated identifiers with functions such as
+ * {@link camelCaseToSnakeCase}. Conversions preserve word boundaries, and
+ * converting back restores the original spelling. They return only the
+ * destination brand, dropping unrelated constraints such as input length.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   identifier,
+ *   maxLength,
+ *   String,
+ * } from "@evolu/common";
+ *
+ * const EnvName = identifier("CONSTANT_CASE")(maxLength(16)(String));
+ *
+ * assertOk(EnvName.fromUnknown("HTTP2_PORT"), "HTTP2_PORT");
+ * assertErr(EnvName.fromUnknown("HTTP_2_PORT"));
+ * ```
+ *
+ * @group String
+ */
+export const identifier = (casing) => (parent) => {
+    const name = identifierBrandByCasing[casing];
+    const pattern = identifierPatternByCasing[casing];
+    return brand(name, parent, (value) => pattern.test(value)
+        ? ok()
+        : err({ type: name, value, casing }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a ${error.casing} identifier.`);
+};
+const identifierBrandByCasing = {
+    camelCase: "CamelCaseIdentifier",
+    PascalCase: "PascalCaseIdentifier",
+    snake_case: "SnakeCaseIdentifier",
+    "kebab-case": "KebabCaseIdentifier",
+    CONSTANT_CASE: "ConstantCaseIdentifier",
+};
+const identifierPatternByCasing = {
+    camelCase: /^[a-z][a-zA-Z0-9]*$/u,
+    PascalCase: /^[A-Z][a-zA-Z0-9]*$/u,
+    snake_case: /^[a-z][a-z0-9]*(?:_[a-z][a-z0-9]*)*$/u,
+    "kebab-case": /^[a-z][a-z0-9]*(?:-[a-z][a-z0-9]*)*$/u,
+    CONSTANT_CASE: /^[A-Z][A-Z0-9]*(?:_[A-Z][A-Z0-9]*)*$/u,
+};
+/**
+ * A validated camelCase identifier, such as `http2Port`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export const CamelCaseIdentifier = 
+/*#__PURE__*/ identifier("camelCase")(String);
+/**
+ * A validated PascalCase identifier, such as `Http2Port`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export const PascalCaseIdentifier = 
+/*#__PURE__*/ identifier("PascalCase")(String);
+/**
+ * A validated snake_case identifier, such as `http2_port`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export const SnakeCaseIdentifier = 
+/*#__PURE__*/ identifier("snake_case")(String);
+/**
+ * A validated kebab-case identifier, such as `http2-port`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export const KebabCaseIdentifier = 
+/*#__PURE__*/ identifier("kebab-case")(String);
+/**
+ * A validated CONSTANT_CASE identifier, such as `HTTP2_PORT`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
+ *
+ * @group String
+ */
+export const ConstantCaseIdentifier = 
+/*#__PURE__*/ identifier("CONSTANT_CASE")(String);
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `http2Port` to `Http2Port`. Use {@link pascalCaseToCamelCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const camelCaseToPascalCase = (value) => (value.charAt(0).toUpperCase() + value.slice(1));
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link SnakeCaseIdentifier}.
+ *
+ * Converts `http2Port` to `http2_port`. Use {@link snakeCaseToCamelCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const camelCaseToSnakeCase = (value) => value.replaceAll(/[A-Z]/gu, (letter) => `_${letter.toLowerCase()}`);
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link KebabCaseIdentifier}.
+ *
+ * Converts `http2Port` to `http2-port`. Use {@link kebabCaseToCamelCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const camelCaseToKebabCase = (value) => snakeCaseToKebabCase(camelCaseToSnakeCase(value));
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `http2Port` to `HTTP2_PORT`. Use {@link constantCaseToCamelCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const camelCaseToConstantCase = (value) => snakeCaseToConstantCase(camelCaseToSnakeCase(value));
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `http2Port`. Use {@link camelCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const pascalCaseToCamelCase = (value) => (value.charAt(0).toLowerCase() + value.slice(1));
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link SnakeCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `http2_port`. Use {@link snakeCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const pascalCaseToSnakeCase = (value) => camelCaseToSnakeCase(pascalCaseToCamelCase(value));
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link KebabCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `http2-port`. Use {@link kebabCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const pascalCaseToKebabCase = (value) => snakeCaseToKebabCase(pascalCaseToSnakeCase(value));
+/**
+ * Converts a {@link PascalCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `Http2Port` to `HTTP2_PORT`. Use {@link constantCaseToPascalCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const pascalCaseToConstantCase = (value) => snakeCaseToConstantCase(pascalCaseToSnakeCase(value));
+/**
+ * Converts a {@link SnakeCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `http2_port` to `http2Port`. Use {@link camelCaseToSnakeCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const snakeCaseToCamelCase = (value) => value.replaceAll(/_[a-z]/gu, (word) => word.charAt(1).toUpperCase());
+/**
+ * Converts a {@link SnakeCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `http2_port` to `Http2Port`. Use {@link pascalCaseToSnakeCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const snakeCaseToPascalCase = (value) => camelCaseToPascalCase(snakeCaseToCamelCase(value));
+/**
+ * Converts a {@link SnakeCaseIdentifier} to a {@link KebabCaseIdentifier}.
+ *
+ * Converts `http2_port` to `http2-port`. Use {@link kebabCaseToSnakeCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const snakeCaseToKebabCase = (value) => value.replaceAll("_", "-");
+/**
+ * Converts a {@link SnakeCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `http2_port` to `HTTP2_PORT`. Use {@link constantCaseToSnakeCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const snakeCaseToConstantCase = (value) => value.toUpperCase();
+/**
+ * Converts a {@link KebabCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `http2-port` to `http2Port`. Use {@link camelCaseToKebabCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const kebabCaseToCamelCase = (value) => snakeCaseToCamelCase(kebabCaseToSnakeCase(value));
+/**
+ * Converts a {@link KebabCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `http2-port` to `Http2Port`. Use {@link pascalCaseToKebabCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const kebabCaseToPascalCase = (value) => camelCaseToPascalCase(kebabCaseToCamelCase(value));
+/**
+ * Converts a {@link KebabCaseIdentifier} to a {@link SnakeCaseIdentifier}.
+ *
+ * Converts `http2-port` to `http2_port`. Use {@link snakeCaseToKebabCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const kebabCaseToSnakeCase = (value) => value.replaceAll("-", "_");
+/**
+ * Converts a {@link KebabCaseIdentifier} to a {@link ConstantCaseIdentifier}.
+ *
+ * Converts `http2-port` to `HTTP2_PORT`. Use {@link constantCaseToKebabCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const kebabCaseToConstantCase = (value) => snakeCaseToConstantCase(kebabCaseToSnakeCase(value));
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link CamelCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `http2Port`. Use {@link camelCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const constantCaseToCamelCase = (value) => snakeCaseToCamelCase(constantCaseToSnakeCase(value));
+/**
+ * Decodes a {@link ConstantCaseIdentifier} to a {@link CamelCaseIdentifier} and
+ * restores the original spelling when encoding.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertOk,
+ *   CamelCaseIdentifierFromConstantCaseIdentifier,
+ * } from "@evolu/common";
+ *
+ * const Key = CamelCaseIdentifierFromConstantCaseIdentifier;
+ * const result = Key.fromUnknown("HTTP2_PORT");
+ * assertOk(result, "http2Port");
+ * assertEqual(Key.to(result.value), "HTTP2_PORT");
+ * ```
+ *
+ * @group String
+ */
+export const CamelCaseIdentifierFromConstantCaseIdentifier = 
+/*#__PURE__*/ transform("CamelCaseIdentifierFromConstantCaseIdentifier", ConstantCaseIdentifier, CamelCaseIdentifier, {
+    from: (value) => ok(constantCaseToCamelCase(value)),
+    to: camelCaseToConstantCase,
+});
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link PascalCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `Http2Port`. Use {@link pascalCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const constantCaseToPascalCase = (value) => camelCaseToPascalCase(constantCaseToCamelCase(value));
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link SnakeCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `http2_port`. Use {@link snakeCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const constantCaseToSnakeCase = (value) => value.toLowerCase();
+/**
+ * Converts a {@link ConstantCaseIdentifier} to a {@link KebabCaseIdentifier}.
+ *
+ * Converts `HTTP2_PORT` to `http2-port`. Use {@link kebabCaseToConstantCase} to
+ * recover the original spelling.
+ *
+ * @group String
+ */
+export const constantCaseToKebabCase = (value) => snakeCaseToKebabCase(constantCaseToSnakeCase(value));
+/**
+ * Adds capitalized text validation to an existing string Type.
+ *
+ * Narrows the output to TypeScript's `Capitalize<string>` while preserving the
+ * parent Type's constraints. Validation leaves the text unchanged. Use
+ * {@link capitalize} to change its casing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   capitalized,
+ *   maxLength,
+ *   String,
+ * } from "@evolu/common";
+ *
+ * const Label = capitalized(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("Hello world"), "Hello world");
+ * assertErr(Label.fromUnknown("hello world"));
+ * ```
+ *
+ * @group String
+ */
+export const capitalized = (parent) => createType("Capitalized", parent, (value) => value === capitalize(value)
+    ? ok(value)
+    : err({ type: "Capitalized", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} must be capitalized.`);
+/**
+ * Validates capitalized text as TypeScript's `Capitalize<string>`.
+ *
+ * The rest of the text can use any casing. Empty strings and text starting with
+ * an uncased character, such as a digit or emoji, are valid. Use
+ * {@link capitalize} to produce a capitalized value from any string.
+ *
+ * Capitalization applies to general text, including spaces and punctuation.
+ * Both `hello` and `Hello` become `Hello`, so the original initial casing
+ * cannot be recovered. Capitalization does not identify words or turn text into
+ * an identifier.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, CapitalizedString } from "@evolu/common";
+ *
+ * const text: CapitalizedString = "Hello world";
+ * assertOk(CapitalizedString.fromUnknown(text), text);
+ * assertErr(CapitalizedString.fromUnknown("hello world"));
+ * assertOk(CapitalizedString.fromUnknown(""), "");
+ * ```
+ *
+ * @group String
+ */
+export const CapitalizedString = /*#__PURE__*/ capitalized(String);
+/**
+ * Uppercases the first Unicode code point and returns a
+ * {@link CapitalizedString}.
+ *
+ * Preserves the remainder of the string and leaves an empty string unchanged.
+ * Uses JavaScript's default Unicode casing without locale-specific rules.
+ * Changing case can change the length, so input brands are not retained.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, capitalize } from "@evolu/common";
+ *
+ * const text = capitalize("hello world");
+ * assertEqual(text, "Hello world");
+ * assertType<typeof text, "Hello world">();
+ * assertEqual(capitalize(text), text);
+ * ```
+ *
+ * @group String
+ */
+export const capitalize = (value) => {
+    const [first = ""] = value;
+    return (first.toUpperCase() + value.slice(first.length));
+};
+/**
+ * Adds uncapitalized text validation to an existing string Type.
+ *
+ * Narrows the output to TypeScript's `Uncapitalize<string>` while preserving
+ * the parent Type's constraints. Validation leaves the text unchanged. Use
+ * {@link uncapitalize} to change its casing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   uncapitalized,
+ *   maxLength,
+ *   String,
+ * } from "@evolu/common";
+ *
+ * const Label = uncapitalized(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("hello WORLD"), "hello WORLD");
+ * assertErr(Label.fromUnknown("Hello WORLD"));
+ * ```
+ *
+ * @group String
+ */
+export const uncapitalized = (parent) => createType("Uncapitalized", parent, (value) => value === uncapitalize(value)
+    ? ok(value)
+    : err({ type: "Uncapitalized", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} must not start with an uppercase letter.`);
+/**
+ * Validates uncapitalized text as TypeScript's `Uncapitalize<string>`.
+ *
+ * The rest of the text can use any casing. Empty strings and text starting with
+ * an uncased character, such as a digit or emoji, are valid. Use
+ * {@link uncapitalize} to produce an uncapitalized value from any string.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, UncapitalizedString } from "@evolu/common";
+ *
+ * const text: UncapitalizedString = "hello WORLD";
+ * assertOk(UncapitalizedString.fromUnknown(text), text);
+ * assertErr(UncapitalizedString.fromUnknown("Hello WORLD"));
+ * assertOk(UncapitalizedString.fromUnknown(""), "");
+ * ```
+ *
+ * @group String
+ */
+export const UncapitalizedString = /*#__PURE__*/ uncapitalized(String);
+/**
+ * Lowercases the first Unicode code point and returns a
+ * {@link UncapitalizedString}.
+ *
+ * Preserves the remainder of the string and leaves an empty string unchanged.
+ * Uses JavaScript's default Unicode casing without locale-specific rules.
+ * Changing case can change the length, so input brands are not retained.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, uncapitalize } from "@evolu/common";
+ *
+ * const text = uncapitalize("Hello WORLD");
+ * assertEqual(text, "hello WORLD");
+ * assertType<typeof text, "hello WORLD">();
+ * assertEqual(uncapitalize(text), text);
+ * ```
+ *
+ * @group String
+ */
+export const uncapitalize = (value) => {
+    const [first = ""] = value;
+    return (first.toLowerCase() + value.slice(first.length));
+};
+/**
+ * Adds uppercased text validation to an existing string Type.
+ *
+ * Narrows the output to TypeScript's `Uppercase<string>` while preserving the
+ * parent Type's constraints. Validation leaves the text unchanged. Use
+ * {@link uppercase} to change its casing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
  *   assertErr,
  *   assertOk,
- *   assertType,
- *   Data,
- *   DateIso,
+ *   uppercased,
+ *   maxLength,
+ *   String,
  * } from "@evolu/common";
  *
- * const value = "2023-01-01T12:00:00.000Z";
- * assertOk(DateIso.fromUnknown(value), value);
- * const invalid = DateIso.fromUnknown("2023-01-01");
- * assertErr(invalid);
- * assertType(Data, invalid.error);
- * assertEqual(invalid.error, {
- *   type: "DateIso",
- *   value: "2023-01-01",
- * });
+ * const Label = uppercased(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("HELLO WORLD"), "HELLO WORLD");
+ * assertErr(Label.fromUnknown("Hello world"));
  * ```
  *
  * @group String
  */
-export const DateIso = /*#__PURE__*/ brand("DateIso", String, (value) => value.length === 24 && new globalThis.Date(value).toJSON() === value
-    ? ok()
-    : err({ type: "DateIso", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a canonical ISO date-time string.`);
+export const uppercased = (parent) => createType("Uppercased", parent, (value) => value === uppercase(value)
+    ? ok(value)
+    : err({ type: "Uppercased", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} must be uppercased.`);
 /**
- * Safely transforms a {@link Date} into a canonical {@link DateIso}.
+ * Validates uppercased text as TypeScript's `Uppercase<string>`.
+ *
+ * Checks the whole string using JavaScript's Unicode uppercase mapping. Empty
+ * strings and uncased characters, such as digits and emoji, are valid. Use
+ * {@link uppercase} to produce an uppercased value from any string.
  *
  * ### Example
  *
  * ```ts
- * import { assertEqual, assertOk, DateIsoFromDate } from "@evolu/common";
- *
- * const date = new Date("2025-01-01T12:00:00.000Z");
- * const result = DateIsoFromDate.fromUnknown(date);
+ * import { assertErr, assertOk, UppercasedString } from "@evolu/common";
  *
- * assertOk(result, "2025-01-01T12:00:00.000Z");
- * assertEqual(DateIsoFromDate.to(result.value), date);
+ * const text: UppercasedString = "HELLO WORLD";
+ * assertOk(UppercasedString.fromUnknown(text), text);
+ * assertErr(UppercasedString.fromUnknown("Hello world"));
+ * assertOk(UppercasedString.fromUnknown(""), "");
  * ```
  *
  * @group String
  */
-export const DateIsoFromDate = /*#__PURE__*/ transform("DateIsoFromDate", Date, DateIso, {
-    from: (value) => trySync(() => globalThis.Date.prototype.toISOString.call(value), () => ({ type: "DateIsoFromDate", value })),
-    to: (value) => new globalThis.Date(value),
-}, () => "The Date cannot be represented as DateIso.");
+export const UppercasedString = /*#__PURE__*/ uppercased(String);
 /**
- * Signed 64-bit {@link BigInt}.
+ * Uppercases the whole string and returns a {@link UppercasedString}.
  *
- * @group Number
- */
-export const Int64 = /*#__PURE__*/ brand("Int64", BigInt, (value) => globalThis.BigInt.asIntN(64, value) === value
-    ? ok()
-    : err({ type: "Int64", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a valid signed 64-bit integer (Int64).`);
-/**
- * Unsigned 64-bit {@link BigInt}.
+ * Leaves an empty string unchanged. Uses JavaScript's default Unicode casing
+ * without locale-specific rules. Changing case can change the length, so input
+ * brands are not retained.
  *
- * @group Number
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, uppercase } from "@evolu/common";
+ *
+ * const text = uppercase("Hello world");
+ * assertEqual(text, "HELLO WORLD");
+ * assertType<typeof text, "HELLO WORLD">();
+ * assertEqual(uppercase(text), text);
+ * ```
+ *
+ * @group String
  */
-export const UInt64 = /*#__PURE__*/ brand("UInt64", BigInt, (value) => globalThis.BigInt.asUintN(64, value) === value
-    ? ok()
-    : err({ type: "UInt64", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a valid unsigned 64-bit integer (UInt64).`);
+export const uppercase = (value) => value.toUpperCase();
 /**
- * Capitalized {@link Brand}.
+ * Adds lowercased text validation to an existing string Type.
  *
- * Requires the first character of a string to be uppercase.
+ * Narrows the output to TypeScript's `Lowercase<string>` while preserving the
+ * parent Type's constraints. Validation leaves the text unchanged. Use
+ * {@link lowercase} to change its casing.
  *
  * ### Example
  *
  * ```ts
  * import {
- *   assertEqual,
  *   assertErr,
  *   assertOk,
- *   assertType,
- *   Data,
+ *   lowercased,
+ *   maxLength,
  *   String,
- *   capitalized,
- *   type Brand,
  * } from "@evolu/common";
  *
- * const CapitalizedString = capitalized(String);
- * type CapitalizedString = typeof CapitalizedString.Output;
+ * const Label = lowercased(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("hello world"), "hello world");
+ * assertErr(Label.fromUnknown("Hello WORLD"));
+ * ```
  *
- * assertType<CapitalizedString, string & Brand<"Capitalized">>();
+ * @group String
+ */
+export const lowercased = (parent) => createType("Lowercased", parent, (value) => value === lowercase(value)
+    ? ok(value)
+    : err({ type: "Lowercased", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} must be lowercased.`);
+/**
+ * Validates lowercased text as TypeScript's `Lowercase<string>`.
  *
- * assertOk(CapitalizedString.fromUnknown("Evolu"), "Evolu");
- * const invalid = CapitalizedString.fromUnknown("evolu");
- * assertErr(invalid);
- * assertType(Data, invalid.error);
- * assertEqual(invalid.error, {
- *   type: "Capitalized",
- *   value: "evolu",
- * });
+ * Checks the whole string using JavaScript's Unicode lowercase mapping. Empty
+ * strings and uncased characters, such as digits and emoji, are valid. Use
+ * {@link lowercase} to produce a lowercased value from any string.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, LowercasedString } from "@evolu/common";
+ *
+ * const text: LowercasedString = "hello world";
+ * assertOk(LowercasedString.fromUnknown(text), text);
+ * assertErr(LowercasedString.fromUnknown("Hello WORLD"));
+ * assertOk(LowercasedString.fromUnknown(""), "");
  * ```
  *
  * @group String
  */
-export const capitalized = (parent) => brand("Capitalized", parent, (value) => {
-    const [first = ""] = value;
-    return value === first.toUpperCase() + value.slice(first.length)
-        ? ok()
-        : err({ type: "Capitalized", value });
-}, (error) => `The value ${safelyStringifyUnknownValue(error.value)} must be capitalized.`);
+export const LowercasedString = /*#__PURE__*/ lowercased(String);
 /**
- * Capitalized {@link String}.
+ * Lowercases the whole string and returns a {@link LowercasedString}.
+ *
+ * Leaves an empty string unchanged. Uses JavaScript's default Unicode casing
+ * without locale-specific rules. Changing case can change the length, so input
+ * brands are not retained.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, lowercase } from "@evolu/common";
+ *
+ * const text = lowercase("Hello WORLD");
+ * assertEqual(text, "hello world");
+ * assertType<typeof text, "hello world">();
+ * assertEqual(lowercase(text), text);
+ * ```
  *
  * @group String
  */
-export const CapitalizedString = /*#__PURE__*/ capitalized(String);
+export const lowercase = (value) => value.toLowerCase();
 /**
  * String {@link Brand} without surrounding whitespace.
  *
@@ -1928,6 +2669,113 @@ export const TrimmedString = /*#__PURE__*/ trimmed(String);
  * @group String
  */
 export const trim = (value) => value.trim();
+/**
+ * String {@link Brand} requiring an exact, case-sensitive prefix.
+ *
+ * Validation preserves the complete string, including the prefix. An empty
+ * prefix accepts every string allowed by the parent Type. The prefix must be
+ * one concrete string literal so different prefixes have distinct brands.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   maxLength,
+ *   startsWith,
+ *   String,
+ *   type Brand,
+ * } from "@evolu/common";
+ *
+ * const EnvName = startsWith("APP_")(maxLength(64)(String));
+ *
+ * const name = EnvName.fromUnknown("APP_PORT");
+ * assertOk(name, "APP_PORT");
+ * assertType<
+ *   typeof name.value,
+ *   string & Brand<"MaxLength64"> & Brand<"StartsWithAPP_">
+ * >();
+ *
+ * assertEqual(EnvName.to(name.value), "APP_PORT");
+ *
+ * assertErr(EnvName.fromUnknown("app_PORT"));
+ * assertErr(EnvName.fromUnknown("APP_" + "X".repeat(61)));
+ * ```
+ *
+ * @group String
+ */
+export const startsWith = (prefix) => {
+    const name = `StartsWith${prefix}`;
+    return (parent) => brand(name, parent, (value) => value.startsWith(prefix)
+        ? ok()
+        : err({
+            type: name,
+            value,
+            prefix,
+        }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} must start with ${safelyStringifyUnknownValue(error.prefix)}.`);
+};
+/**
+ * Decodes a prefixed string with another {@link Type} and restores the prefix
+ * when encoding.
+ *
+ * Uses {@link startsWith} to validate an exact, case-sensitive prefix before
+ * removing one occurrence. The wrapped Type validates and decodes the suffix;
+ * its constraints apply to the suffix, and its Output is preserved. Encoding
+ * prepends the prefix to the wrapped Type's canonical string representation. An
+ * empty prefix leaves that representation unchanged.
+ *
+ * The prefix must be one concrete string literal. The wrapped Type must accept
+ * a string Input and encode to strings; its Output can have another type, as
+ * with {@link PortFromString}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertType,
+ *   ConstantCaseIdentifier,
+ *   prefixed,
+ *   PortFromString,
+ *   type Port,
+ * } from "@evolu/common";
+ *
+ * const EnvName = prefixed("APP_")(ConstantCaseIdentifier);
+ *
+ * const name = EnvName.fromUnknown("APP_PORT");
+ * assertOk(name, "PORT");
+ * assertType<typeof name.value, ConstantCaseIdentifier>();
+ *
+ * assertEqual(EnvName.to(name.value), "APP_PORT");
+ *
+ * assertErr(EnvName.fromUnknown("OTHER_PORT"));
+ * assertErr(EnvName.fromUnknown("APP_port"));
+ *
+ * const PortSetting = prefixed("port:")(PortFromString);
+ *
+ * const port = PortSetting.fromUnknown("port:04000");
+ * assertOk(port, 4000);
+ * assertType<typeof port.value, Port>();
+ *
+ * assertEqual(PortSetting.to(port.value), "port:4000");
+ * ```
+ *
+ * @group String
+ */
+export const prefixed = (prefix) => (type) => {
+    // A literal prefix makes the generated names concrete and distinct.
+    const source = startsWith(prefix)(String);
+    return transform(`Prefixed${prefix}`, source, type, {
+        // The Input guard permits any string; concatenation establishes the prefix brand.
+        from: (value) => ok(value.slice(prefix.length)),
+        to: (value) => `${prefix}${value}`,
+    });
+};
 /**
  * Minimum-length {@link Brand} for values whose `length` is at least `min`.
  *
@@ -2055,6 +2903,7 @@ export const length = (exact) => (parent) => {
  * assertType<UrlSafeString, string & Brand<"UrlSafeString">>();
  *
  * assertOk(UrlSafeString.fromUnknown("abc-123_DEF"), "abc-123_DEF");
+ *
  * const invalid = UrlSafeString.fromUnknown("not safe");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -2183,7 +3032,13 @@ export const uint8ArrayToBase64Url = (bytes) => uint8ArrayToBase64UrlString(byte
  */
 export const base64UrlToUint8Array = (value) => base64UrlStringToUint8Array(value);
 /**
- * A non-empty URL-safe name containing at most 64 UTF-16 code units.
+ * A non-empty file-system-safe and URL-safe token of at most 64 UTF-16 code
+ * units.
+ *
+ * Evolu uses it for database file names, storage pool names, and log prefixes.
+ * It accepts the {@link UrlSafeString} alphabet in any order, so it may start
+ * with a digit, `-`, or `_`. It is not a language identifier; for
+ * word-structured names, use {@link identifier}.
  *
  * @group String
  */
@@ -2643,6 +3498,7 @@ export const PositiveFiniteNumber = /*#__PURE__*/ positive(NonNegativeFiniteNumb
  * assertType<Int, number & Brand<"Int">>();
  *
  * assertOk(Int.fromUnknown(42), 42);
+ *
  * const invalid = Int.fromUnknown(1.5);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -2682,6 +3538,49 @@ export const zeroNonNegativeInt = /*#__PURE__*/ NonNegativeInt.orThrow(0);
  * @group Number
  */
 export const PositiveInt = /*#__PURE__*/ positive(NonNegativeInt);
+/**
+ * Transforms a decimal integer string into an {@link Int}.
+ *
+ * This is useful for inputs that carry numbers as text, such as environment
+ * variables, URL query parameters, and form fields. The string must consist of
+ * an optional minus sign and digits; the {@link Int} constraint then rejects
+ * values outside the safe integer range.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   assertSame,
+ *   IntFromString,
+ * } from "@evolu/common";
+ *
+ * assertOk(IntFromString.fromUnknown("4000"), 4000);
+ * assertOk(IntFromString.fromUnknown("-1"), -1);
+ * assertEqual(IntFromString.to(IntFromString.orThrow("42")), "42");
+ *
+ * const negativeZero = IntFromString.orThrow("-0");
+ * assertSame(negativeZero, -0);
+ * assertEqual(IntFromString.to(negativeZero), "-0");
+ *
+ * const invalid = IntFromString.fromUnknown("4000.5");
+ * assertErr(invalid, { type: "IntFromString", value: "4000.5" });
+ * assertEqual(
+ *   IntFromString.formatError(invalid.error),
+ *   'The value "4000.5" is not a decimal integer.',
+ * );
+ * ```
+ *
+ * @group Number
+ */
+export const IntFromString = /*#__PURE__*/ transform("IntFromString", String, Int, {
+    from: (value) => /^-?\d+$/u.test(value)
+        ? ok(globalThis.Number(value))
+        : err({ type: "IntFromString", value }),
+    to: (value) => globalThis.Object.is(value, -0) ? "-0" : globalThis.String(value),
+}, (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a decimal integer.`);
 /**
  * Minimum {@link PositiveInt} value.
  *
@@ -2805,6 +3704,55 @@ export const lessThanOrEqualTo = (max) => (parent) => {
         ? ok()
         : err({ type: name, value, max }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} must be less than or equal to ${error.max}.`);
 };
+/**
+ * A TCP or UDP port as an integer from zero through 65535, inclusive.
+ *
+ * When binding a server, zero requests an automatically assigned port. Use
+ * {@link PortFromString} for configuration values supplied as text.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, Port } from "@evolu/common";
+ *
+ * assertOk(Port.fromUnknown(0), 0);
+ * assertOk(Port.fromUnknown(4000), 4000);
+ * assertOk(Port.fromUnknown(65535), 65535);
+ * assertErr(Port.fromUnknown(-1));
+ * assertErr(Port.fromUnknown(65536));
+ * assertErr(Port.fromUnknown(4000.5));
+ * ```
+ *
+ * @group Number
+ */
+export const Port = /*#__PURE__*/ brand("Port", 
+/*#__PURE__*/ lessThanOrEqualTo(65535)(NonNegativeInt));
+/**
+ * Parses a decimal integer string and validates it as a {@link Port}.
+ *
+ * Uses {@link IntFromString} for decimal parsing, including its rejection of
+ * whitespace, plus signs, fractions, and exponent notation.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   PortFromString,
+ * } from "@evolu/common";
+ *
+ * assertOk(PortFromString.fromUnknown("0"), 0);
+ * assertOk(PortFromString.fromUnknown("4000"), 4000);
+ * assertErr(PortFromString.fromUnknown("65536"));
+ * assertErr(PortFromString.fromUnknown("http"));
+ * assertEqual(PortFromString.to(PortFromString.orThrow("04000")), "4000");
+ * ```
+ *
+ * @group Number
+ */
+export const PortFromString = /*#__PURE__*/ transform("PortFromString", IntFromString, Port, { from: ok, to: identity });
 /**
  * Finite {@link Number} from zero to one, inclusive.
  *
@@ -3033,6 +3981,7 @@ export const NegativeDecimalString = /*#__PURE__*/ negativeDecimalString(NonPosi
  * >();
  *
  * assertOk(Tenths.fromUnknown(0.3), 0.3);
+ *
  * const invalid = Tenths.fromUnknown(0.31);
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -3152,6 +4101,7 @@ export const between = (min, max) => (parent) => {
  *
  * const UserId = brand("UserId", String);
  * const UserIds = array(UserId);
+ *
  * const result = UserIds.from.parent(["ada", "grace"]);
  *
  * assertType<
@@ -3160,6 +4110,7 @@ export const between = (min, max) => (parent) => {
  * >();
  * assertOk(result, ["ada", "grace"]);
  * assertOk(UserIds.fromUnknown(["ada", "grace"]), ["ada", "grace"]);
+ *
  * const invalid = UserIds.fromUnknown("ada");
  * assertErr(invalid);
  * assertType(Data, invalid.error);
@@ -3731,25 +4682,25 @@ const createTupleType = (typeElements) => {
 };
 const validateTupleItems = (value, elements, validate, options, checkStructure) => validateIndexedArrayItems("Tuple", value, (value, elementOptions, index) => validate(elements[index], value, elementOptions, index), options, checkStructure);
 /**
- * Decimal digit from `"0"` to `"9"`.
+ * Decimal integer string from `"0"` to `"9"`.
  *
  * @group String
  */
 export const Digit = /*#__PURE__*/ union("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");
 /**
- * Decimal digit from `"1"` to `"9"`.
+ * Decimal integer string from `"1"` to `"9"`.
  *
  * @group String
  */
 export const Digit1To9 = /*#__PURE__*/ union("1", "2", "3", "4", "5", "6", "7", "8", "9");
 /**
- * Decimal string from `"1"` to `"6"`.
+ * Decimal integer string from `"1"` to `"6"`.
  *
  * @group String
  */
 export const Digit1To6 = /*#__PURE__*/ union("1", "2", "3", "4", "5", "6");
 /**
- * Decimal string from `"1"` to `"23"`.
+ * Decimal integer string from `"1"` to `"23"`, without a leading zero.
  *
  * @group String
  */
@@ -3757,7 +4708,7 @@ export const Digit1To23 = /*#__PURE__*/ union(Digit1To9,
 /*#__PURE__*/ templateLiteral("1", Digit), 
 /*#__PURE__*/ templateLiteral("2", /*#__PURE__*/ union("0", "1", "2", "3")));
 /**
- * Decimal string from `"1"` to `"51"`.
+ * Decimal integer string from `"1"` to `"51"`, without a leading zero.
  *
  * @group String
  */
@@ -3765,14 +4716,14 @@ export const Digit1To51 = /*#__PURE__*/ union(Digit1To9,
 /*#__PURE__*/ templateLiteral(/*#__PURE__*/ union("1", "2", "3", "4"), Digit), 
 /*#__PURE__*/ templateLiteral("5", /*#__PURE__*/ union("0", "1")));
 /**
- * Decimal string from `"1"` to `"99"`.
+ * Decimal integer string from `"1"` to `"99"`, without a leading zero.
  *
  * @group String
  */
 export const Digit1To99 = /*#__PURE__*/ union(Digit1To9, 
 /*#__PURE__*/ templateLiteral(Digit1To9, Digit));
 /**
- * Decimal string from `"1"` to `"59"`.
+ * Decimal integer string from `"1"` to `"59"`, without a leading zero.
  *
  * @group String
  */
@@ -4026,6 +4977,7 @@ export { _Object as Object };
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -4061,6 +5013,7 @@ export { _Object as Object };
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -4279,16 +5232,116 @@ const validateRecordEntries = (input, validateKey, validateValue, options) => {
  * @group Objects
  */
 export const optional = (type) => createOptionalProperty(type);
-const optionalPropertySymbol = /*#__PURE__*/ globalThis.Symbol();
+const optionalPropertySymbol = 
+/*#__PURE__*/ globalThis.Symbol();
 const createOptionalProperty = (type) => ({
     type,
     [optionalPropertySymbol]: true,
 });
+export function withDefault(property, value, { strategy } = {}) {
+    assert(strategy === undefined || strategy === "preserve", 'withDefault strategy must be omitted or "preserve".');
+    const optionalInput = optionalPropertySymbol in property;
+    const type = (optionalInput ? property.type : property);
+    assert(type.is(value), `withDefault value must be an Output of ${type.name}.`);
+    const originals = new Set([
+        ...(optionalInput ? ["missing"] : []),
+        ...(type.is(null) ? ["null"] : []),
+        ...(type.is(undefined) ? ["undefined"] : []),
+    ]);
+    const supplied = createRootType("DefaultSupplied", (candidate) => (strategy === undefined && globalThis.Object.is(candidate, value)) ||
+        (candidate !== null && candidate !== undefined && type.is(candidate))
+        ? ok(candidate)
+        : err({ type: "DefaultValue" }), () => "The value must be a non-nullish Output of its Type or, in replacement mode, the configured default.");
+    const defaultValue = createRootType("DefaultValue", (candidate) => type.is(candidate) &&
+        (globalThis.Object.is(candidate, value) ||
+            (Data.is(value) && Data.is(candidate) && eqData(candidate, value)))
+        ? ok(candidate)
+        : err({ type: "DefaultValue" }), () => "A preserved default must equal the configured default value.");
+    const output = (strategy === undefined
+        ? supplied
+        : discriminatedUnion("defaultUsed", object({ value: supplied, defaultUsed: literal(false) }), object({
+            value: defaultValue,
+            defaultUsed: literal(true),
+            original: createRootType("DefaultOriginal", (candidate) => typeof candidate === "string" && originals.has(candidate)
+                ? ok(candidate)
+                : err({ type: "DefaultOriginal" }), () => "The original absence must be handled by this default declaration."),
+        })));
+    const ownGetTypeIssues = output[getRuntimeTypeIssuesSymbol];
+    const outputWithIssues = {
+        ...output,
+        [outputValidationSymbol]: (value, options) => {
+            const result = output[outputValidationSymbol](value, options);
+            return result.ok
+                ? result
+                : err({ type: "WithDefault", outputError: result.error });
+        },
+        [getRuntimeTypeIssuesSymbol]: (error, mode) => error.type === "WithDefault" && "outputError" in error
+            ? ownGetTypeIssues(error.outputError, mode)
+            : type[getRuntimeTypeIssuesSymbol](error, mode),
+    };
+    const operations = {
+        output: outputWithIssues,
+        createObject: createDefaultObjectType,
+        partial: (type) => createOptionalProperty(strategy === "preserve"
+            ? withDefault(type, value, {
+                strategy,
+            })
+            : withDefault(type, value)),
+        decode: (candidate) => {
+            const original = candidate === missingDefaultValue
+                ? "missing"
+                : candidate === null
+                    ? "null"
+                    : candidate === undefined
+                        ? "undefined"
+                        : undefined;
+            const effective = original === undefined ? candidate : value;
+            return strategy === undefined
+                ? effective
+                : original === undefined
+                    ? { value: effective, defaultUsed: false }
+                    : { value: effective, defaultUsed: true, original };
+        },
+        encode: (candidate) => {
+            if (strategy === undefined)
+                return candidate;
+            const preserved = candidate;
+            if (!preserved.defaultUsed)
+                return preserved.value;
+            switch (preserved.original) {
+                case "missing":
+                    return missingDefaultValue;
+                case "null":
+                    return null;
+                case "undefined":
+                    return undefined;
+            }
+        },
+    };
+    if (optionalInput) {
+        return {
+            type,
+            value,
+            strategy: strategy ?? "replace",
+            [defaultPropertySymbol]: operations,
+        };
+    }
+    const fromOwn = (value) => ok(operations.decode(value));
+    const fromParent = mapRuntimeOperations(type[fromSymbol], (operation) => (value, options) => flatMapResult(operation(value, options), fromOwn));
+    return createTypeNode("WithDefault", type, (value, options) => flatMapResult(type.fromUnknown(value, options), fromOwn), operations.output.is, operations.output[outputValidationSymbol], createFromOperation(fromParent), operations.encode, operations.output[getRuntimeTypeIssuesSymbol]);
+}
+const defaultPropertySymbol = 
+/*#__PURE__*/ globalThis.Symbol();
+const missingDefaultValue = /*#__PURE__*/ globalThis.Symbol();
 export function object(props, recordType) {
     return createObjectType(snapshotObjectProps(props), recordType);
 }
 const createObjectType = (props, recordType) => {
     const runtimeProps = props;
+    const defaultProperty = globalThis.Object.values(runtimeProps).find(isDefaultProperty);
+    if (defaultProperty) {
+        return defaultProperty[defaultPropertySymbol].createObject(props, recordType);
+    }
     const keys = globalThis.Object.keys(runtimeProps);
     const validate = (value, options, exactOutput) => {
         if (value === null || typeof value !== "object") {
@@ -4598,6 +5651,57 @@ const createObjectType = (props, recordType) => {
         }
         : { props: runtimeProps });
 };
+const createDefaultObjectType = (props, recordType) => {
+    const inputProps = createMutableRecord();
+    const outputProps = createMutableRecord();
+    const defaults = new Map();
+    for (const [key, property] of globalThis.Object.entries(props)) {
+        if (isDefaultProperty(property)) {
+            const defaultProperty = property;
+            inputProps[key] = createOptionalProperty(defaultProperty.type);
+            outputProps[key] = defaultProperty[defaultPropertySymbol].output;
+            defaults.set(key, defaultProperty[defaultPropertySymbol]);
+        }
+        else {
+            inputProps[key] = property;
+            const type = objectPropertyToType(property);
+            const output = createRootType(type.name, type[outputValidationSymbol], type.formatError, type[getRuntimeTypeIssuesSymbol]);
+            outputProps[key] =
+                optionalPropertySymbol in property
+                    ? createOptionalProperty(output)
+                    : output;
+        }
+    }
+    const source = createObjectType(inputProps, recordType);
+    // The object parent validates only its input structure and root value Types.
+    const parent = getTerminalRuntimeNode(source);
+    const output = createObjectType(outputProps, recordType);
+    const finish = (value) => {
+        const result = createMutableRecord(value);
+        for (const [key, operations] of defaults) {
+            result[key] = operations.decode(globalThis.Object.hasOwn(result, key)
+                ? result[key]
+                : missingDefaultValue);
+        }
+        return ok(result);
+    };
+    const fromInput = getTerminalRuntimeNode(source[fromSymbol]);
+    const fromParent = (value, options) => flatMapResult(fromInput(value, options), finish);
+    const to = (value) => {
+        const result = createMutableRecord(value);
+        for (const [key, operations] of defaults) {
+            const original = operations.encode(result[key]);
+            if (original === missingDefaultValue)
+                delete result[key];
+            else
+                result[key] = original;
+        }
+        return source[encoderSymbol](result);
+    };
+    return createTypeNode("Object", parent, (value, options) => flatMapResult(source.fromUnknown(value, options), finish), output.is, output[outputValidationSymbol], createFromOperation(fromParent), to, createObjectRuntimeTypeIssues(source.formatError, props, recordType), recordType
+        ? { props, record: recordType }
+        : { props });
+};
 // Read descriptors instead of spreading so accessors are not invoked,
 // non-enumerable declarations are retained, and later mutations are isolated.
 const snapshotObjectProps = (props, runtimeProps = createMutableRecord()) => {
@@ -4613,7 +5717,12 @@ const snapshotObjectProps = (props, runtimeProps = createMutableRecord()) => {
     return runtimeProps;
 };
 const isOptionalProperty = (property) => optionalPropertySymbol in property;
-const objectPropertyToType = (property) => (isOptionalProperty(property) ? property.type : property);
+const isDefaultProperty = (property) => defaultPropertySymbol in property;
+const objectPropertyToType = (property) => isDefaultProperty(property)
+    ? property[defaultPropertySymbol].output
+    : isOptionalProperty(property)
+        ? property.type
+        : property;
 const createRecordPropertyError = (issue) => ({
     type: "Record",
     reason: { kind: "Entries", issues: [issue] },
@@ -4622,7 +5731,8 @@ const createRecordPropertyError = (issue) => ({
  * Object {@link Type} with every property optional.
  *
  * No property is required, but every present property must still satisfy its
- * Type.
+ * Type. For {@link withDefault} properties, this disables the missing-property
+ * default; defaults for present `null` or `undefined` values still apply.
  *
  * ### Example
  *
@@ -4650,9 +5760,11 @@ export const partial = (props, ..._validation) => {
     const partialProps = createMutableRecord();
     for (const key of globalThis.Object.keys(source)) {
         const property = source[key];
-        partialProps[key] = isOptionalProperty(property)
-            ? property
-            : createOptionalProperty(property);
+        partialProps[key] = isDefaultProperty(property)
+            ? property[defaultPropertySymbol].partial(property.type)
+            : isOptionalProperty(property)
+                ? property
+                : createOptionalProperty(property);
     }
     return createObjectType(partialProps);
 };
@@ -4693,7 +5805,7 @@ export const nullableToOptional = (props, ..._validation) => {
     const optionalProps = createMutableRecord();
     for (const key of globalThis.Object.keys(source)) {
         const property = source[key];
-        if (isOptionalProperty(property)) {
+        if (isOptionalProperty(property) || isDefaultProperty(property)) {
             optionalProps[key] = property;
             continue;
         }
@@ -4732,6 +5844,101 @@ export const omit = (objectType, ...keys) => {
     }
     return createObjectType(props, runtimeObjectType.record);
 };
+/**
+ * Renames a strict {@link object} Type's encoded keys using a string codec.
+ *
+ * The object declaration uses semantic keys. Each key must be a valid Output of
+ * the key Type. Its canonical encoding becomes the external property name.
+ * Decoding accepts those exact names; aliases and unknown properties are
+ * rejected. Values, optionality, and semantic Output stay with the object Type.
+ * Only the outer keys change. Nested field codecs keep their own behavior.
+ *
+ * Construction rejects invalid schema keys, duplicate encodings, and key codecs
+ * that do not decode their encodings back to the declared keys. These are
+ * schema mistakes; invalid external values return normal Type errors. Error
+ * paths use the external names, including missing required properties.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertErr,
+ *   assertOk,
+ *   CamelCaseIdentifierFromConstantCaseIdentifier,
+ *   object,
+ *   objectKeys,
+ *   optional,
+ *   PortFromString,
+ *   prefixed,
+ * } from "@evolu/common";
+ *
+ * const Key = prefixed("APP_")(
+ *   CamelCaseIdentifierFromConstantCaseIdentifier,
+ * );
+ * const Settings = objectKeys(Key)(
+ *   object({ port: optional(PortFromString) }),
+ * );
+ *
+ * const result = Settings.fromUnknown({ APP_PORT: "04000" });
+ * assertOk(result, { port: 4000 });
+ *
+ * assertEqual(Settings.to(result.value), { APP_PORT: "4000" });
+ *
+ * assertErr(Settings.fromUnknown({ APP_POTR: "4000" }));
+ * ```
+ *
+ * @group Objects
+ */
+export const objectKeys = (key) => (type) => {
+    const runtimeKey = key;
+    const runtimeOutput = type;
+    const props = createMutableRecord();
+    const outputKeyByInputKey = new Map();
+    const inputKeyByOutputKey = new Map();
+    for (const outputKey of globalThis.Object.keys(type.props)) {
+        assert(runtimeKey.is(outputKey), `Invalid object schema key ${safelyStringifyUnknownValue(outputKey)} for ${key.name}.`);
+        const inputKey = runtimeKey.to(outputKey);
+        assert(!outputKeyByInputKey.has(inputKey), `Duplicate encoded object key ${safelyStringifyUnknownValue(inputKey)}.`);
+        const decoded = runtimeKey.fromUnknown(inputKey, firstValidationOptions);
+        assert(decoded.ok && decoded.value === outputKey, "An object key codec must decode its encoding to the declared key.");
+        props[inputKey] = type.props[outputKey];
+        outputKeyByInputKey.set(inputKey, outputKey);
+        inputKeyByOutputKey.set(outputKey, inputKey);
+    }
+    const input = createObjectType(props);
+    const fromUnknown = (value, options = firstValidationOptions) => {
+        const result = input.fromUnknown(value, options);
+        if (!result.ok)
+            return err({ type: "ObjectKeys", error: result.error });
+        const output = createMutableRecord();
+        for (const [inputKey, value] of globalThis.Object.entries(result.value)) {
+            output[outputKeyByInputKey.get(inputKey)] = value;
+        }
+        return ok(output);
+    };
+    const to = (value) => {
+        const encoded = runtimeOutput[encoderSymbol](value);
+        const input = createMutableRecord();
+        for (const [key, value] of globalThis.Object.entries(encoded)) {
+            input[inputKeyByOutputKey.get(key)] = value;
+        }
+        return input;
+    };
+    const validateOutput = (value, options) => {
+        const result = runtimeOutput[outputValidationSymbol](value, options);
+        return result.ok
+            ? result
+            : err({ type: "ObjectKeys", outputError: result.error });
+    };
+    const getTypeIssues = (error, mode) => {
+        if ("outputError" in error) {
+            return runtimeOutput[getRuntimeTypeIssuesSymbol](error.outputError, mode);
+        }
+        return input[getRuntimeTypeIssuesSymbol](error.error, mode);
+    };
+    return createTypeNode("ObjectKeys", Unknown, fromUnknown, runtimeOutput.is, validateOutput, createFromOperation(fromUnknown), to, getTypeIssues, { key, output: type });
+};
 export function result(okType, errorType) {
     return discriminatedUnion("ok", createObjectType({
         ok: literal(true),
@@ -5746,7 +6953,7 @@ export const json = (type, name, ..._validation) => {
     const BrandedJson = {
         ...typeNode,
         from,
-        orThrow: mapRuntimeResult(fromInput, getOrThrow),
+        orThrow: createRuntimeOrThrow(fromInput, typeNode.formatError),
         orNull: mapRuntimeResult(fromInput, getOrNull),
     };
     return [