@evolu/common 8.9.0 → 8.11.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,44 +454,129 @@ 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";
+import { 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 = 
 /*#__PURE__*/ globalThis.Symbol();
-const singleRuntimeTypeIssue = (formatterName, error, defaultFormatter, path = []) => [
+// Copying a short path in a loop is about twice as fast as spreading it.
+const appendIssuePath = (path, key) => {
+    const issuePath = createMutableArray(path.length + 1);
+    for (let index = 0; index < path.length; index++) {
+        issuePath[index] = path[index];
+    }
+    issuePath[path.length] = key;
+    return issuePath;
+};
+const singleRuntimeTypeIssue = (formatterName, error, defaultFormatter, path) => [
     { name: formatterName, error, path, formatError: defaultFormatter },
 ];
-const prependRuntimeTypeIssuePath = (key, issues) => issues.map((issue) => ({
-    ...issue,
-    path: [key, ...issue.path],
-}));
-const createCollectionRuntimeTypeIssues = (name, issuesKind, defaultFormatter, getNestedType) => (error, mode) => {
+const createCollectionRuntimeTypeIssues = (name, issuesKind, defaultFormatter, getNestedType) => (error, mode, path) => {
     const reason = error.reason;
     if (reason.kind !== issuesKind) {
-        return singleRuntimeTypeIssue(name, error, defaultFormatter);
+        return singleRuntimeTypeIssue(name, error, defaultFormatter, path);
     }
     const allIssues = reason.issues;
-    const issues = mode === "first" ? [allIssues[0]] : allIssues;
-    return issues.flatMap((issue) => {
-        const path = "key" in issue ? issue.key : issue.index;
-        if (issue.error !== undefined) {
-            return prependRuntimeTypeIssuePath(path, getNestedType(issue)[getRuntimeTypeIssuesSymbol](issue.error, mode));
+    const issueCount = mode === "first" ? 1 : allIssues.length;
+    const result = [];
+    for (let index = 0; index < issueCount; index++) {
+        const issue = allIssues[index];
+        const issuePath = appendIssuePath(path, "key" in issue ? issue.key : issue.index);
+        if (issue.error === undefined) {
+            result.push({
+                name,
+                error: mode === "first"
+                    ? error
+                    : {
+                        type: name,
+                        reason: { kind: issuesKind, issues: [issue] },
+                    },
+                path: issuePath,
+                formatError: defaultFormatter,
+            });
+            continue;
         }
-        return singleRuntimeTypeIssue(name, mode === "first"
-            ? error
-            : {
-                type: name,
-                reason: { kind: issuesKind, issues: [issue] },
-            }, defaultFormatter, [path]);
-    });
+        const nestedIssues = getNestedType(issue)[getRuntimeTypeIssuesSymbol](issue.error, mode, issuePath);
+        // Nested issues are a new array, so one visited issue returns them.
+        if (issueCount === 1)
+            return nestedIssues;
+        for (const nestedIssue of nestedIssues)
+            result.push(nestedIssue);
+    }
+    return result;
 };
 const formatDefaultRuntimeTypeIssue = (issue) => issue.formatError(issue.error);
+const formatRuntimeTypeIssue = (issue, formatIssue = formatDefaultRuntimeTypeIssue) => {
+    let message = formatIssue(issue);
+    if (issue.alternatives === undefined)
+        return message;
+    // Each alternative issue starts a "- " line; continuation lines of a
+    // multi-line message are indented.
+    for (const { index, name, issues } of issue.alternatives) {
+        for (const alternativeIssue of issues) {
+            let path = "";
+            for (const key of alternativeIssue.path) {
+                path +=
+                    typeof key === "string"
+                        ? `[${JSON.stringify(key)}]`
+                        : `[${globalThis.String(key)}]`;
+            }
+            const alternativeMessage = formatRuntimeTypeIssue(alternativeIssue, formatIssue);
+            // replaceAll is slow even without a match.
+            message += `\n- ${index}: ${name}${path}: ${alternativeMessage.includes("\n")
+                ? alternativeMessage.replaceAll("\n", "\n  ")
+                : alternativeMessage}`;
+        }
+    }
+    return message;
+};
 export function assertType(type, value) {
     if (type === undefined)
         return;
@@ -530,6 +615,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 +760,30 @@ 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),
-    }));
-    const derived = createTypeNode(source.name, parent, source.fromUnknown, source.is, source[outputValidationSymbol], source[fromSymbol], source[encoderSymbol].parent ?? source[encoderSymbol], getTypeIssues, undefined, formatIssue);
+        ...(issue.alternatives === undefined
+            ? {}
+            : {
+                alternatives: issue.alternatives.map((alternative) => ({
+                    ...alternative,
+                    issues: alternative.issues.map(localizeIssue),
+                })),
+            }),
+    });
+    const getTypeIssues = (error, mode, path) => source[getRuntimeTypeIssuesSymbol](error, mode, path).map(localizeIssue);
+    const derived = createTypeNode(source.name, parent, source.fromUnknown, source.is, source[outputValidationSymbol], source[fromSymbol], source[encoderSymbol].parent ?? source[encoderSymbol], getTypeIssues, {
+        formatIssue,
+        check: source[checkSymbol],
+        refinements: source[refinementsSymbol],
+    });
     // 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,14 +815,27 @@ 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;
 };
 export function createType(name, fromUnknownOrParent, fromParentOrFormatError, formatError) {
-    return typeof fromUnknownOrParent === "function"
-        ? createRootType(name, assertRefinementIdentity(fromUnknownOrParent), fromParentOrFormatError)
-        : createChildType(name, fromUnknownOrParent, assertRefinementIdentity(fromParentOrFormatError), formatError);
+    if (typeof fromUnknownOrParent === "function") {
+        const fromUnknown = assertRefinementIdentity(fromUnknownOrParent);
+        return createRootType(name, fromUnknown, fromParentOrFormatError, {
+            // The asserted identity makes this an identity Type.
+            check: (value) => {
+                const result = fromUnknown(value);
+                return result.ok ? undefined : result.error;
+            },
+        });
+    }
+    return createChildType(name, fromUnknownOrParent, assertRefinementIdentity(fromParentOrFormatError), formatError);
 }
 const assertRefinementIdentity = (refinement) => (value) => {
     const result = refinement(value);
@@ -728,11 +844,68 @@ const assertRefinementIdentity = (refinement) => (value) => {
     }
     return result;
 };
-const createRootType = (name, fromUnknown, formatError, getTypeIssues) => {
+/**
+ * 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) => {
+    const check = type[checkSymbol];
+    return createRootType(name, (value, options) => {
+        const result = type.fromUnknown(value, options);
+        return result.ok ? result : err(mapError(result.error, value));
+    }, formatError, {
+        check: check &&
+            ((value, options) => {
+                const error = check(value, options);
+                return error === undefined ? undefined : mapError(error, value);
+            }),
+    });
+};
+const createRootType = (name, fromUnknown, formatError, { getTypeIssues, isOutput, check, } = {}) => {
     const runtimeFormatError = formatError;
     const runtimeGetTypeIssues = getTypeIssues ??
-        ((error) => singleRuntimeTypeIssue(error.type === "TypeOf" ? name : error.type, error, runtimeFormatError));
-    const is = (value) => fromUnknown(value).ok;
+        ((error, _mode, path) => singleRuntimeTypeIssue(error.type === "TypeOf" ? name : error.type, error, runtimeFormatError, path));
+    const is = isOutput ??
+        (check
+            ? (value) => check(value, firstValidationOptions) === undefined
+            : (value) => fromUnknown(value).ok);
     const from = (value, options = firstValidationOptions) => {
         assertTypeOutput(name, is, fromUnknown, value, options);
         return ok(value);
@@ -746,7 +919,7 @@ const createRootType = (name, fromUnknown, formatError, getTypeIssues) => {
         return value;
     };
     return {
-        ...instance("Type"),
+        "~evolu/instance": "Type",
         name,
         parent: null,
         fromUnknown,
@@ -756,32 +929,134 @@ const createRootType = (name, fromUnknown, formatError, getTypeIssues) => {
         to,
         orThrow,
         orNull: to,
-        "~standard": createStandardSchemaProps(fromUnknown, runtimeGetTypeIssues, formatDefaultRuntimeTypeIssue),
+        "~standard": {
+            version: 1,
+            vendor: "evolu",
+            validate: (value) => {
+                const result = fromUnknown(value, allValidationOptions);
+                return result.ok
+                    ? { value: result.value }
+                    : {
+                        issues: runtimeGetTypeIssues(result.error, "all", []).map((issue) => ({
+                            message: formatRuntimeTypeIssue(issue),
+                            path: issue.path,
+                        })),
+                    };
+            },
+        },
         [outputValidationSymbol]: fromUnknown,
         [fromSymbol]: ok,
         [encoderSymbol]: identity,
         [getRuntimeTypeIssuesSymbol]: runtimeGetTypeIssues,
+        [checkSymbol]: check,
+        [refinementsSymbol]: undefined,
+        [arrayTypeSymbol]: undefined,
+        [setTypeSymbol]: undefined,
     };
 };
 const createChildType = (name, parent, fromParent, formatOwnError, 
 // Wrapped child errors can delegate their structured issues.
-getTypeIssuesOverride) => {
+getTypeIssuesOverride, 
+// A refinement `fromParent` only checks the parent Output and returns
+// `ok()`, so the child can return the parent Result unchanged.
+isRefinement = false) => {
     const typeParent = parent;
     const defaultFormatter = formatOwnError;
     const getTypeIssues = getTypeIssuesOverride ??
         (formatOwnError
-            ? (error, mode) => error.type === name
-                ? singleRuntimeTypeIssue(name, error, defaultFormatter)
-                : typeParent[getRuntimeTypeIssuesSymbol](error, mode)
+            ? (error, mode, path) => error.type === name
+                ? singleRuntimeTypeIssue(name, error, defaultFormatter, path)
+                : typeParent[getRuntimeTypeIssuesSymbol](error, mode, path)
             : typeParent[getRuntimeTypeIssuesSymbol]);
+    // Validators get only the value and no receiver (refinements are read into
+    // a local before a call), so default parameters, `arguments`, and `this`
+    // behave as in a direct call.
     const validate = fromParent;
-    const mapFromParent = (result, options) => (result.ok ? validate(result.value, options) : result);
-    const fromParentOperation = mapRuntimeOperations(typeParent[fromSymbol], (operation) => mapRuntimeResult(operation, mapFromParent));
+    // Returning the parent Result avoids allocating an equal Ok per layer.
+    const mapFromParent = isRefinement
+        ? (result) => {
+            if (!result.ok)
+                return result;
+            const refined = validate(result.value);
+            return refined.ok ? result : refined;
+        }
+        : (result) => result.ok ? validate(result.value) : result;
+    // Parent operations are read once, so validation skips repeated property
+    // lookups on heterogeneous Type nodes.
+    const parentFromUnknown = typeParent.fromUnknown;
+    const parentValidateOutput = typeParent[outputValidationSymbol];
+    const parentFrom = typeParent[fromSymbol];
+    const fromParentOperation = (value, options = firstValidationOptions) => mapFromParent(parentFrom(value, options));
+    if (parentFrom.parent) {
+        fromParentOperation.parent = mapRuntimeOperations(parentFrom.parent, (operation) => mapRuntimeResult(operation, mapFromParent));
+    }
     const from = createFromOperation(fromParentOperation);
-    const fromUnknown = (value, options = firstValidationOptions) => mapFromParent(typeParent.fromUnknown(value, options), options);
-    const validateOutput = (value, options = firstValidationOptions) => mapFromParent(typeParent[outputValidationSymbol](value, options), options);
+    // Refinement children form a chain whose refinements run in order after
+    // its base, the nearest ancestor that is not a refinement, so nested
+    // refinements need no call per level.
+    const parentRefinements = isRefinement
+        ? typeParent[refinementsSymbol]
+        : undefined;
+    const refinements = parentRefinements
+        ? [...parentRefinements, validate]
+        : [validate];
+    const refinementCount = refinements.length;
+    let base = typeParent;
+    if (isRefinement) {
+        while (base[refinementsSymbol])
+            base = base.parent;
+    }
+    const isBase = base.is;
+    const is = (value) => {
+        if (!isBase(value))
+            return false;
+        for (let index = 0; index < refinementCount; index++) {
+            const refine = refinements[index];
+            if (!refine(value).ok)
+                return false;
+        }
+        return true;
+    };
+    const baseCheck = base[checkSymbol];
+    // A child returns its parent Output unchanged, so a child of an identity
+    // Type is one too.
+    const check = baseCheck &&
+        ((value, options) => {
+            const error = baseCheck(value, options);
+            if (error !== undefined)
+                return error;
+            for (let index = 0; index < refinementCount; index++) {
+                const refine = refinements[index];
+                const result = refine(value);
+                if (!result.ok)
+                    return result.error;
+            }
+            return undefined;
+        });
+    const validateBase = base.fromUnknown;
+    // Like nested refinement children, it returns the base Result or the first
+    // refinement Err. A single refinement is faster with its direct call.
+    const fromUnknown = refinementCount > 1
+        ? (value, options = firstValidationOptions) => {
+            const result = validateBase(value, options);
+            if (!result.ok)
+                return result;
+            for (let index = 0; index < refinementCount; index++) {
+                const refine = refinements[index];
+                const refined = refine(result.value);
+                if (!refined.ok)
+                    return refined;
+            }
+            return result;
+        }
+        : (value, options = firstValidationOptions) => mapFromParent(parentFromUnknown(value, options));
+    // A root parent validates its Output with fromUnknown, and so does a child
+    // of such a parent.
+    const validateOutput = parentValidateOutput === parentFromUnknown
+        ? fromUnknown
+        : (value, options = firstValidationOptions) => mapFromParent(parentValidateOutput(value, options));
     const to = identity;
-    return createTypeNode(name, typeParent, fromUnknown, (value) => typeParent.is(value) && validate(value, firstValidationOptions).ok, validateOutput, from, to, getTypeIssues);
+    return createTypeNode(name, typeParent, fromUnknown, is, validateOutput, from, to, getTypeIssues, { check, refinements: isRefinement ? refinements : undefined });
 };
 export function transform(name, parent, output, { from: transformFrom, to: transformTo, }, formatOwnError) {
     const typeParent = parent;
@@ -802,20 +1077,20 @@ export function transform(name, parent, output, { from: transformFrom, to: trans
         return parentValue;
     };
     const defaultFormatter = formatOwnError;
-    const getTypeIssues = (error, mode) => {
+    const getTypeIssues = (error, mode, path) => {
         if (error.type !== name) {
-            return typeParent[getRuntimeTypeIssuesSymbol](error, mode);
+            return typeParent[getRuntimeTypeIssuesSymbol](error, mode, path);
         }
         if ("outputError" in error) {
-            return typeOutput[getRuntimeTypeIssuesSymbol](error.outputError, mode);
+            return typeOutput[getRuntimeTypeIssuesSymbol](error.outputError, mode, path);
         }
-        return singleRuntimeTypeIssue(name, error, defaultFormatter);
+        return singleRuntimeTypeIssue(name, error, defaultFormatter, path);
     };
     const validateOutput = (value, options) => {
         const result = typeOutput[outputValidationSymbol](value, options);
         return result.ok ? result : err({ type: name, outputError: result.error });
     };
-    return createTypeNode(name, typeParent, fromUnknown, typeOutput.is, validateOutput, from, to, getTypeIssues, { output: typeOutput });
+    return createTypeNode(name, typeParent, fromUnknown, typeOutput.is, validateOutput, from, to, getTypeIssues, { additionalProperties: { output: typeOutput } });
 }
 const firstValidationOptions = { errors: "first" };
 const allValidationOptions = { errors: "all" };
@@ -825,7 +1100,39 @@ const fromSymbol =
 /*#__PURE__*/ globalThis.Symbol();
 const templateLiteralSyntaxSymbol = 
 /*#__PURE__*/ globalThis.Symbol();
+// A Type node caches the Array and Set Types of itself as an element in these
+// own properties; a Type whose slot cannot be written, such as a frozen one,
+// uses the typeByElement WeakMaps. A WeakMap alone keeps each entry's value
+// alive through young-generation GCs, so every schema created at runtime would
+// be promoted.
+const arrayTypeSymbol = /*#__PURE__*/ globalThis.Symbol();
+const setTypeSymbol = /*#__PURE__*/ globalThis.Symbol();
+const checkSymbol = 
+/*#__PURE__*/ globalThis.Symbol();
+const refinementsSymbol = 
+/*#__PURE__*/ globalThis.Symbol();
+// The `fromUnknown` of an identity Type.
+const checkToFromUnknown = (check) => (value, options = firstValidationOptions) => {
+    const error = check(value, options);
+    return error === undefined ? ok(value) : err(error);
+};
+// The checks of identity Types, or `undefined` if any Type is not one.
+const getRuntimeChecks = (types) => {
+    const checks = [];
+    for (const type of types) {
+        const check = type[checkSymbol];
+        if (check === undefined)
+            return undefined;
+        checks.push(check);
+    }
+    return checks;
+};
 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);
@@ -841,37 +1148,56 @@ const createFromOperation = (parent) => {
     from.parent = parent;
     return from;
 };
-const createToOperation = (parent, own) => {
-    const mapOwnToParent = (operation) => (value) => operation(own(value));
-    const to = mapOwnToParent(parent);
-    const toParent = mapRuntimeResult(own, identity);
-    if (parent.parent) {
-        toParent.parent = mapRuntimeOperations(parent.parent, mapOwnToParent);
-    }
-    to.parent = toParent;
-    return to;
-};
+// Composite Types read these operations of their Types on first use, so
+// construction allocates no arrays and validation skips property lookups on
+// heterogeneous Type nodes.
+const getFromUnknown = (type) => type.fromUnknown;
+const getValidateOutput = (type) => type[outputValidationSymbol];
+const getIs = (type) => type.is;
 function getTerminalRuntimeNode(node) {
     while (node.parent != null)
         node = node.parent;
     return node;
 }
-const createTypeNode = (name, parent, fromUnknown, is, validateOutput, from, ownTo, getTypeIssues, additionalProperties, formatIssue = formatDefaultRuntimeTypeIssue) => {
+const createTypeNode = (name, parent, fromUnknown, is, validateOutput, from, ownTo, getTypeIssues, { additionalProperties, formatIssue = formatDefaultRuntimeTypeIssue, check, refinements, } = {}) => {
     const runtimeParent = parent;
-    const to = runtimeParent
-        ? createToOperation(runtimeParent[encoderSymbol], ownTo)
-        : ownTo;
+    const parentTo = runtimeParent?.[encoderSymbol];
+    // Operations defined directly here share this call's closure context, so a
+    // Type node does not allocate one context per helper.
+    let to = ownTo;
+    if (parentTo) {
+        to = (value) => parentTo(ownTo(value));
+        const toParent = (value, options = firstValidationOptions) => ownTo(value, options);
+        if (parentTo.parent) {
+            toParent.parent = mapRuntimeOperations(parentTo.parent, (operation) => (value) => operation(ownTo(value)));
+        }
+        to.parent = toParent;
+    }
     const runtimeFormatError = runtimeParent?.[getRuntimeTypeIssuesSymbol] === getTypeIssues
         ? runtimeParent.formatError
-        : (error) => formatIssue(getTypeIssues(error, "first")[0]);
-    const typedFrom = addRuntimeAssertions(name, is, validateOutput, parent, from);
+        : (error) => formatRuntimeTypeIssue(getTypeIssues(error, "first", [])[0], formatIssue);
+    const typedFrom = (value, options = firstValidationOptions) => {
+        assertTypeOutput(name, is, validateOutput, value, options);
+        return from(value, options);
+    };
+    if (from.parent) {
+        typedFrom.parent = addRuntimeAssertions(runtimeParent, from.parent);
+    }
     const fromInput = getTerminalRuntimeNode(typedFrom);
-    const typedTo = mapRuntimeOperations(to, (operation) => (value) => {
+    const typedTo = (value) => {
         assertTypeOutput(name, is, validateOutput, value);
-        return operation(value);
-    });
+        return to(value);
+    };
+    if (to.parent) {
+        typedTo.parent = mapRuntimeOperations(to.parent, (operation) => (value) => {
+            assertTypeOutput(name, is, validateOutput, value);
+            return operation(value);
+        });
+    }
+    // A spread-free literal gets a fixed shape; spreading in the middle made
+    // every later property a slow generic definition.
     const type = {
-        ...instance("Type"),
+        "~evolu/instance": "Type",
         name,
         parent,
         fromUnknown,
@@ -879,41 +1205,55 @@ const createTypeNode = (name, parent, fromUnknown, is, validateOutput, from, own
         is,
         from: typedFrom,
         to: typedTo,
-        orThrow: mapRuntimeResult(fromInput, getOrThrow),
-        orNull: mapRuntimeResult(fromInput, getOrNull),
-        "~standard": createStandardSchemaProps(fromUnknown, getTypeIssues, formatIssue),
-        ...additionalProperties,
+        orThrow: (value, options = firstValidationOptions) => {
+            const result = fromInput(value, options);
+            if (result.ok)
+                return result.value;
+            throw new Error(runtimeFormatError(result.error), {
+                cause: result.error,
+            });
+        },
+        orNull: (value, options = firstValidationOptions) => getOrNull(fromInput(value, options)),
+        "~standard": {
+            version: 1,
+            vendor: "evolu",
+            validate: (value) => {
+                const result = fromUnknown(value, allValidationOptions);
+                return result.ok
+                    ? { value: result.value }
+                    : {
+                        issues: getTypeIssues(result.error, "all", []).map((issue) => ({
+                            message: formatRuntimeTypeIssue(issue, formatIssue),
+                            path: issue.path,
+                        })),
+                    };
+            },
+        },
         [outputValidationSymbol]: validateOutput,
         [fromSymbol]: from,
         [encoderSymbol]: to,
         [getRuntimeTypeIssuesSymbol]: getTypeIssues,
+        [checkSymbol]: check,
+        [refinementsSymbol]: refinements,
+        [arrayTypeSymbol]: undefined,
+        [setTypeSymbol]: undefined,
     };
+    if (additionalProperties !== undefined) {
+        globalThis.Object.assign(type, additionalProperties);
+    }
     return type;
 };
-const createStandardSchemaProps = (fromUnknown, getTypeIssues, formatIssue) => ({
-    version: 1,
-    vendor: "evolu",
-    validate: (value) => {
-        const result = fromUnknown(value, allValidationOptions);
-        return result.ok
-            ? { value: result.value }
-            : {
-                issues: getTypeIssues(result.error, "all").map((issue) => ({
-                    message: formatIssue(issue),
-                    path: issue.path,
-                })),
-            };
-    },
-});
-const addRuntimeAssertions = (name, is, validateOutput, parent, operation) => {
+// Each `from.parent` suffix asserts the Output of the next Type toward the
+// root before running the remaining pipeline.
+const addRuntimeAssertions = (boundary, operation) => {
+    const { name, is } = boundary;
+    const validateOutput = boundary[outputValidationSymbol];
     const asserted = (value, options = firstValidationOptions) => {
         assertTypeOutput(name, is, validateOutput, value, options);
         return operation(value, options);
     };
     if (operation.parent) {
-        const typeParent = parent;
-        const runtimeParent = typeParent;
-        asserted.parent = addRuntimeAssertions(runtimeParent.name, runtimeParent.is, runtimeParent[outputValidationSymbol], runtimeParent.parent, operation.parent);
+        asserted.parent = addRuntimeAssertions(boundary.parent, operation.parent);
     }
     return asserted;
 };
@@ -922,18 +1262,26 @@ const addRuntimeAssertions = (name, is, validateOutput, parent, operation) => {
  *
  * @group Base
  */
-export const Unknown = /*#__PURE__*/ createRootType("Unknown", ok, identity);
+export const Unknown = /*#__PURE__*/ createRootType("Unknown", ok, identity, { isOutput: () => true, check: () => undefined });
 /**
  * A {@link Type} rejecting every value.
  *
  * @group Base
  */
-export const Never = /*#__PURE__*/ createRootType("Never", (value) => err({ type: "Never", value }), (error) => `A value ${safelyStringifyUnknownValue(error.value)} is not valid for type Never.`);
+export const Never = /*#__PURE__*/ createRootType("Never", (value) => err({ type: "Never", value }), (error) => `A value ${safelyStringifyUnknownValue(error.value)} is not valid for type Never.`, {
+    isOutput: () => false,
+    check: (value) => ({ type: "Never", value }),
+});
 const createTypeOfType = (name) => {
     const typeOf = name.toLowerCase();
     return createRootType(name, (value) => typeof value === typeOf
         ? ok(value)
-        : err({ type: "TypeOf", expected: name, value }), (error) => `A value ${safelyStringifyUnknownValue(error.value)} is not a ${typeOf}.`);
+        : err({ type: "TypeOf", expected: name, value }), (error) => `A value ${safelyStringifyUnknownValue(error.value)} is not a ${typeOf}.`, {
+        isOutput: (value) => typeof value === typeOf,
+        check: (value) => typeof value === typeOf
+            ? undefined
+            : { type: "TypeOf", expected: name, value },
+    });
 };
 /**
  * A JavaScript string {@link Type} without additional constraints.
@@ -1035,6 +1383,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 +1409,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}.
  *
@@ -1085,18 +1474,25 @@ export const EvoluType = /*#__PURE__*/ createType("EvoluType", (value) => isInst
     : err({ type: "EvoluType", value }), (error) => `A value ${safelyStringifyUnknownValue(error.value)} is not an Evolu Type.`);
 export function objectTag(name, outputType) {
     const formatError = (error) => `A value ${safelyStringifyUnknownValue(error.value)} does not have the expected object tag ${safelyStringifyUnknownValue(error.expected)}.`;
+    const tag = `[object ${name}]`;
     if (outputType === undefined) {
-        return createRootType(name, (value) => hasObjectTag(value, name)
+        return createRootType(name, (value) => hasObjectTag(value, tag)
             ? ok(value)
-            : err({ type: "ObjectTag", expected: name, value }), formatError);
+            : err({ type: "ObjectTag", expected: name, value }), formatError, {
+            isOutput: (value) => hasObjectTag(value, tag),
+            check: (value) => hasObjectTag(value, tag)
+                ? undefined
+                : { type: "ObjectTag", expected: name, value },
+        });
     }
-    return globalThis.Object.assign(createChildType("ObjectTag", outputType, (value) => hasObjectTag(value, name)
+    return globalThis.Object.assign(createChildType("ObjectTag", outputType, (value) => hasObjectTag(value, tag)
         ? ok(value)
         : err({ type: "ObjectTag", expected: name, value }), formatError), { expected: name });
 }
-const hasObjectTag = (value, expected) => value !== null &&
+// Takes the complete `[object Name]` tag, so hot calls build no string.
+const hasObjectTag = (value, tag) => value !== null &&
     (typeof value === "object" || typeof value === "function") &&
-    globalThis.Object.prototype.toString.call(value) === `[object ${expected}]`;
+    globalThis.Object.prototype.toString.call(value) === tag;
 /**
  * A realm-neutral JavaScript Date {@link Type} for trusted values.
  *
@@ -1158,7 +1554,12 @@ export const instanceOf = (constructor) => {
     const constructorName = concreteConstructor.name;
     const is = (value) => globalThis.Function.prototype[globalThis.Symbol.hasInstance].call(concreteConstructor, value);
     const fromUnknown = (value) => is(value) ? ok(value) : err({ type: "InstanceOf", constructorName, value });
-    return globalThis.Object.assign(createRootType("InstanceOf", fromUnknown, (error) => `A value ${safelyStringifyUnknownValue(error.value)} is not an instance of ${error.constructorName}.`), { constructor: concreteConstructor });
+    return globalThis.Object.assign(createRootType("InstanceOf", fromUnknown, (error) => `A value ${safelyStringifyUnknownValue(error.value)} is not an instance of ${error.constructorName}.`, {
+        isOutput: is,
+        check: (value) => is(value)
+            ? undefined
+            : { type: "InstanceOf", constructorName, value },
+    }), { constructor: concreteConstructor });
 };
 /**
  * Literal {@link Type}.
@@ -1188,6 +1589,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);
@@ -1202,9 +1604,6 @@ export const instanceOf = (constructor) => {
  */
 export const literal = (expected) => {
     const literalExpected = expected;
-    const validate = (value) => value === literalExpected
-        ? ok(value)
-        : err({ type: "Literal", expected: literalExpected, value });
     const parent = typeof literalExpected === "string"
         ? String
         : typeof literalExpected === "number"
@@ -1216,8 +1615,17 @@ export const literal = (expected) => {
                     : null;
     const formatError = (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not strictly equal to the expected literal: ${globalThis.String(error.expected)}.`;
     return globalThis.Object.assign(parent
-        ? createChildType("Literal", parent, validate, formatError)
-        : createRootType("Literal", validate, formatError), {
+        ? createChildType("Literal", parent, (value) => value === literalExpected
+            ? ok()
+            : err({ type: "Literal", expected: literalExpected, value }), formatError, undefined, true)
+        : createRootType("Literal", (value) => value === literalExpected
+            ? ok(value)
+            : err({ type: "Literal", expected: literalExpected, value }), formatError, {
+            isOutput: (value) => value === literalExpected,
+            check: (value) => value === literalExpected
+                ? undefined
+                : { type: "Literal", expected: literalExpected, value },
+        }), {
         expected: literalExpected,
         [templateLiteralSyntaxSymbol]: true,
     });
@@ -1239,17 +1647,35 @@ export function union(...typesOrLiterals) {
         ? typeOrLiteral
         : literal(typeOrLiteral));
     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 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]));
-    const fromParent = createUnionValidation(members, (_member, value, options, index) => inputMembers[index].is(value)
-        ? memberFromInputs[index](value, options)
-        : undefined);
+    const inputCheck = createUnionCheck(inputMembers);
+    const inputFrom = inputCheck
+        ? checkToFromUnknown(inputCheck)
+        : createUnionValidation(inputMembers, getFromUnknown);
+    const getTypeIssues = createUnionRuntimeTypeIssues(members);
+    const input = createTypeNode("Union", null, inputFrom, createUnionIs(inputMembers), inputCheck
+        ? inputFrom
+        : createUnionValidation(inputMembers, getValidateOutput), ok, identity, createUnionRuntimeTypeIssues(inputMembers), { check: inputCheck });
+    // Literal members accept exactly their `===` equal values, so a match skips
+    // them.
+    const isLiteralUnion = typesOrLiterals.every((typeOrLiteral) => typeOrLiteral === null || typeof typeOrLiteral !== "object");
+    const isLiteral = (value) => 
+    // oxlint-disable-next-line typescript/prefer-includes -- Like Literal validation, indexOf uses ===, so NaN never matches.
+    typesOrLiterals.indexOf(value) !== -1;
+    const checkMembers = createUnionCheck(members);
+    const check = checkMembers && isLiteralUnion
+        ? (value, options) => isLiteral(value) ? undefined : checkMembers(value, options)
+        : checkMembers;
+    const fromUnknown = check
+        ? checkToFromUnknown(check)
+        : createUnionValidation(members, getFromUnknown);
+    const validateOutput = check
+        ? fromUnknown
+        : createUnionValidation(members, getValidateOutput);
+    const fromParent = createUnionValidation(members, (member, index) => {
+        const memberFromInput = getTerminalRuntimeNode(member[fromSymbol]);
+        const inputIs = inputMembers[index].is;
+        return (value, options) => inputIs(value) ? memberFromInput(value, options) : undefined;
+    });
     const getOutputMember = (value) => members.find((member) => member.is(value));
     const from = createFromOperation(fromParent);
     const to = (value) => {
@@ -1257,25 +1683,99 @@ export function union(...typesOrLiterals) {
         assertNonNullable(member);
         return member[encoderSymbol](value);
     };
-    return createTypeNode("Union", input, fromUnknown, (value) => members.some((member) => member.is(value)), validateOutput, from, to, getTypeIssues, { members, [templateLiteralSyntaxSymbol]: true });
+    return createTypeNode("Union", input, fromUnknown, isLiteralUnion ? isLiteral : createUnionIs(members), validateOutput, from, to, getTypeIssues, {
+        additionalProperties: { members, [templateLiteralSyntaxSymbol]: true },
+        check,
+    });
 }
-const createUnionValidation = (members, validateMember) => (value, options = firstValidationOptions) => {
-    let errors;
-    for (let index = 0; index < members.length; index++) {
-        const result = validateMember(members[index], value, options, index);
-        if (result === undefined)
-            continue;
-        if (result.ok)
-            return result;
-        if (errors === undefined || options.errors === "all") {
-            (errors ??= []).push({ index, error: result.error });
-        }
+const createUnionRuntimeTypeIssues = (members) => (error, _mode, path) => [
+    {
+        name: "Union",
+        error,
+        path,
+        formatError: () => "A value does not match any allowed variant.",
+        // Alternative issue paths are relative to the Union value.
+        alternatives: error.errors.map(({ index, error }) => ({
+            index,
+            name: members[index].name,
+            issues: members[index][getRuntimeTypeIssuesSymbol](error, "all", []),
+        })),
+    },
+];
+const createUnionIs = (members) => {
+    // Two members, as in nullOr, are checked without a loop.
+    if (members.length === 2) {
+        const firstIs = members[0].is;
+        const secondIs = members[1].is;
+        return (value) => firstIs(value) || secondIs(value);
     }
-    assertNonNullable(errors);
-    return err({
-        type: "Union",
-        errors: errors,
-    });
+    let memberIs;
+    return (value) => {
+        const isMembers = (memberIs ??= members.map(getIs));
+        for (let index = 0; index < isMembers.length; index++) {
+            if (isMembers[index](value))
+                return true;
+        }
+        return false;
+    };
+};
+// A Union of identity Types returns the Result of the first valid member, so
+// it is an identity Type too.
+const createUnionCheck = (members) => {
+    const checks = getRuntimeChecks(members);
+    if (checks === undefined)
+        return undefined;
+    return (value, options) => {
+        // The same errors as createUnionValidation.
+        let first;
+        let errors;
+        for (let index = 0; index < checks.length; index++) {
+            const error = checks[index](value, options);
+            if (error === undefined)
+                return undefined;
+            if (first === undefined) {
+                first = { index, error };
+            }
+            else if (options.errors === "all") {
+                (errors ??= [first]).push({ index, error });
+            }
+        }
+        assertNonNullable(first);
+        return {
+            type: "Union",
+            errors: (errors ?? [first]),
+        };
+    };
+};
+// A member validation returns `undefined` to skip its member.
+const createUnionValidation = (members, getMemberValidation) => {
+    let memberValidations;
+    return (value, options = firstValidationOptions) => {
+        const validations = (memberValidations ??=
+            members.map(getMemberValidation));
+        // A later member often matches (nullOr), so the error array is created
+        // only when a second member fails or the Union fails.
+        let first;
+        let errors;
+        for (let index = 0; index < validations.length; index++) {
+            const result = validations[index](value, options);
+            if (result === undefined)
+                continue;
+            if (result.ok)
+                return result;
+            if (first === undefined) {
+                first = { index, error: result.error };
+            }
+            else if (options.errors === "all") {
+                (errors ??= [first]).push({ index, error: result.error });
+            }
+        }
+        assertNonNullable(first);
+        return err({
+            type: "Union",
+            errors: (errors ?? [first]),
+        });
+    };
 };
 /**
  * Union {@link Type} containing the supplied Type and `undefined`.
@@ -1398,6 +1898,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);
@@ -1568,14 +2069,14 @@ const createTemplateLiteralParserType = (templateParts) => {
             return result;
         return err({ type: "TemplateLiteral", value: stringResult.value });
     };
-    const getTypeIssues = (error, mode) => {
+    const getTypeIssues = (error, mode, path) => {
         if (error.type !== "TemplateLiteral") {
-            return String[getRuntimeTypeIssuesSymbol](error, mode);
+            return String[getRuntimeTypeIssuesSymbol](error, mode, path);
         }
         if ("outputError" in error) {
-            return runtimeOutput[getRuntimeTypeIssuesSymbol](error.outputError, mode);
+            return runtimeOutput[getRuntimeTypeIssuesSymbol](error.outputError, mode, path);
         }
-        return singleRuntimeTypeIssue("TemplateLiteral", error, ((error) => `The value ${safelyStringifyUnknownValue(error.value)} does not match the template literal.`));
+        return singleRuntimeTypeIssue("TemplateLiteral", error, ((error) => `The value ${safelyStringifyUnknownValue(error.value)} does not match the template literal.`), path);
     };
     const canonicalStringFromUnknown = (value, options = firstValidationOptions) => {
         const stringResult = String.fromUnknown(value, options);
@@ -1584,7 +2085,7 @@ const createTemplateLiteralParserType = (templateParts) => {
             : stringResult;
     };
     const canonicalStringFrom = createFromOperation((value, options = firstValidationOptions) => canonicalizeString(value, options));
-    const stringType = createTypeNode("TemplateLiteral", String, canonicalStringFromUnknown, (value) => validateCanonicalString(value, firstValidationOptions).ok, validateCanonicalString, canonicalStringFrom, identity, getTypeIssues, reflection);
+    const stringType = createTypeNode("TemplateLiteral", String, canonicalStringFromUnknown, (value) => validateCanonicalString(value, firstValidationOptions).ok, validateCanonicalString, canonicalStringFrom, identity, getTypeIssues, { additionalProperties: reflection });
     const fromUnknown = (value, options = firstValidationOptions) => {
         const stringResult = String.fromUnknown(value, options);
         if (!stringResult.ok)
@@ -1614,7 +2115,7 @@ const createTemplateLiteralParserType = (templateParts) => {
     };
     fromCanonicalString.parent = fromString;
     const from = createFromOperation(fromCanonicalString);
-    const type = createTypeNode("TemplateLiteral", stringType, fromUnknown, runtimeOutput.is, runtimeOutput[outputValidationSymbol], from, encodeCaptures, getTypeIssues, reflection);
+    const type = createTypeNode("TemplateLiteral", stringType, fromUnknown, runtimeOutput.is, runtimeOutput[outputValidationSymbol], from, encodeCaptures, getTypeIssues, { additionalProperties: reflection });
     type.from.parent =
         fromCanonicalString;
     return type;
@@ -1756,9 +2257,7 @@ const getTemplateLiteralPartFraming = (part) => {
     return getTemplateLiteralPartFraming(type.parent);
 };
 export function brand(name, parent, validate, formatError) {
-    return createChildType(name, parent, validate
-        ? (value) => flatMapResult(validate(value), () => ok(value))
-        : ok, formatError);
+    return createChildType(name, parent, validate ?? (() => ok()), formatError, undefined, true);
 }
 /**
  * Canonical ISO date-time {@link String}.
@@ -1785,6 +2284,7 @@ export function brand(name, parent, validate, formatError) {
  *
  * 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);
@@ -1837,126 +2337,790 @@ export const UInt64 = /*#__PURE__*/ brand("UInt64", BigInt, (value) => globalThi
     ? ok()
     : err({ type: "UInt64", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} is not a valid unsigned 64-bit integer (UInt64).`);
 /**
- * Capitalized {@link Brand}.
- *
- * Requires the first character of a string to be uppercase.
+ * Adds identifier validation in a naming convention to an existing string Type.
+ *
+ * An identifier is one or more ASCII words, each starting with a letter and
+ * continuing with letters or digits. camelCase and PascalCase start every word
+ * after the first with an uppercase letter, so `httpUrl` has two words and
+ * `httpURL` has four. snake_case, kebab-case, and CONSTANT_CASE put exactly one
+ * separator between words. Validation keeps the spelling and rejects empty
+ * strings, whitespace, punctuation, and non-ASCII characters.
+ *
+ * Words never start with a digit. Identifier grammars in most languages forbid
+ * a leading digit, and camelCase cannot mark a word boundary before one, so the
+ * rule applies to every word and keeps every conversion exact. Join an
+ * abbreviation such as `2FA` to the previous word, as in `MAX2FA_ATTEMPTS` and
+ * `max2faAttempts`, or spell the number out, as in `TWO_FACTOR_SECRET`.
+ *
+ * Convert validated identifiers with functions such as
+ * {@link camelCaseToSnakeCase}. Conversions preserve word boundaries, and
+ * converting back restores the original spelling. They return only the
+ * destination brand, dropping unrelated constraints such as input length.
  *
  * ### Example
  *
  * ```ts
  * import {
- *   assertEqual,
  *   assertErr,
  *   assertOk,
- *   assertType,
- *   Data,
+ *   identifier,
+ *   maxLength,
  *   String,
- *   capitalized,
- *   type Brand,
  * } from "@evolu/common";
  *
- * const CapitalizedString = capitalized(String);
- * type CapitalizedString = typeof CapitalizedString.Output;
- *
- * assertType<CapitalizedString, string & Brand<"Capitalized">>();
+ * const EnvName = identifier("CONSTANT_CASE")(maxLength(16)(String));
  *
- * assertOk(CapitalizedString.fromUnknown("Evolu"), "Evolu");
- * const invalid = CapitalizedString.fromUnknown("evolu");
- * assertErr(invalid);
- * assertType(Data, invalid.error);
- * assertEqual(invalid.error, {
- *   type: "Capitalized",
- *   value: "evolu",
- * });
+ * assertOk(EnvName.fromUnknown("HTTP2_PORT"), "HTTP2_PORT");
+ * assertErr(EnvName.fromUnknown("HTTP_2_PORT"));
  * ```
  *
  * @group String
  */
-export const capitalized = (parent) => brand("Capitalized", parent, (value) => {
-    const [first = ""] = value;
-    return value === first.toUpperCase() + value.slice(first.length)
+export const identifier = (casing) => (parent) => {
+    const name = identifierBrandByCasing[casing];
+    const pattern = identifierPatternByCasing[casing];
+    return brand(name, parent, (value) => pattern.test(value)
         ? ok()
-        : err({ type: "Capitalized", value });
-}, (error) => `The value ${safelyStringifyUnknownValue(error.value)} must be capitalized.`);
+        : 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,
+};
 /**
- * Capitalized {@link String}.
+ * A validated camelCase identifier, such as `http2Port`.
+ *
+ * See {@link identifier} for the grammar and the conversion functions.
  *
  * @group String
  */
-export const CapitalizedString = /*#__PURE__*/ capitalized(String);
+export const CamelCaseIdentifier = 
+/*#__PURE__*/ identifier("camelCase")(String);
 /**
- * String {@link Brand} without surrounding whitespace.
- *
- * ### Example
+ * A validated PascalCase identifier, such as `Http2Port`.
  *
- * ```ts
- * import { assertOk, String, trimmed } from "@evolu/common";
+ * See {@link identifier} for the grammar and the conversion functions.
  *
- * const Trimmed = trimmed(String);
+ * @group String
+ */
+export const PascalCaseIdentifier = 
+/*#__PURE__*/ identifier("PascalCase")(String);
+/**
+ * A validated snake_case identifier, such as `http2_port`.
  *
- * assertOk(Trimmed.fromUnknown("Evolu"), "Evolu");
- * ```
+ * See {@link identifier} for the grammar and the conversion functions.
  *
  * @group String
  */
-export const trimmed = (parent) => brand("Trimmed", parent, (value) => value === value.trim()
-    ? ok()
-    : err({ type: "Trimmed", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} must be trimmed.`);
+export const SnakeCaseIdentifier = 
+/*#__PURE__*/ identifier("snake_case")(String);
 /**
- * A {@link String} without surrounding whitespace.
+ * A validated kebab-case identifier, such as `http2-port`.
  *
- * This Type validates that a string is already trimmed; it does not modify the
- * value. Use {@link trim} to normalize a string. Because an empty string is
- * valid, this Type is useful as an intermediate boundary for input controls
- * that trim their values before domain validation. If an empty string is
- * invalid, use {@link NonEmptyTrimmedString}.
+ * See {@link identifier} for the grammar and the conversion functions.
  *
  * @group String
  */
-export const TrimmedString = /*#__PURE__*/ trimmed(String);
+export const KebabCaseIdentifier = 
+/*#__PURE__*/ identifier("kebab-case")(String);
 /**
- * Trims a string and returns a {@link TrimmedString}.
+ * A validated CONSTANT_CASE identifier, such as `HTTP2_PORT`.
  *
- * ### Example
+ * See {@link identifier} for the grammar and the conversion functions.
  *
- * ```ts
- * import { assertEqual, trim } from "@evolu/common";
+ * @group String
+ */
+export const ConstantCaseIdentifier = 
+/*#__PURE__*/ identifier("CONSTANT_CASE")(String);
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link PascalCaseIdentifier}.
  *
- * assertEqual(trim("  Evolu  "), "Evolu");
- * ```
+ * Converts `http2Port` to `Http2Port`. Use {@link pascalCaseToCamelCase} to
+ * recover the original spelling.
  *
  * @group String
  */
-export const trim = (value) => value.trim();
+export const camelCaseToPascalCase = (value) => (value.charAt(0).toUpperCase() + value.slice(1));
 /**
- * Minimum-length {@link Brand} for values whose `length` is at least `min`.
- *
- * ### Example
+ * Converts a {@link CamelCaseIdentifier} to a {@link SnakeCaseIdentifier}.
  *
- * ```ts
- * import { assertOk, String, array, minLength } from "@evolu/common";
+ * Converts `http2Port` to `http2_port`. Use {@link snakeCaseToCamelCase} to
+ * recover the original spelling.
  *
- * const AtLeastThreeCharacters = minLength(3)(String);
- * const AtLeastTwoItems = minLength(2)(array(String));
+ * @group String
+ */
+export const camelCaseToSnakeCase = (value) => value.replaceAll(/[A-Z]/gu, (letter) => `_${letter.toLowerCase()}`);
+/**
+ * Converts a {@link CamelCaseIdentifier} to a {@link KebabCaseIdentifier}.
  *
- * assertOk(AtLeastThreeCharacters.fromUnknown("abc"), "abc");
- * assertOk(AtLeastTwoItems.fromUnknown(["a", "b"]), ["a", "b"]);
- * ```
+ * Converts `http2Port` to `http2-port`. Use {@link kebabCaseToCamelCase} to
+ * recover the original spelling.
  *
  * @group String
- * @group Collection
  */
-export const minLength = (min) => (parent) => {
-    const name = `MinLength${min}`;
-    return brand(name, parent, (value) => value.length >= min
-        ? ok()
-        : err({ type: name, value, min }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} does not meet the minimum length of ${error.min}.`);
-};
+export const camelCaseToKebabCase = (value) => snakeCaseToKebabCase(camelCaseToSnakeCase(value));
 /**
- * A non-empty {@link TrimmedString}.
+ * Converts a {@link CamelCaseIdentifier} to a {@link ConstantCaseIdentifier}.
  *
- * Use as the base Type for ordinary human-entered text, which should usually be
- * trimmed, non-empty, and bounded. Add a domain-appropriate maximum with
+ * 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,
+ *   uppercased,
+ *   maxLength,
+ *   String,
+ * } from "@evolu/common";
+ *
+ * const Label = uppercased(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("HELLO WORLD"), "HELLO WORLD");
+ * assertErr(Label.fromUnknown("Hello world"));
+ * ```
+ *
+ * @group String
+ */
+export const uppercased = (parent) => createType("Uppercased", parent, (value) => value === uppercase(value)
+    ? ok(value)
+    : err({ type: "Uppercased", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} must be uppercased.`);
+/**
+ * Validates uppercased text as TypeScript's `Uppercase<string>`.
+ *
+ * Checks the whole string using JavaScript's Unicode uppercase mapping. Empty
+ * strings and uncased characters, such as digits and emoji, are valid. Use
+ * {@link uppercase} to produce an uppercased value from any string.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, UppercasedString } from "@evolu/common";
+ *
+ * const text: UppercasedString = "HELLO WORLD";
+ * assertOk(UppercasedString.fromUnknown(text), text);
+ * assertErr(UppercasedString.fromUnknown("Hello world"));
+ * assertOk(UppercasedString.fromUnknown(""), "");
+ * ```
+ *
+ * @group String
+ */
+export const UppercasedString = /*#__PURE__*/ uppercased(String);
+/**
+ * Uppercases the whole string and returns a {@link UppercasedString}.
+ *
+ * Leaves an empty string unchanged. Uses JavaScript's default Unicode casing
+ * without locale-specific rules. Changing case can change the length, so input
+ * brands are not retained.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, uppercase } from "@evolu/common";
+ *
+ * const text = uppercase("Hello world");
+ * assertEqual(text, "HELLO WORLD");
+ * assertType<typeof text, "HELLO WORLD">();
+ * assertEqual(uppercase(text), text);
+ * ```
+ *
+ * @group String
+ */
+export const uppercase = (value) => value.toUpperCase();
+/**
+ * Adds lowercased text validation to an existing string Type.
+ *
+ * Narrows the output to TypeScript's `Lowercase<string>` while preserving the
+ * parent Type's constraints. Validation leaves the text unchanged. Use
+ * {@link lowercase} to change its casing.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertErr,
+ *   assertOk,
+ *   lowercased,
+ *   maxLength,
+ *   String,
+ * } from "@evolu/common";
+ *
+ * const Label = lowercased(maxLength(50)(String));
+ * assertOk(Label.fromUnknown("hello world"), "hello world");
+ * assertErr(Label.fromUnknown("Hello WORLD"));
+ * ```
+ *
+ * @group String
+ */
+export const lowercased = (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>`.
+ *
+ * Checks the whole string using JavaScript's Unicode lowercase mapping. Empty
+ * strings and uncased characters, such as digits and emoji, are valid. Use
+ * {@link lowercase} to produce a lowercased value from any string.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertErr, assertOk, LowercasedString } from "@evolu/common";
+ *
+ * const text: LowercasedString = "hello world";
+ * assertOk(LowercasedString.fromUnknown(text), text);
+ * assertErr(LowercasedString.fromUnknown("Hello WORLD"));
+ * assertOk(LowercasedString.fromUnknown(""), "");
+ * ```
+ *
+ * @group String
+ */
+export const LowercasedString = /*#__PURE__*/ lowercased(String);
+/**
+ * Lowercases the whole string and returns a {@link LowercasedString}.
+ *
+ * Leaves an empty string unchanged. Uses JavaScript's default Unicode casing
+ * without locale-specific rules. Changing case can change the length, so input
+ * brands are not retained.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, assertType, lowercase } from "@evolu/common";
+ *
+ * const text = lowercase("Hello WORLD");
+ * assertEqual(text, "hello world");
+ * assertType<typeof text, "hello world">();
+ * assertEqual(lowercase(text), text);
+ * ```
+ *
+ * @group String
+ */
+export const lowercase = (value) => value.toLowerCase();
+/**
+ * String {@link Brand} without surrounding whitespace.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertOk, String, trimmed } from "@evolu/common";
+ *
+ * const Trimmed = trimmed(String);
+ *
+ * assertOk(Trimmed.fromUnknown("Evolu"), "Evolu");
+ * ```
+ *
+ * @group String
+ */
+export const trimmed = (parent) => brand("Trimmed", parent, (value) => value === value.trim()
+    ? ok()
+    : err({ type: "Trimmed", value }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} must be trimmed.`);
+/**
+ * A {@link String} without surrounding whitespace.
+ *
+ * This Type validates that a string is already trimmed; it does not modify the
+ * value. Use {@link trim} to normalize a string. Because an empty string is
+ * valid, this Type is useful as an intermediate boundary for input controls
+ * that trim their values before domain validation. If an empty string is
+ * invalid, use {@link NonEmptyTrimmedString}.
+ *
+ * @group String
+ */
+export const TrimmedString = /*#__PURE__*/ trimmed(String);
+/**
+ * Trims a string and returns a {@link TrimmedString}.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertEqual, trim } from "@evolu/common";
+ *
+ * assertEqual(trim("  Evolu  "), "Evolu");
+ * ```
+ *
+ * @group String
+ */
+export const trim = (value) => 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`.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { assertOk, String, array, minLength } from "@evolu/common";
+ *
+ * const AtLeastThreeCharacters = minLength(3)(String);
+ * const AtLeastTwoItems = minLength(2)(array(String));
+ *
+ * assertOk(AtLeastThreeCharacters.fromUnknown("abc"), "abc");
+ * assertOk(AtLeastTwoItems.fromUnknown(["a", "b"]), ["a", "b"]);
+ * ```
+ *
+ * @group String
+ * @group Collection
+ */
+export const minLength = (min) => (parent) => {
+    const name = `MinLength${min}`;
+    return brand(name, parent, (value) => value.length >= min
+        ? ok()
+        : err({ type: name, value, min }), (error) => `The value ${safelyStringifyUnknownValue(error.value)} does not meet the minimum length of ${error.min}.`);
+};
+/**
+ * A non-empty {@link TrimmedString}.
+ *
+ * Use as the base Type for ordinary human-entered text, which should usually be
+ * trimmed, non-empty, and bounded. Add a domain-appropriate maximum with
  * {@link maxLength}, or use {@link NonEmptyTrimmedString100} or
  * {@link NonEmptyTrimmedString1000}.
  *
@@ -2055,6 +3219,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 +3348,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 +3814,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);
@@ -2670,18 +3842,61 @@ export const NonNegativeInt = /*#__PURE__*/ nonNegative(Int);
 /**
  * Minimum {@link NonNegativeInt} value.
  *
- * @group Number
- */
-export const zeroNonNegativeInt = /*#__PURE__*/ NonNegativeInt.orThrow(0);
-/**
- * Positive {@link Int}.
+ * @group Number
+ */
+export const zeroNonNegativeInt = /*#__PURE__*/ NonNegativeInt.orThrow(0);
+/**
+ * Positive {@link Int}.
+ *
+ * Also satisfies {@link NonNegativeInt}, so it can be used wherever a
+ * non-negative integer is required.
+ *
+ * @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");
  *
- * Also satisfies {@link NonNegativeInt}, so it can be used wherever a
- * non-negative integer is required.
+ * 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 PositiveInt = /*#__PURE__*/ positive(NonNegativeInt);
+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 +4020,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 +4297,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 +4417,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 +4426,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);
@@ -3211,9 +4478,13 @@ const isArrayCollection = (value, isElement) => {
 };
 const arrayRuntimeConfig = {
     name: "Array",
+    typeSymbol: arrayTypeSymbol,
     typeByElement: arrayTypeByElement,
     validate: validateArrayCollection,
     validateItems: (value, validateElement, options) => validateArrayItems(value, validateElement, options, false),
+    check: (value, checkElement, options) => Array.isArray(value)
+        ? checkIndexedArrayItems("Array", value, checkElement, options)
+        : { type: "Array", reason: { kind: "NotArray", value } },
     encode: encodeArrayCollection,
     is: isArrayCollection,
     formatError: ((error) => {
@@ -3238,23 +4509,10 @@ const validateArrayItems = (value, validate, options, checkStructure) => validat
 // Encoding and Output membership stay feature-local because sharing those
 // shorter hot paths measurably increases standalone bundles.
 const validateIndexedArrayItems = (name, value, validate, options, checkStructure) => {
-    let issues;
+    let issues = checkStructure
+        ? getArrayExcessPropertyIssues(value, options)
+        : undefined;
     let output;
-    if (checkStructure) {
-        for (const key of Reflect.ownKeys(value)) {
-            if (key === "length")
-                continue;
-            if (typeof key === "string") {
-                const index = globalThis.Number(key) >>> 0;
-                if (index < value.length && globalThis.String(index) === key) {
-                    continue;
-                }
-            }
-            (issues ??= []).push({ kind: "ExcessProperty", key });
-            if (options.errors === "first")
-                break;
-        }
-    }
     for (let index = 0; (issues === undefined || options.errors === "all") && index < value.length; index++) {
         let item;
         if (checkStructure) {
@@ -3301,6 +4559,66 @@ const validateIndexedArrayItems = (name, value, validate, options, checkStructur
             },
         });
 };
+// Like validateIndexedArrayItems for identity elements, which leave the value
+// unchanged, so it returns only the error.
+const checkIndexedArrayItems = (name, value, check, options) => {
+    let issues = getArrayExcessPropertyIssues(value, options);
+    for (let index = 0; (issues === undefined || options.errors === "all") && index < value.length; index++) {
+        const descriptor = globalThis.Object.getOwnPropertyDescriptor(value, index);
+        if (descriptor === undefined) {
+            (issues ??= []).push({ kind: "Hole", index });
+            if (options.errors === "first")
+                break;
+            continue;
+        }
+        if (!("value" in descriptor)) {
+            (issues ??= []).push({ kind: "Accessor", index });
+            if (options.errors === "first")
+                break;
+            continue;
+        }
+        const error = check(descriptor.value, options, index);
+        if (error === undefined)
+            continue;
+        (issues ??= []).push({ kind: "Element", index, error });
+        if (options.errors === "first")
+            break;
+    }
+    return issues === undefined
+        ? undefined
+        : {
+            type: name,
+            reason: {
+                kind: "Items",
+                issues: issues,
+            },
+        };
+};
+// Own keys other than indexes and `length` are excess properties.
+const getArrayExcessPropertyIssues = (value, options) => {
+    let issues;
+    const keys = Reflect.ownKeys(value);
+    for (let position = 0; position < keys.length; position++) {
+        const key = keys[position];
+        if (key === "length")
+            continue;
+        if (typeof key === "string") {
+            // Ordinary arrays list their indexes first, in ascending order. Comparing
+            // the key first reads `length` only for an index key.
+            if (key === globalThis.String(position) && position < value.length) {
+                continue;
+            }
+            const index = globalThis.Number(key) >>> 0;
+            if (index < value.length && globalThis.String(index) === key) {
+                continue;
+            }
+        }
+        (issues ??= []).push({ kind: "ExcessProperty", key });
+        if (options.errors === "first")
+            break;
+    }
+    return issues;
+};
 const copyArrayPrefix = (value, endIndex) => {
     const output = createMutableArray(value.length);
     for (let index = 0; index < endIndex; index++) {
@@ -3334,11 +4652,23 @@ export const set = (element) => createHomogeneousCollectionType(element, setRunt
 // Array(String) +82/+63 B gzip, while Array(String)+Set(String) is 2501/2492 B
 // and Set adds only +303/+304 B once Array is present. See TreeShaking.test.ts.
 const createHomogeneousCollectionType = (typeElement, config) => {
-    const cached = config.typeByElement.get(typeElement);
+    const slot = typeElement[config.typeSymbol];
+    // A copy of a Type, spread or with the Type as its prototype, has the slot
+    // of the original.
+    const cached = slot !== undefined && slot.element === typeElement
+        ? slot
+        : config.typeByElement.get(typeElement);
     if (cached)
         return cached;
-    const fromUnknown = (value, options = firstValidationOptions) => config.validate(value, typeElement.fromUnknown, options);
-    const validateOutput = (value, options = firstValidationOptions) => config.validate(value, typeElement[outputValidationSymbol], options);
+    const checkElement = typeElement[checkSymbol];
+    const check = checkElement &&
+        ((value, options) => config.check(value, checkElement, options));
+    const fromUnknown = check
+        ? checkToFromUnknown(check)
+        : (value, options = firstValidationOptions) => config.validate(value, typeElement.fromUnknown, options);
+    const validateOutput = check
+        ? fromUnknown
+        : (value, options = firstValidationOptions) => config.validate(value, typeElement[outputValidationSymbol], options);
     const parent = typeElement.parent
         ? createHomogeneousCollectionType(typeElement.parent, config)
         : null;
@@ -3353,16 +4683,20 @@ const createHomogeneousCollectionType = (typeElement, config) => {
         ? identity
         : (value) => config.encode(value, encodeElement);
     const getTypeIssues = createCollectionRuntimeTypeIssues(config.name, "Items", config.formatError, () => typeElement);
-    const type = createTypeNode(config.name, parent, fromUnknown, (value) => config.is(value, typeElement.is), validateOutput, from, to, getTypeIssues, { element: typeElement });
-    config.typeByElement.set(typeElement, type);
+    const type = createTypeNode(config.name, parent, fromUnknown, (value) => config.is(value, typeElement.is), validateOutput, from, to, getTypeIssues, { additionalProperties: { element: typeElement }, check });
+    // A frozen element Type keeps its Collection Type in the WeakMap.
+    if (!Reflect.set(typeElement, config.typeSymbol, type)) {
+        config.typeByElement.set(typeElement, type);
+    }
     return type;
 };
 const setTypeByElement = /*#__PURE__*/ new WeakMap();
 const setRuntimeConfig = {
     name: "Set",
+    typeSymbol: setTypeSymbol,
     typeByElement: setTypeByElement,
     validate: (value, validateElement, options) => {
-        if (!hasObjectTag(value, "Set")) {
+        if (!hasObjectTag(value, "[object Set]")) {
             return err({
                 type: "Set",
                 reason: { kind: "NotSet", value },
@@ -3371,6 +4705,37 @@ const setRuntimeConfig = {
         return validateSetItems(value, validateElement, options, true);
     },
     validateItems: (value, validateElement, options) => validateSetItems(value, validateElement, options, false),
+    check: (value, checkElement, options) => {
+        if (!hasObjectTag(value, "[object Set]")) {
+            return { type: "Set", reason: { kind: "NotSet", value } };
+        }
+        // The same issues as validateSetItems, without building an Output.
+        let issues;
+        for (const key of Reflect.ownKeys(value)) {
+            (issues ??= []).push({ kind: "ExcessProperty", key });
+            if (options.errors === "first")
+                break;
+        }
+        let index = 0;
+        for (const item of value) {
+            if (issues !== undefined && options.errors === "first")
+                break;
+            const error = checkElement(item, options);
+            if (error !== undefined) {
+                (issues ??= []).push({ kind: "Element", index, error });
+            }
+            index++;
+        }
+        return issues === undefined
+            ? undefined
+            : {
+                type: "Set",
+                reason: {
+                    kind: "Items",
+                    issues: issues,
+                },
+            };
+    },
     encode: (value, encodeElement) => {
         let changed = false;
         const output = new Set();
@@ -3383,7 +4748,7 @@ const setRuntimeConfig = {
         return changed ? output : value;
     },
     is: (value, isElement) => {
-        if (!hasObjectTag(value, "Set") ||
+        if (!hasObjectTag(value, "[object Set]") ||
             Reflect.ownKeys(value).length !== 0) {
             return false;
         }
@@ -3474,7 +4839,7 @@ export const map = (key, value) => {
     if (cached)
         return cached;
     const validate = (input, validateKey, validateValue, options) => {
-        if (!hasObjectTag(input, "Map")) {
+        if (!hasObjectTag(input, "[object Map]")) {
             return err({
                 type: "Map",
                 reason: { kind: "NotMap", value: input },
@@ -3482,8 +4847,90 @@ export const map = (key, value) => {
         }
         return validateMapEntries(input, validateKey, validateValue, options, true);
     };
-    const fromUnknown = (input, options = firstValidationOptions) => validate(input, typeKey.fromUnknown, typeValue.fromUnknown, options);
-    const validateOutput = (input, options = firstValidationOptions) => validate(input, typeKey[outputValidationSymbol], typeValue[outputValidationSymbol], options);
+    const checkKey = typeKey[checkSymbol];
+    const checkValue = typeValue[checkSymbol];
+    // Like validate for identity keys and values, which leave the Map unchanged,
+    // so it returns only the error. A custom iterator can repeat a key, so
+    // collisions are still detected.
+    const check = checkKey &&
+        checkValue &&
+        ((input, options) => {
+            if (!hasObjectTag(input, "[object Map]")) {
+                return {
+                    type: "Map",
+                    reason: { kind: "NotMap", value: input },
+                };
+            }
+            const entries = input;
+            let issues;
+            const entryByKey = new Map();
+            for (const key of Reflect.ownKeys(entries)) {
+                (issues ??= []).push({ kind: "ExcessProperty", key });
+                if (options.errors === "first")
+                    break;
+            }
+            let index = 0;
+            for (const [inputKey, inputValue] of entries) {
+                if (issues !== undefined && options.errors === "first")
+                    break;
+                const keyError = checkKey(inputKey, options);
+                if (keyError !== undefined) {
+                    (issues ??= []).push({
+                        kind: "Key",
+                        index,
+                        key: inputKey,
+                        error: keyError,
+                    });
+                    if (options.errors === "first")
+                        break;
+                }
+                const valueError = checkValue(inputValue, options);
+                if (valueError !== undefined) {
+                    (issues ??= []).push({
+                        kind: "Value",
+                        index,
+                        key: inputKey,
+                        error: valueError,
+                    });
+                    if (options.errors === "first")
+                        break;
+                }
+                if (keyError === undefined) {
+                    const previous = entryByKey.get(inputKey);
+                    if (previous === undefined) {
+                        entryByKey.set(inputKey, { index, key: inputKey });
+                    }
+                    else {
+                        (issues ??= []).push({
+                            kind: "Collision",
+                            index,
+                            key: inputKey,
+                            previousIndex: previous.index,
+                            previousKey: previous.key,
+                            outputKey: inputKey,
+                        });
+                        if (options.errors === "first")
+                            break;
+                    }
+                }
+                index++;
+            }
+            return issues === undefined
+                ? undefined
+                : {
+                    type: "Map",
+                    reason: {
+                        kind: "Entries",
+                        issues: issues,
+                    },
+                };
+        });
+    const fromUnknown = check
+        ? checkToFromUnknown(check)
+        : (input, options = firstValidationOptions) => validate(input, typeKey.fromUnknown, typeValue.fromUnknown, options);
+    const validateOutput = check
+        ? fromUnknown
+        : (input, options = firstValidationOptions) => validate(input, typeKey[outputValidationSymbol], typeValue[outputValidationSymbol], options);
     const formatError = (error) => {
         if (error.reason.kind === "NotMap")
             return `A value ${safelyStringifyUnknownValue(error.reason.value)} is not a Map.`;
@@ -3524,7 +4971,7 @@ export const map = (key, value) => {
             return changed ? output : input;
         };
     const is = (input) => {
-        if (!hasObjectTag(input, "Map")) {
+        if (!hasObjectTag(input, "[object Map]")) {
             return false;
         }
         if (Reflect.ownKeys(input).length !== 0)
@@ -3535,26 +4982,36 @@ export const map = (key, value) => {
         }
         return true;
     };
-    const getTypeIssues = (error, mode) => {
+    const getTypeIssues = (error, mode, path) => {
         const mapError = error;
         if (mapError.reason.kind !== "Entries") {
-            return singleRuntimeTypeIssue("Map", error, formatError);
+            return singleRuntimeTypeIssue("Map", error, formatError, path);
         }
         const allIssues = mapError.reason.issues;
         const issues = mode === "first" ? [allIssues[0]] : allIssues;
-        return issues.flatMap((issue) => {
+        const result = [];
+        for (const issue of issues) {
             if (issue.kind === "Key" || issue.kind === "Value") {
-                return prependRuntimeTypeIssuePath(issue.index, prependRuntimeTypeIssuePath(issue.kind === "Key" ? "key" : "value", (issue.kind === "Key" ? typeKey : typeValue)[getRuntimeTypeIssuesSymbol](issue.error, mode)));
+                for (const nestedIssue of (issue.kind === "Key" ? typeKey : typeValue)[getRuntimeTypeIssuesSymbol](issue.error, mode, appendIssuePath(appendIssuePath(path, issue.index), issue.kind === "Key" ? "key" : "value"))) {
+                    result.push(nestedIssue);
+                }
+                continue;
             }
-            return singleRuntimeTypeIssue("Map", mode === "first"
-                ? error
-                : {
-                    type: "Map",
-                    reason: { kind: "Entries", issues: [issue] },
-                }, formatError, [issue.kind === "ExcessProperty" ? issue.key : issue.index]);
-        });
+            result.push({
+                name: "Map",
+                error: mode === "first"
+                    ? error
+                    : {
+                        type: "Map",
+                        reason: { kind: "Entries", issues: [issue] },
+                    },
+                path: appendIssuePath(path, issue.kind === "ExcessProperty" ? issue.key : issue.index),
+                formatError: formatError,
+            });
+        }
+        return result;
     };
-    const type = createTypeNode("Map", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, { key: typeKey, value: typeValue });
+    const type = createTypeNode("Map", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, { additionalProperties: { key: typeKey, value: typeValue }, check });
     if (typeByValue === undefined) {
         typeByValue = new WeakMap();
         mapTypeByValueByKey.set(typeKey, typeByValue);
@@ -3667,8 +5124,33 @@ const createTupleType = (typeElements) => {
         }
         return validateTupleItems(value, typeElements, validateElement, options, true);
     };
-    const fromUnknown = (value, options = firstValidationOptions) => validate(value, (element, item, elementOptions) => element.fromUnknown(item, elementOptions), options);
-    const validateOutput = (value, options = firstValidationOptions) => validate(value, (element, item, elementOptions) => element[outputValidationSymbol](item, elementOptions), options);
+    const elementChecks = getRuntimeChecks(typeElements);
+    const checkElement = elementChecks &&
+        ((item, options, index) => elementChecks[index](item, options));
+    // The same errors as validate, for identity elements.
+    const check = checkElement &&
+        ((value, options) => {
+            if (!Array.isArray(value)) {
+                return { type: "Tuple", reason: { kind: "NotArray", value } };
+            }
+            if (value.length !== expectedLength) {
+                return {
+                    type: "Tuple",
+                    reason: {
+                        kind: "InvalidLength",
+                        expected: expectedLength,
+                        actual: value.length,
+                    },
+                };
+            }
+            return checkIndexedArrayItems("Tuple", value, checkElement, options);
+        });
+    const fromUnknown = check
+        ? checkToFromUnknown(check)
+        : (value, options = firstValidationOptions) => validate(value, (element, item, elementOptions) => element.fromUnknown(item, elementOptions), options);
+    const validateOutput = check
+        ? fromUnknown
+        : (value, options = firstValidationOptions) => validate(value, (element, item, elementOptions) => element[outputValidationSymbol](item, elementOptions), options);
     const formatError = (error) => {
         if (error.reason.kind === "NotArray")
             return `A value ${safelyStringifyUnknownValue(error.reason.value)} is not a tuple.`;
@@ -3727,29 +5209,29 @@ const createTupleType = (typeElements) => {
         return true;
     };
     const getTypeIssues = createCollectionRuntimeTypeIssues("Tuple", "Items", formatError, (issue) => typeElements[issue.index]);
-    return createTypeNode("Tuple", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, { elements: typeElements });
+    return createTypeNode("Tuple", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, { additionalProperties: { elements: typeElements }, check });
 };
 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 +5239,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,31 +5247,32 @@ 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
  */
 export const Digit1To59 = /*#__PURE__*/ union(Digit1To9, 
 /*#__PURE__*/ templateLiteral(
 /*#__PURE__*/ union("1", "2", "3", "4", "5"), Digit));
-const createObjectRuntimeTypeIssues = (defaultFormatter, props, recordType) => (error, mode) => {
+const createObjectRuntimeTypeIssues = (props, recordType) => (error, mode, path) => {
     const objectError = error;
     if (objectError.reason.kind !== "Properties") {
-        return singleRuntimeTypeIssue("Object", error, defaultFormatter);
+        return singleRuntimeTypeIssue("Object", error, formatObjectError, path);
     }
     const propertyErrors = objectError.reason.errors;
     const keys = Reflect.ownKeys(propertyErrors);
-    const firstKey = keys[0];
-    assertNonNullable(firstKey);
-    const keysToVisit = mode === "first" ? [firstKey] : keys;
-    return keysToVisit.flatMap((key) => {
+    assertNonNullable(keys[0]);
+    const visitCount = mode === "first" ? 1 : keys.length;
+    const result = [];
+    for (let index = 0; index < visitCount; index++) {
+        const key = keys[index];
         const propertyError = propertyErrors[key];
         const property = typeof key === "string" &&
             props !== undefined &&
@@ -3809,51 +5292,86 @@ const createObjectRuntimeTypeIssues = (defaultFormatter, props, recordType) => (
                     reason: { kind: "Properties", errors },
                 };
             }
-            return singleRuntimeTypeIssue("Object", ownError, defaultFormatter, [
-                key,
-            ]);
+            result.push({
+                name: "Object",
+                error: ownError,
+                path: appendIssuePath(path, key),
+                // The issue error has this first key, so its message needs no key
+                // enumeration of the error record.
+                formatError: () => formatObjectPropertyError(key, propertyError),
+            });
+            continue;
         }
-        if (property !== undefined) {
-            return prependRuntimeTypeIssuePath(key, objectPropertyToType(property)[getRuntimeTypeIssuesSymbol](propertyError, mode));
+        // A record property error adds its own key.
+        const nestedIssues = property === undefined
+            ? recordType[getRuntimeTypeIssuesSymbol](propertyError, mode, path.slice())
+            : objectPropertyToType(property)[getRuntimeTypeIssuesSymbol](propertyError, mode, appendIssuePath(path, key));
+        // Nested issues are a new array, so one visited issue returns them.
+        if (visitCount === 1)
+            return nestedIssues;
+        for (const issue of nestedIssues)
+            result.push(issue);
+    }
+    return result;
+};
+const formatObjectError = (error) => {
+    if (error.reason.kind !== "Properties")
+        return formatPlainObjectRootError(error.reason);
+    const key = Reflect.ownKeys(error.reason.errors).at(0);
+    assertNonNullable(key);
+    return formatObjectPropertyError(key, error.reason.errors[key]);
+};
+const formatObjectPropertyError = (key, propertyError) => {
+    assertNonNullable(propertyError);
+    if (propertyError.type === "ObjectPropertyAccess") {
+        switch (propertyError.reason) {
+            case "Accessor":
+                return "An Object property must be a data property. Materialize accessor values into plain data before using this Type or use a different Type.";
+            case "NonEnumerable":
+                return "An Object property must be enumerable. Make it enumerable or use a different Type.";
         }
-        return recordType[getRuntimeTypeIssuesSymbol](propertyError, mode);
-    });
+    }
+    if (propertyError.type === "ObjectMissingProperty")
+        return `The required property ${safelyStringifyUnknownValue(key)} is missing.`;
+    if (typeof key === "symbol")
+        return "An Object property key must be a string. Remove the symbol property or use a different Type.";
+    if (propertyError.type === "ObjectExcessProperty")
+        return `The property ${safelyStringifyUnknownValue(key)} is not allowed. Remove it or use a different Type.`;
+    return `The property ${safelyStringifyUnknownValue(key)} is invalid.`;
 };
 const formatPlainObjectRootError = (reason) => reason.kind === "NotObject"
     ? `A value ${safelyStringifyUnknownValue(reason.value)} is not an object.`
     : "The value is an object, but an Object Output must be a plain object or have a null prototype.";
-/**
- * A {@link Type} for readonly plain objects with unknown property values.
- *
- * `Object` is the runtime counterpart of a `Readonly<Record<string, unknown>>`
- * data boundary. Its prototype rule uses the realm-neutral structural heuristic
- * described by {@link isPlainObject}. A matching custom root prototype can be
- * classified as plain; other custom prototypes and class instances are
- * rejected. Every own property must have a string key and be an enumerable data
- * property. Accessors, non-enumerable properties, and symbol properties are
- * rejected without reading their values.
- *
- * Use {@link object} when property names are fixed, {@link record} when keys and
- * values have their own Types, and {@link instanceOf} when an instance belongs
- * to the domain.
- *
- * @group Base
- */
-const _Object = /*#__PURE__*/ createRootType("Object", (value, options = firstValidationOptions) => {
+// Ordinary objects list string keys before symbols, so without symbols the
+// names are the own keys, and cheaper than Reflect.ownKeys. A Proxy may list
+// symbols first, and Reflect.ownKeys keeps that order.
+const getOwnKeys = (value) => {
+    const names = globalThis.Object.getOwnPropertyNames(value);
+    return globalThis.Object.getOwnPropertySymbols(value).length === 0
+        ? names
+        : Reflect.ownKeys(value);
+};
+// An `is` walk in own-key order fails at the first symbol key, after checking
+// the names before it. Ordinary objects list symbols last, but a Proxy may
+// list one first. Walking names is faster than walking mixed own keys.
+const getNamesBeforeSymbol = (value) => {
+    const names = [];
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key !== "string")
+            break;
+        names.push(key);
+    }
+    return names;
+};
+const checkPlainObject = (value, options) => {
     if (value === null || typeof value !== "object") {
-        return err({
-            type: "Object",
-            reason: { kind: "NotObject", value },
-        });
+        return { type: "Object", reason: { kind: "NotObject", value } };
     }
     if (!isPlainObject(value)) {
-        return err({
-            type: "Object",
-            reason: { kind: "UnexpectedPrototype", value },
-        });
+        return { type: "Object", reason: { kind: "UnexpectedPrototype", value } };
     }
     let errors;
-    for (const key of Reflect.ownKeys(value)) {
+    for (const key of getOwnKeys(value)) {
         let propertyError;
         if (typeof key !== "string") {
             propertyError = { type: "ObjectExcessProperty" };
@@ -3882,57 +5400,38 @@ const _Object = /*#__PURE__*/ createRootType("Object", (value, options = firstVa
             break;
     }
     return errors === undefined
-        ? ok(value)
-        : err({
+        ? undefined
+        : {
             type: "Object",
             reason: { kind: "Properties", errors },
-        });
-}, (error) => {
-    if (error.reason.kind !== "Properties")
-        return formatPlainObjectRootError(error.reason);
-    const key = Reflect.ownKeys(error.reason.errors).at(0);
-    assertNonNullable(key);
-    const propertyError = error.reason.errors[key];
-    assertNonNullable(propertyError);
-    if (propertyError.type === "ObjectPropertyAccess") {
-        switch (propertyError.reason) {
-            case "Accessor":
-                return "An Object property must be a data property. Materialize accessor values into plain data before using this Type or use a different Type.";
-            case "NonEnumerable":
-                return "An Object property must be enumerable. Make it enumerable or use a different Type.";
-        }
-    }
-    if (propertyError.type === "ObjectMissingProperty")
-        return `The required property ${safelyStringifyUnknownValue(key)} is missing.`;
-    if (typeof key === "symbol")
-        return "An Object property key must be a string. Remove the symbol property or use a different Type.";
-    if (propertyError.type === "ObjectExcessProperty")
-        return `The property ${safelyStringifyUnknownValue(key)} is not allowed. Remove it or use a different Type.`;
-    return `The property ${safelyStringifyUnknownValue(key)} is invalid.`;
-}, 
-/*#__PURE__*/ createObjectRuntimeTypeIssues(((error) => {
-    if (error.reason.kind !== "Properties")
-        return formatPlainObjectRootError(error.reason);
-    const key = Reflect.ownKeys(error.reason.errors).at(0);
-    assertNonNullable(key);
-    const propertyError = error.reason.errors[key];
-    assertNonNullable(propertyError);
-    if (propertyError.type === "ObjectPropertyAccess") {
-        switch (propertyError.reason) {
-            case "Accessor":
-                return "An Object property must be a data property. Materialize accessor values into plain data before using this Type or use a different Type.";
-            case "NonEnumerable":
-                return "An Object property must be enumerable. Make it enumerable or use a different Type.";
-        }
-    }
-    if (propertyError.type === "ObjectMissingProperty")
-        return `The required property ${safelyStringifyUnknownValue(key)} is missing.`;
-    if (typeof key === "symbol")
-        return "An Object property key must be a string. Remove the symbol property or use a different Type.";
-    if (propertyError.type === "ObjectExcessProperty")
-        return `The property ${safelyStringifyUnknownValue(key)} is not allowed. Remove it or use a different Type.`;
-    return `The property ${safelyStringifyUnknownValue(key)} is invalid.`;
-})));
+        };
+};
+/**
+ * A {@link Type} for readonly plain objects with unknown property values.
+ *
+ * `Object` is the runtime counterpart of a `Readonly<Record<string, unknown>>`
+ * data boundary. Its prototype rule uses the realm-neutral structural heuristic
+ * described by {@link isPlainObject}. A matching custom root prototype can be
+ * classified as plain; other custom prototypes and class instances are
+ * rejected. Every own property must have a string key and be an enumerable data
+ * property. Accessors, non-enumerable properties, and symbol properties are
+ * rejected without reading their values.
+ *
+ * Use {@link object} when property names are fixed, {@link record} when keys and
+ * values have their own Types, and {@link instanceOf} when an instance belongs
+ * to the domain.
+ *
+ * @group Base
+ */
+const _Object = /*#__PURE__*/ createRootType("Object", (value, options = firstValidationOptions) => {
+    const error = checkPlainObject(value, options);
+    return error === undefined
+        ? ok(value)
+        : err(error);
+}, formatObjectError, {
+    getTypeIssues: /*#__PURE__*/ createObjectRuntimeTypeIssues(),
+    check: checkPlainObject,
+});
 // Avoid a local `Object` binding because Babel's CommonJS transform injects
 // `Object.defineProperty` before it is initialized:
 // https://github.com/babel/babel/issues/16943
@@ -4026,6 +5525,7 @@ export { _Object as Object };
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -4061,6 +5561,7 @@ export { _Object as Object };
  * const valueType = typeof value;
  *
  * assertEqual(valueType, "function");
+ *
  * const called = trySync(
  *   () => {
  *     if (value !== undefined) value.toFixed(0);
@@ -4094,8 +5595,71 @@ export const record = (key, value) => {
         }
         return validateRecordEntries(input, validateKey, validateValue, options);
     };
-    const fromUnknown = (input, options = firstValidationOptions) => validate(input, typeKey.fromUnknown, typeValue.fromUnknown, options);
-    const validateOutput = (input, options = firstValidationOptions) => validate(input, typeKey[outputValidationSymbol], typeValue[outputValidationSymbol], options);
+    const checkKey = typeKey[checkSymbol];
+    const checkValue = typeValue[checkSymbol];
+    // The same errors as validate for identity keys and values. Own keys are
+    // unique, so identity keys never collide.
+    const check = checkKey &&
+        checkValue &&
+        ((input, options) => {
+            if (input === null || typeof input !== "object") {
+                return { type: "Record", reason: { kind: "NotRecord", value: input } };
+            }
+            if (!isPlainObject(input)) {
+                return {
+                    type: "Record",
+                    reason: { kind: "NotPlainRecord", value: input },
+                };
+            }
+            let issues;
+            for (const inputKey of getOwnKeys(input)) {
+                const keyError = checkKey(inputKey, options);
+                if (keyError !== undefined) {
+                    (issues ??= []).push({ kind: "Key", key: inputKey, error: keyError });
+                    if (options.errors === "first")
+                        break;
+                }
+                const descriptor = globalThis.Object.getOwnPropertyDescriptor(input, inputKey);
+                assert(descriptor !== undefined, "Record property descriptor is missing.");
+                if (!("value" in descriptor)) {
+                    (issues ??= []).push({ kind: "Accessor", key: inputKey });
+                    if (options.errors === "first")
+                        break;
+                }
+                else if (!descriptor.enumerable) {
+                    (issues ??= []).push({ kind: "NonEnumerable", key: inputKey });
+                    if (options.errors === "first")
+                        break;
+                }
+                else {
+                    const valueError = checkValue(descriptor.value, options);
+                    if (valueError !== undefined) {
+                        (issues ??= []).push({
+                            kind: "Value",
+                            key: inputKey,
+                            error: valueError,
+                        });
+                        if (options.errors === "first")
+                            break;
+                    }
+                }
+            }
+            return issues === undefined
+                ? undefined
+                : {
+                    type: "Record",
+                    reason: {
+                        kind: "Entries",
+                        issues: issues,
+                    },
+                };
+        });
+    const fromUnknown = check
+        ? checkToFromUnknown(check)
+        : (input, options = firstValidationOptions) => validate(input, typeKey.fromUnknown, typeValue.fromUnknown, options);
+    const validateOutput = check
+        ? fromUnknown
+        : (input, options = firstValidationOptions) => validate(input, typeKey[outputValidationSymbol], typeValue[outputValidationSymbol], options);
     const formatError = (error) => {
         if (error.reason.kind === "NotRecord")
             return `A value ${safelyStringifyUnknownValue(error.reason.value)} is not a Record.`;
@@ -4149,8 +5713,16 @@ export const record = (key, value) => {
             return false;
         if (!isPlainObject(input))
             return false;
-        for (const key of Reflect.ownKeys(input)) {
-            if (typeof key !== "string" || !typeKey.is(key))
+        // Separate name and symbol enumerations cost dictionary-mode inputs, such
+        // as null-prototype records, about 10% over one Reflect.ownKeys, which is
+        // much slower for ordinary objects.
+        const hasSymbols = globalThis.Object.getOwnPropertySymbols(input).length !== 0;
+        const names = hasSymbols
+            ? getNamesBeforeSymbol(input)
+            : globalThis.Object.getOwnPropertyNames(input);
+        for (let index = 0; index < names.length; index++) {
+            const key = names[index];
+            if (!typeKey.is(key))
                 return false;
             const descriptor = globalThis.Object.getOwnPropertyDescriptor(input, key);
             if (descriptor === undefined ||
@@ -4161,17 +5733,17 @@ export const record = (key, value) => {
             if (!typeValue.is(descriptor.value))
                 return false;
         }
-        return true;
+        return !hasSymbols;
     };
     const getTypeIssues = createCollectionRuntimeTypeIssues("Record", "Entries", formatError, (issue) => (issue.kind === "Key" ? typeKey : typeValue));
-    return createTypeNode("Record", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, { key: typeKey, value: typeValue });
+    return createTypeNode("Record", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, { additionalProperties: { key: typeKey, value: typeValue }, check });
 };
 const validateRecordEntries = (input, validateKey, validateValue, options) => {
     let issues;
     const output = createMutableRecord();
     const inputKeyByOutputKey = createMutableRecord();
     let changed = false;
-    for (const inputKey of Reflect.ownKeys(input)) {
+    for (const inputKey of getOwnKeys(input)) {
         const keyResult = validateKey(inputKey, options);
         if (!keyResult.ok) {
             (issues ??= []).push({
@@ -4279,17 +5851,139 @@ 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, path) => error.type === "WithDefault" && "outputError" in error
+            ? ownGetTypeIssues(error.outputError, mode, path)
+            : type[getRuntimeTypeIssuesSymbol](error, mode, path),
+        // Output validation wraps errors, so a copied check would not match it.
+        [checkSymbol]: undefined,
+        [refinementsSymbol]: undefined,
+    };
+    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 createObjectType = (props, recordType, 
+// A parent Object Type reuses the key order of its child.
+keys = globalThis.Object.keys(props)) => {
     const runtimeProps = props;
-    const keys = globalThis.Object.keys(runtimeProps);
+    const keyCount = keys.length;
+    const propertyTypes = createMutableArray(keyCount);
+    const optionalFlags = createMutableArray(keyCount);
+    for (let index = 0; index < keyCount; index++) {
+        const property = runtimeProps[keys[index]];
+        if (isDefaultProperty(property)) {
+            return property[defaultPropertySymbol].createObject(props, recordType);
+        }
+        const isOptional = isOptionalProperty(property);
+        const type = isOptional ? property.type : property;
+        propertyTypes[index] = type;
+        optionalFlags[index] = isOptional;
+    }
+    const propertyChecks = propertyTypes.map((type) => type[checkSymbol]);
+    const recordCheck = recordType?.value[checkSymbol];
+    // When every property and Record value Type is an identity Type, validation
+    // never changes a value.
+    const isIdentity = !propertyChecks.includes(undefined) &&
+        (recordType === undefined || recordCheck !== undefined);
+    let isOutputs;
+    // Returns `undefined` for a valid input it did not change, so a valid
+    // identity Object allocates no Result.
     const validate = (value, options, exactOutput) => {
         if (value === null || typeof value !== "object") {
             return err({
@@ -4304,116 +5998,158 @@ const createObjectType = (props, recordType) => {
                 reason: { kind: "UnexpectedPrototype", value: input },
             });
         }
+        const ownKeys = getOwnKeys(input);
+        // Descriptors by visit index let a copy-on-write Output reuse the values
+        // already read. Only a property without a check can change its value.
+        const descriptors = isIdentity
+            ? undefined
+            : createMutableArray(keyCount + ownKeys.length);
         let errors;
         let output;
-        const inputDescriptorByKey = new Map();
-        for (const key of keys)
-            inputDescriptorByKey.set(key, undefined);
-        for (const key of Reflect.ownKeys(input)) {
-            inputDescriptorByKey.set(key, undefined);
-        }
-        const setError = (key, error) => {
-            errors ??= createMutableRecord();
-            errors[key] = error;
-        };
-        for (const [key] of inputDescriptorByKey) {
-            const property = typeof key === "string" && globalThis.Object.hasOwn(runtimeProps, key)
-                ? runtimeProps[key]
-                : undefined;
+        // Own keys that are exactly the declared keys in their order leave the
+        // undeclared-key loop nothing to visit. A first-mode stop leaves the flag
+        // unchecked, but then that loop does not run either.
+        let ownKeysAreDeclared = ownKeys.length === keyCount;
+        for (let index = 0; (errors === undefined || options.errors !== "first") && index < keyCount; index++) {
+            const key = keys[index];
+            if (ownKeysAreDeclared && ownKeys[index] !== key) {
+                ownKeysAreDeclared = false;
+            }
             const descriptor = globalThis.Object.getOwnPropertyDescriptor(input, key);
-            inputDescriptorByKey.set(key, descriptor);
+            if (descriptors !== undefined)
+                descriptors[index] = descriptor;
+            let error;
             if (descriptor === undefined) {
-                assert(property !== undefined, "Object property is missing.");
-                if (isOptionalProperty(property)) {
+                if (optionalFlags[index])
                     continue;
+                error = { type: "ObjectMissingProperty" };
+            }
+            else if (!("value" in descriptor)) {
+                error = {
+                    type: "ObjectPropertyAccess",
+                    reason: "Accessor",
+                };
+            }
+            else if (!descriptor.enumerable) {
+                error = {
+                    type: "ObjectPropertyAccess",
+                    reason: "NonEnumerable",
+                };
+            }
+            else {
+                const propertyValue = descriptor.value;
+                const check = propertyChecks[index];
+                if (check !== undefined) {
+                    const propertyError = check(propertyValue, options);
+                    if (propertyError === undefined) {
+                        if (output !== undefined && errors === undefined) {
+                            output[key] = propertyValue;
+                        }
+                        continue;
+                    }
+                    error = propertyError;
                 }
-                setError(key, { type: "ObjectMissingProperty" });
-                if (options.errors === "first")
-                    break;
+                else {
+                    const result = exactOutput
+                        ? propertyTypes[index][outputValidationSymbol](propertyValue, options)
+                        : propertyTypes[index].fromUnknown(propertyValue, options);
+                    if (result.ok) {
+                        if (errors !== undefined || exactOutput)
+                            continue;
+                        if (output === undefined) {
+                            if (globalThis.Object.is(result.value, propertyValue))
+                                continue;
+                            output = copyVisitedProperties(descriptors, ownKeys, index);
+                        }
+                        output[key] = result.value;
+                        continue;
+                    }
+                    error = result.error;
+                }
+            }
+            errors ??= createMutableRecord();
+            errors[key] = error;
+        }
+        const ownKeyEnd = ownKeysAreDeclared ? 0 : ownKeys.length;
+        for (let position = 0; (errors === undefined || options.errors !== "first") &&
+            position < ownKeyEnd; position++) {
+            const key = ownKeys[position];
+            const index = keyCount + position;
+            if (typeof key === "string" &&
+                // Own keys usually follow the declared order.
+                ((position < keyCount && key === keys[position]) ||
+                    globalThis.Object.hasOwn(runtimeProps, key))) {
+                if (descriptors !== undefined)
+                    descriptors[index] = undefined;
                 continue;
             }
-            if (property === undefined && recordType === undefined) {
-                setError(key, {
+            const descriptor = globalThis.Object.getOwnPropertyDescriptor(input, key);
+            assert(descriptor !== undefined, "Object property is missing.");
+            if (descriptors !== undefined)
+                descriptors[index] = descriptor;
+            let error;
+            if (recordType === undefined) {
+                error = {
                     type: "ObjectExcessProperty",
-                });
-                if (options.errors === "first")
-                    break;
-                continue;
+                };
             }
-            if (property === undefined && typeof key !== "string") {
-                setError(key, createRecordPropertyError({
+            else if (typeof key !== "string") {
+                error = createRecordPropertyError({
                     kind: "Key",
                     key,
-                    error: {
-                        type: "TypeOf",
-                        expected: "String",
-                        value: key,
-                    },
-                }));
-                if (options.errors === "first")
-                    break;
-                continue;
+                    error: { type: "TypeOf", expected: "String", value: key },
+                });
             }
-            if (!("value" in descriptor)) {
-                const propertyError = {
+            else if (!("value" in descriptor)) {
+                error = {
                     type: "ObjectPropertyAccess",
                     reason: "Accessor",
                 };
-                setError(key, propertyError);
-                if (options.errors === "first")
-                    break;
-                continue;
             }
-            if (!descriptor.enumerable) {
-                const propertyError = {
+            else if (!descriptor.enumerable) {
+                error = {
                     type: "ObjectPropertyAccess",
                     reason: "NonEnumerable",
                 };
-                setError(key, propertyError);
-                if (options.errors === "first")
-                    break;
-                continue;
-            }
-            const propertyValue = descriptor.value;
-            const propertyType = property === undefined
-                ? recordType.value
-                : objectPropertyToType(property);
-            const result = exactOutput
-                ? propertyType[outputValidationSymbol](propertyValue, options)
-                : propertyType.fromUnknown(propertyValue, options);
-            if (!result.ok) {
-                setError(key, property === undefined
-                    ? createRecordPropertyError({
-                        kind: "Value",
-                        key,
-                        error: result.error,
-                    })
-                    : result.error);
-                if (options.errors === "first")
-                    break;
-                continue;
             }
-            if (errors !== undefined)
-                continue;
-            if (exactOutput)
-                continue;
-            if (output === undefined &&
-                globalThis.Object.is(result.value, propertyValue)) {
-                continue;
-            }
-            if (output === undefined) {
-                output = globalThis.Object.create(null);
-                for (const [previousKey, previousDescriptor] of inputDescriptorByKey) {
-                    if (previousKey === key)
-                        break;
-                    if (previousDescriptor !== undefined &&
-                        "value" in previousDescriptor &&
-                        previousDescriptor.enumerable) {
-                        output[previousKey] = previousDescriptor.value;
+            else {
+                const propertyValue = descriptor.value;
+                let valueError;
+                if (recordCheck !== undefined) {
+                    const checkError = recordCheck(propertyValue, options);
+                    if (checkError === undefined) {
+                        if (output !== undefined && errors === undefined) {
+                            output[key] = propertyValue;
+                        }
+                        continue;
                     }
+                    valueError = checkError;
                 }
+                else {
+                    const result = exactOutput
+                        ? recordType.value[outputValidationSymbol](propertyValue, options)
+                        : recordType.value.fromUnknown(propertyValue, options);
+                    if (result.ok) {
+                        if (errors !== undefined || exactOutput)
+                            continue;
+                        if (output === undefined) {
+                            if (globalThis.Object.is(result.value, propertyValue))
+                                continue;
+                            output = copyVisitedProperties(descriptors, ownKeys, index);
+                        }
+                        output[key] = result.value;
+                        continue;
+                    }
+                    valueError = result.error;
+                }
+                error = createRecordPropertyError({
+                    kind: "Value",
+                    key,
+                    error: valueError,
+                });
             }
-            output[key] = result.value;
+            errors ??= createMutableRecord();
+            errors[key] = error;
         }
         if (errors !== undefined) {
             return err({
@@ -4421,69 +6157,70 @@ const createObjectType = (props, recordType) => {
                 reason: { kind: "Properties", errors },
             });
         }
-        if (output === undefined)
-            return ok(input);
-        return ok(output);
+        return output === undefined ? undefined : ok(output);
     };
-    const fromUnknown = (value, options = firstValidationOptions) => validate(value, options, false);
-    const validateOutput = (value, options = firstValidationOptions) => validate(value, options, true);
-    const formatError = (error) => {
-        if (error.reason.kind !== "Properties")
-            return formatPlainObjectRootError(error.reason);
-        const key = Reflect.ownKeys(error.reason.errors).at(0);
-        assertNonNullable(key);
-        const propertyError = error.reason.errors[key];
-        assertNonNullable(propertyError);
-        if (propertyError.type === "ObjectPropertyAccess") {
-            switch (propertyError.reason) {
-                case "Accessor":
-                    return "An Object property must be a data property. Materialize accessor values into plain data before using this Type or use a different Type.";
-                case "NonEnumerable":
-                    return "An Object property must be enumerable. Make it enumerable or use a different Type.";
-            }
+    // Properties visited before `end` are valid and unchanged, so a new Output
+    // starts with their values.
+    const copyVisitedProperties = (descriptors, ownKeys, end) => {
+        const output = globalThis.Object.create(null);
+        for (let index = 0; index < end; index++) {
+            const descriptor = descriptors[index];
+            if (descriptor === undefined)
+                continue;
+            output[index < keyCount ? keys[index] : ownKeys[index - keyCount]] =
+                descriptor.value;
         }
-        if (propertyError.type === "ObjectMissingProperty")
-            return `The required property ${safelyStringifyUnknownValue(key)} is missing.`;
-        if (typeof key === "symbol")
-            return "An Object property key must be a string. Remove the symbol property or use a different Type.";
-        if (propertyError.type === "ObjectExcessProperty")
-            return `The property ${safelyStringifyUnknownValue(key)} is not allowed. Remove it or use a different Type.`;
-        return `The property ${safelyStringifyUnknownValue(key)} is invalid.`;
+        return output;
     };
-    const rootProps = createMutableRecord();
+    // An identity Object builds no Output, so its validation returns an Err or
+    // `undefined`.
+    const check = isIdentity
+        ? (value, options) => {
+            const result = validate(value, options, false);
+            return result?.ok === false ? result.error : undefined;
+        }
+        : undefined;
+    const fromUnknown = (value, options = firstValidationOptions) => validate(value, options, false) ??
+        ok(value);
+    const validateOutput = isIdentity
+        ? fromUnknown
+        : (value, options = firstValidationOptions) => validate(value, options, true) ??
+            ok(value);
     let hasNonRootType = false;
     let canSkipTo = recordType === undefined || recordType.value[encoderSymbol] === identity;
-    for (const key of keys) {
-        const property = runtimeProps[key];
-        const type = objectPropertyToType(property);
+    for (let index = 0; index < keyCount; index++) {
+        const type = propertyTypes[index];
         if (type[encoderSymbol] !== identity)
             canSkipTo = false;
-        const rootType = getTerminalRuntimeNode(type);
-        if (rootType !== type)
+        if (type.parent != null)
             hasNonRootType = true;
-        rootProps[key] = isOptionalProperty(property)
-            ? optional(rootType)
-            : rootType;
     }
-    const parent = hasNonRootType || recordType?.parent
-        ? createObjectType(rootProps, (recordType?.parent ?? recordType))
-        : null;
-    const inputFromByKey = createMutableRecord();
-    for (const key of keys) {
-        inputFromByKey[key] = getTerminalRuntimeNode(objectPropertyToType(runtimeProps[key])[fromSymbol]);
+    let parent = null;
+    if (hasNonRootType || recordType?.parent) {
+        const rootProps = createMutableRecord();
+        for (let index = 0; index < keyCount; index++) {
+            const rootType = getTerminalRuntimeNode(propertyTypes[index]);
+            rootProps[keys[index]] = optionalFlags[index]
+                ? optional(rootType)
+                : rootType;
+        }
+        parent = createObjectType(rootProps, (recordType?.parent ?? recordType), keys);
     }
+    let inputFroms;
     const recordValueFromInput = recordType
         ? getTerminalRuntimeNode(recordType.value[fromSymbol])
         : undefined;
     const fromParent = parent
         ? (value, options = firstValidationOptions) => {
+            const propertyFroms = (inputFroms ??= propertyTypes.map((type) => getTerminalRuntimeNode(type[fromSymbol])));
             let errors;
             let output;
-            for (const key of keys) {
+            for (let index = 0; index < keyCount; index++) {
+                const key = keys[index];
                 if (!globalThis.Object.hasOwn(value, key))
                     continue;
                 const propertyValue = value[key];
-                const result = inputFromByKey[key](propertyValue, options);
+                const result = propertyFroms[index](propertyValue, options);
                 if (result.ok) {
                     if (!globalThis.Object.is(result.value, propertyValue)) {
                         (output ??= createMutableRecord(value))[key] = result.value;
@@ -4531,11 +6268,12 @@ const createObjectType = (props, recordType) => {
         ? identity
         : (value) => {
             let output;
-            for (const key of keys) {
+            for (let index = 0; index < keyCount; index++) {
+                const key = keys[index];
                 if (!globalThis.Object.hasOwn(value, key))
                     continue;
                 const propertyValue = value[key];
-                const encoded = objectPropertyToType(runtimeProps[key])[encoderSymbol](propertyValue);
+                const encoded = propertyTypes[index][encoderSymbol](propertyValue);
                 if (!globalThis.Object.is(encoded, propertyValue)) {
                     (output ??= createMutableRecord(value))[key] = encoded;
                 }
@@ -4553,57 +6291,139 @@ const createObjectType = (props, recordType) => {
             }
             return output ?? value;
         };
-    const is = (value) => {
-        if (value === null || typeof value !== "object")
-            return false;
-        if (!isPlainObject(value))
-            return false;
-        for (const key of keys) {
-            const property = runtimeProps[key];
-            const descriptor = globalThis.Object.getOwnPropertyDescriptor(value, key);
+    const isDeclared = (value) => {
+        const isProperties = (isOutputs ??= propertyTypes.map(getIs));
+        for (let index = 0; index < keyCount; index++) {
+            const descriptor = globalThis.Object.getOwnPropertyDescriptor(value, keys[index]);
             if (descriptor === undefined) {
-                if (!isOptionalProperty(property))
+                if (!optionalFlags[index])
                     return false;
                 continue;
             }
             if (!("value" in descriptor) ||
                 !descriptor.enumerable ||
-                !objectPropertyToType(property).is(descriptor.value)) {
+                !isProperties[index](descriptor.value)) {
                 return false;
             }
         }
-        for (const key of Reflect.ownKeys(value)) {
-            if (typeof key === "string" &&
-                globalThis.Object.hasOwn(runtimeProps, key)) {
-                continue;
-            }
-            if (recordType === undefined || typeof key !== "string")
+        return true;
+    };
+    // Separate predicates keep each small; one shared by both cases was up to
+    // 5% slower in either.
+    const is = recordType === undefined
+        ? (value) => {
+            if (value === null || typeof value !== "object")
                 return false;
-            const descriptor = globalThis.Object.getOwnPropertyDescriptor(value, key);
-            if (descriptor === undefined ||
-                !("value" in descriptor) ||
-                !descriptor.enumerable) {
+            if (!isPlainObject(value) || !isDeclared(value))
                 return false;
+            // Checking names has no effects without a Record, so symbols, which
+            // fail, are counted after them.
+            const names = globalThis.Object.getOwnPropertyNames(value);
+            for (let position = 0; position < names.length; position++) {
+                const key = names[position];
+                if (!(position < keyCount && key === keys[position]) &&
+                    !globalThis.Object.hasOwn(runtimeProps, key)) {
+                    return false;
+                }
             }
-            if (!recordType.value.is(descriptor.value))
+            return globalThis.Object.getOwnPropertySymbols(value).length === 0;
+        }
+        : (value) => {
+            if (value === null || typeof value !== "object")
+                return false;
+            if (!isPlainObject(value) || !isDeclared(value))
                 return false;
+            const hasSymbols = globalThis.Object.getOwnPropertySymbols(value).length !== 0;
+            const names = hasSymbols
+                ? getNamesBeforeSymbol(value)
+                : globalThis.Object.getOwnPropertyNames(value);
+            for (let position = 0; position < names.length; position++) {
+                const key = names[position];
+                if ((position < keyCount && key === keys[position]) ||
+                    globalThis.Object.hasOwn(runtimeProps, key)) {
+                    continue;
+                }
+                const descriptor = globalThis.Object.getOwnPropertyDescriptor(value, key);
+                if (descriptor === undefined ||
+                    !("value" in descriptor) ||
+                    !descriptor.enumerable) {
+                    return false;
+                }
+                if (!recordType.value.is(descriptor.value))
+                    return false;
+            }
+            return !hasSymbols;
+        };
+    const getTypeIssues = createObjectRuntimeTypeIssues(runtimeProps, recordType);
+    return createTypeNode("Object", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, {
+        additionalProperties: recordType
+            ? {
+                props: runtimeProps,
+                record: recordType,
+            }
+            : { props: runtimeProps },
+        check,
+    });
+};
+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]);
         }
-        return true;
+        else {
+            inputProps[key] = property;
+            const type = objectPropertyToType(property);
+            const output = createRootType(type.name, type[outputValidationSymbol], type.formatError, { getTypeIssues: 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 getTypeIssues = createObjectRuntimeTypeIssues(formatError, runtimeProps, recordType);
-    return createTypeNode("Object", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, recordType
-        ? {
-            props: runtimeProps,
-            record: recordType,
+    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;
         }
-        : { props: runtimeProps });
+        return source[encoderSymbol](result);
+    };
+    return createTypeNode("Object", parent, (value, options) => flatMapResult(source.fromUnknown(value, options), finish), output.is, output[outputValidationSymbol], createFromOperation(fromParent), to, createObjectRuntimeTypeIssues(props, recordType), {
+        additionalProperties: 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()) => {
     const errorMessage = "Object schema properties must be own string-keyed data properties.";
     assert(isPlainObject(props), errorMessage);
-    for (const key of Reflect.ownKeys(props)) {
+    for (const key of getOwnKeys(props)) {
         const descriptor = globalThis.Object.getOwnPropertyDescriptor(props, key);
         assert(typeof key === "string" &&
             descriptor !== undefined &&
@@ -4613,7 +6433,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 +6447,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 +6476,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 +6521,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 +6560,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, path) => {
+        if ("outputError" in error) {
+            return runtimeOutput[getRuntimeTypeIssuesSymbol](error.outputError, mode, path);
+        }
+        return input[getRuntimeTypeIssuesSymbol](error.error, mode, path);
+    };
+    return createTypeNode("ObjectKeys", Unknown, fromUnknown, runtimeOutput.is, validateOutput, createFromOperation(fromUnknown), to, getTypeIssues, { additionalProperties: { key, output: type } });
+};
 export function result(okType, errorType) {
     return discriminatedUnion("ok", createObjectType({
         ok: literal(true),
@@ -4788,21 +6711,28 @@ export function discriminatedUnion(...keyOrMembers) {
         membersByDiscriminator.set(value, member);
     }
     const routeUnknown = (value) => {
-        const objectResult = value === null || typeof value !== "object"
-            ? err({ type: "Object", reason: { kind: "NotObject", value } })
-            : !isPlainObject(value)
-                ? err({
-                    type: "Object",
-                    reason: { kind: "UnexpectedPrototype", value },
-                })
-                : ok(value);
-        if (!objectResult.ok) {
+        if (value === null || typeof value !== "object") {
             return err({
                 type: "DiscriminatedUnion",
-                reason: { kind: "Object", error: objectResult.error },
+                reason: {
+                    kind: "Object",
+                    error: { type: "Object", reason: { kind: "NotObject", value } },
+                },
+            });
+        }
+        if (!isPlainObject(value)) {
+            return err({
+                type: "DiscriminatedUnion",
+                reason: {
+                    kind: "Object",
+                    error: {
+                        type: "Object",
+                        reason: { kind: "UnexpectedPrototype", value },
+                    },
+                },
             });
         }
-        const input = objectResult.value;
+        const input = value;
         const descriptor = globalThis.Object.getOwnPropertyDescriptor(input, key);
         let discriminator;
         if (descriptor === undefined) {
@@ -4843,16 +6773,15 @@ export function discriminatedUnion(...keyOrMembers) {
         }
         return ok(member);
     };
-    const wrapMemberResult = (member, result) => result.ok
-        ? result
-        : err({
-            type: "DiscriminatedUnion",
-            reason: {
-                kind: "Member",
-                discriminator: member.props[key].expected,
-                error: result.error,
-            },
-        });
+    const createMemberError = (member, error) => ({
+        type: "DiscriminatedUnion",
+        reason: {
+            kind: "Member",
+            discriminator: member.props[key].expected,
+            error,
+        },
+    });
+    const wrapMemberResult = (member, result) => result.ok ? result : err(createMemberError(member, result.error));
     const validateUnknown = (value, options = firstValidationOptions, useParent, exactOutput) => {
         const routeResult = routeUnknown(value);
         if (!routeResult.ok)
@@ -4891,24 +6820,34 @@ export function discriminatedUnion(...keyOrMembers) {
         }
     };
     const defaultFormatter = formatError;
-    const getTypeIssues = (error, mode) => {
+    const getTypeIssues = (error, mode, path) => {
         const discriminatedUnionError = error;
         if (discriminatedUnionError.reason.kind === "Member") {
             const reason = discriminatedUnionError.reason;
             const member = membersByDiscriminator.get(reason.discriminator);
             assertNonNullable(member);
-            return member[getRuntimeTypeIssuesSymbol](reason.error, mode);
+            return member[getRuntimeTypeIssuesSymbol](reason.error, mode, path);
         }
         if (discriminatedUnionError.reason.kind === "PropertyAccess" ||
             discriminatedUnionError.reason.kind === "Discriminator") {
-            return singleRuntimeTypeIssue("DiscriminatedUnion", discriminatedUnionError, defaultFormatter, [discriminatedUnionError.reason.key]);
+            return singleRuntimeTypeIssue("DiscriminatedUnion", discriminatedUnionError, defaultFormatter, appendIssuePath(path, discriminatedUnionError.reason.key));
         }
-        return singleRuntimeTypeIssue("DiscriminatedUnion", error, defaultFormatter);
+        return singleRuntimeTypeIssue("DiscriminatedUnion", error, defaultFormatter, path);
     };
     const parentFromUnknown = (value, options) => validateUnknown(value, options, true, false);
     const parentValidateOutput = (value, options) => validateUnknown(value, options, true, true);
     const parentTo = (value) => route(value).parent[encoderSymbol](value);
-    const parent = createTypeNode("DiscriminatedUnion", null, parentFromUnknown, (value) => getOutputMember(value)?.parent.is(value) ?? false, parentValidateOutput, ok, parentTo, getTypeIssues, { key, members });
+    const parent = createTypeNode("DiscriminatedUnion", null, parentFromUnknown, (value) => getOutputMember(value)?.parent.is(value) ?? false, parentValidateOutput, ok, parentTo, getTypeIssues, { additionalProperties: { key, members } });
+    // Identity members return the input itself, and so does routing.
+    const check = getRuntimeChecks(members) &&
+        ((value, options) => {
+            const routeResult = routeUnknown(value);
+            if (!routeResult.ok)
+                return routeResult.error;
+            const member = routeResult.value;
+            const error = member[checkSymbol](value, options);
+            return error === undefined ? undefined : createMemberError(member, error);
+        });
     const fromUnknown = (value, options) => validateUnknown(value, options, false, false);
     const validateOutput = (value, options) => validateUnknown(value, options, false, true);
     const fromParent = (value, options = firstValidationOptions) => {
@@ -4918,7 +6857,7 @@ export function discriminatedUnion(...keyOrMembers) {
     };
     const from = createFromOperation(fromParent);
     const to = (value) => route(value)[encoderSymbol](value);
-    return createTypeNode("DiscriminatedUnion", parent, fromUnknown, (value) => getOutputMember(value)?.is(value) ?? false, validateOutput, from, to, getTypeIssues, { key, members });
+    return createTypeNode("DiscriminatedUnion", parent, fromUnknown, (value) => getOutputMember(value)?.is(value) ?? false, validateOutput, from, to, getTypeIssues, { additionalProperties: { key, members }, check });
 }
 export function lazy(getType) {
     let resolution = { state: "unresolved" };
@@ -4960,11 +6899,11 @@ export function lazy(getType) {
     };
     const parentFromUnknown = (value, options = firstValidationOptions) => resolve().root.fromUnknown(value, options);
     const parentTo = (value) => resolve().root[encoderSymbol](value);
-    const parent = createTypeNode("Lazy", null, parentFromUnknown, (value) => resolve().root.is(value), (value, options) => resolve().root[outputValidationSymbol](value, options), ok, parentTo, (error, mode) => resolve().root[getRuntimeTypeIssuesSymbol](error, mode));
+    const parent = createTypeNode("Lazy", null, parentFromUnknown, (value) => resolve().root.is(value), (value, options) => resolve().root[outputValidationSymbol](value, options), ok, parentTo, (error, mode, path) => resolve().root[getRuntimeTypeIssuesSymbol](error, mode, path));
     const fromUnknown = (value, options = firstValidationOptions) => resolve().target.fromUnknown(value, options);
     const fromParent = (value, options = firstValidationOptions) => resolve().targetFromInput(value, options);
     const from = createFromOperation(fromParent);
-    const type = createTypeNode("Lazy", parent, fromUnknown, (value) => resolve().target.is(value), (value, options) => resolve().target[outputValidationSymbol](value, options), from, (value) => resolve().target[encoderSymbol](value), (error, mode) => resolve().target[getRuntimeTypeIssuesSymbol](error, mode));
+    const type = createTypeNode("Lazy", parent, fromUnknown, (value) => resolve().target.is(value), (value, options) => resolve().target[outputValidationSymbol](value, options), from, (value) => resolve().target[encoderSymbol](value), (error, mode, path) => resolve().target[getRuntimeTypeIssuesSymbol](error, mode, path));
     lazyTypeNodes.add(parent);
     lazyTypeNodes.add(type);
     return type;
@@ -5035,10 +6974,17 @@ const validateData = (value, options = firstValidationOptions) => {
         const kind = getObjectKind(value);
         if (kind === "Array") {
             const array = value;
-            for (const key of Reflect.ownKeys(array)) {
+            const keys = Reflect.ownKeys(array);
+            for (let position = 0; position < keys.length; position++) {
+                const key = keys[position];
                 if (key === "length")
                     continue;
                 if (typeof key === "string") {
+                    // Ordinary arrays list their indexes first, in ascending order.
+                    // Comparing the key first reads `length` only for an index key.
+                    if (key === globalThis.String(position) && position < array.length) {
+                        continue;
+                    }
                     const index = globalThis.Number(key) >>> 0;
                     if (index < array.length && globalThis.String(index) === key) {
                         continue;
@@ -5073,7 +7019,7 @@ const validateData = (value, options = firstValidationOptions) => {
             }
         }
         else if (kind === "Object") {
-            for (const key of Reflect.ownKeys(value)) {
+            for (const key of getOwnKeys(value)) {
                 const childPath = dataChildPath(path, key);
                 if (typeof key === "symbol") {
                     if (addIssue({
@@ -5187,7 +7133,7 @@ const validateData = (value, options = firstValidationOptions) => {
             },
         });
 };
-const getDataRuntimeTypeIssues = (error, mode) => {
+const getDataRuntimeTypeIssues = (error, mode, path) => {
     const dataError = error;
     const issues = mode === "first"
         ? [dataError.reason.issues[0]]
@@ -5200,7 +7146,8 @@ const getDataRuntimeTypeIssues = (error, mode) => {
                 type: "Data",
                 reason: { kind: "Issues", issues: [issue] },
             },
-        path: issue.path,
+        // A root issue shares the path array of its error.
+        path: path.length === 0 ? issue.path : [...path, ...issue.path],
         formatError: ((error) => {
             const issue = error.reason.issues[0];
             switch (issue.kind) {
@@ -5244,7 +7191,12 @@ const getDataRuntimeTypeIssues = (error, mode) => {
  *
  * @group Base
  */
-export const Data = /*#__PURE__*/ createTypeNode("Data", null, validateData, (value) => validateData(value).ok, validateData, ok, identity, getDataRuntimeTypeIssues);
+export const Data = /*#__PURE__*/ createTypeNode("Data", null, validateData, (value) => validateData(value).ok, validateData, ok, identity, getDataRuntimeTypeIssues, {
+    check: (value, options) => {
+        const result = validateData(value, options);
+        return result.ok ? undefined : result.error;
+    },
+});
 const emptyJsonValuePath = 
 /*#__PURE__*/ globalThis.Object.freeze([]);
 const jsonValuePathToArray = (path) => {
@@ -5327,10 +7279,17 @@ const validateJsonValue = (value, options = firstValidationOptions) => {
         }
         const children = [];
         if (isArray) {
-            for (const key of Reflect.ownKeys(value)) {
+            const keys = Reflect.ownKeys(value);
+            for (let position = 0; position < keys.length; position++) {
+                const key = keys[position];
                 if (key === "length")
                     continue;
                 if (typeof key === "string") {
+                    // Ordinary arrays list their indexes first, in ascending order.
+                    // Comparing the key first reads `length` only for an index key.
+                    if (key === globalThis.String(position) && position < value.length) {
+                        continue;
+                    }
                     const index = globalThis.Number(key) >>> 0;
                     if (index < value.length && globalThis.String(index) === key) {
                         continue;
@@ -5374,7 +7333,7 @@ const validateJsonValue = (value, options = firstValidationOptions) => {
             }
         }
         else {
-            for (const key of Reflect.ownKeys(value)) {
+            for (const key of getOwnKeys(value)) {
                 const childPath = jsonValueChildPath(path, key);
                 if (typeof key === "symbol") {
                     if (addIssue({
@@ -5429,7 +7388,7 @@ const validateJsonValue = (value, options = firstValidationOptions) => {
             },
         });
 };
-const getJsonValueRuntimeTypeIssues = (error, mode) => {
+const getJsonValueRuntimeTypeIssues = (error, mode, path) => {
     const jsonValueError = error;
     const issues = mode === "first"
         ? [jsonValueError.reason.issues[0]]
@@ -5442,7 +7401,7 @@ const getJsonValueRuntimeTypeIssues = (error, mode) => {
                 type: "JsonValue",
                 reason: { kind: "Issues", issues: [issue] },
             },
-        path: issue.path,
+        path: path.length === 0 ? issue.path : [...path, ...issue.path],
         formatError: ((error) => {
             const issue = error.reason.issues[0];
             switch (issue.kind) {
@@ -5559,7 +7518,12 @@ const stringifyJsonValue = (value) => {
  * @group JSON
  */
 export const JsonValue = 
-/*#__PURE__*/ createTypeNode("JsonValue", null, validateJsonValue, (value) => validateJsonValue(value).ok, validateJsonValue, ok, identity, getJsonValueRuntimeTypeIssues);
+/*#__PURE__*/ createTypeNode("JsonValue", null, validateJsonValue, (value) => validateJsonValue(value).ok, validateJsonValue, ok, identity, getJsonValueRuntimeTypeIssues, {
+    check: (value, options) => {
+        const result = validateJsonValue(value, options);
+        return result.ok ? undefined : result.error;
+    },
+});
 /**
  * Exact top-level JSON array {@link Type}.
  *
@@ -5695,9 +7659,9 @@ export const JsonValueFromJson = /*#__PURE__*/ transform("JsonValueFromJson", Js
  */
 export const json = (type, name, ..._validation) => {
     const runtimeType = type;
-    const getTypeIssues = (error, mode) => error.type === name
-        ? runtimeType[getRuntimeTypeIssuesSymbol](error.error, mode)
-        : Json[getRuntimeTypeIssuesSymbol](error, mode);
+    const getTypeIssues = (error, mode, path) => error.type === name
+        ? runtimeType[getRuntimeTypeIssuesSymbol](error.error, mode, path)
+        : Json[getRuntimeTypeIssuesSymbol](error, mode, path);
     const jsonToTypeOutput = (value, options = firstValidationOptions) => runtimeType.fromUnknown(parseJson(value), options);
     const jsonStringToBrandedJson = (value, options) => {
         const jsonValueResult = jsonToJsonValueResult(value);
@@ -5746,7 +7710,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 [