@evolu/common 8.10.0 → 8.11.0

package/dist/src/Type.js

@@ -460,7 +460,7 @@ import { createMutableRecord, getObjectKind, isPlainObject, } from "./Object.js"
 import { hasNodeBuffer } from "./Platform.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.
  *
@@ -497,7 +497,7 @@ import { instance, isInstance, } from "./Types.js";
  */
 export const typeErrorToIssues = (type, error) => {
     const runtimeType = type;
-    return runtimeType[getRuntimeTypeIssuesSymbol](error, "all").map((issue) => ({
+    return runtimeType[getRuntimeTypeIssuesSymbol](error, "all", []).map((issue) => ({
         path: issue.path,
         message: formatRuntimeTypeIssue(issue),
     }));
@@ -506,50 +506,76 @@ 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) => {
-    const summary = formatIssue(issue);
+    let message = formatIssue(issue);
     if (issue.alternatives === undefined)
-        return summary;
-    return [
-        summary,
-        ...issue.alternatives.flatMap(({ index, name, issues }) => issues.map((issue) => {
-            const path = issue.path
-                .map((key) => typeof key === "string"
-                ? `[${JSON.stringify(key)}]`
-                : `[${globalThis.String(key)}]`)
-                .join("");
-            const message = formatRuntimeTypeIssue(issue, formatIssue).replaceAll("\n", "\n  ");
-            return `- ${index}: ${name}${path}: ${message}`;
-        })),
-    ].join("\n");
+        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)
@@ -746,8 +772,12 @@ const withFormatError = (source, formatIssue, localizedTypeBySource) => {
                 })),
             }),
     });
-    const getTypeIssues = (error, mode) => source[getRuntimeTypeIssuesSymbol](error, mode).map(localizeIssue);
-    const derived = createTypeNode(source.name, parent, source.fromUnknown, source.is, source[outputValidationSymbol], source[fromSymbol], source[encoderSymbol].parent ?? source[encoderSymbol], getTypeIssues, undefined, formatIssue);
+    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.
@@ -795,9 +825,17 @@ const localizeTypeReflection = (value, 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);
@@ -847,15 +885,27 @@ const assertRefinementIdentity = (refinement) => (value) => {
  *
  * @group Construction
  */
-export const createTypeWithError = (name, type, mapError, formatError) => createRootType(name, (value, options) => {
-    const result = type.fromUnknown(value, options);
-    return result.ok ? result : err(mapError(result.error, value));
-}, formatError);
-const createRootType = (name, fromUnknown, formatError, getTypeIssues) => {
+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);
@@ -869,7 +919,7 @@ const createRootType = (name, fromUnknown, formatError, getTypeIssues) => {
         return value;
     };
     return {
-        ...instance("Type"),
+        "~evolu/instance": "Type",
         name,
         parent: null,
         fromUnknown,
@@ -879,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;
@@ -925,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" };
@@ -948,6 +1100,33 @@ 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)
@@ -969,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) => formatRuntimeTypeIssue(getTypeIssues(error, "first")[0], formatIssue);
-    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,
@@ -1007,41 +1205,55 @@ const createTypeNode = (name, parent, fromUnknown, is, validateOutput, from, own
         is,
         from: typedFrom,
         to: typedTo,
-        orThrow: createRuntimeOrThrow(fromInput, runtimeFormatError),
-        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: formatRuntimeTypeIssue(issue, formatIssue),
-                    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;
 };
@@ -1050,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.
@@ -1254,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.
  *
@@ -1327,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}.
@@ -1372,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"
@@ -1386,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,
     });
@@ -1409,16 +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 inputCheck = createUnionCheck(inputMembers);
+    const inputFrom = inputCheck
+        ? checkToFromUnknown(inputCheck)
+        : createUnionValidation(inputMembers, getFromUnknown);
     const getTypeIssues = createUnionRuntimeTypeIssues(members);
-    const input = createTypeNode("Union", null, inputFrom, (value) => inputMembers.some((member) => member.is(value)), inputValidateOutput, ok, identity, createUnionRuntimeTypeIssues(inputMembers));
-    const fromUnknown = createUnionValidation(members, (member, value, options) => member.fromUnknown(value, options));
-    const validateOutput = createUnionValidation(members, (member, value, options) => member[outputValidationSymbol](value, options));
-    const memberFromInputs = members.map((member) => getTerminalRuntimeNode(member[fromSymbol]));
-    const fromParent = createUnionValidation(members, (_member, value, options, index) => inputMembers[index].is(value)
-        ? memberFromInputs[index](value, options)
-        : undefined);
+    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) => {
@@ -1426,38 +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 createUnionRuntimeTypeIssues = (members) => (error) => [
+const createUnionRuntimeTypeIssues = (members) => (error, _mode, path) => [
     {
         name: "Union",
         error,
-        path: [],
+        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"),
+            issues: members[index][getRuntimeTypeIssuesSymbol](error, "all", []),
         })),
     },
 ];
-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 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`.
@@ -1751,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);
@@ -1767,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)
@@ -1797,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;
@@ -1939,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}.
@@ -4162,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) => {
@@ -4189,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) {
@@ -4252,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++) {
@@ -4285,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;
@@ -4304,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 },
@@ -4322,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();
@@ -4334,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;
         }
@@ -4425,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 },
@@ -4433,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.`;
@@ -4475,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)
@@ -4486,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);
@@ -4618,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.`;
@@ -4678,7 +5209,7 @@ 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);
 /**
@@ -4730,17 +5261,18 @@ export const Digit1To99 = /*#__PURE__*/ union(Digit1To9,
 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 &&
@@ -4760,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" };
@@ -4833,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
@@ -5047,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.`;
@@ -5102,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 ||
@@ -5114,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({
@@ -5275,9 +5894,12 @@ export function withDefault(property, value, { strategy } = {}) {
                 ? result
                 : err({ type: "WithDefault", outputError: result.error });
         },
-        [getRuntimeTypeIssuesSymbol]: (error, mode) => error.type === "WithDefault" && "outputError" in error
-            ? ownGetTypeIssues(error.outputError, mode)
-            : type[getRuntimeTypeIssuesSymbol](error, mode),
+        [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,
@@ -5336,13 +5958,32 @@ 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 defaultProperty = globalThis.Object.values(runtimeProps).find(isDefaultProperty);
-    if (defaultProperty) {
-        return defaultProperty[defaultPropertySymbol].createObject(props, recordType);
+    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 keys = globalThis.Object.keys(runtimeProps);
+    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({
@@ -5357,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({
@@ -5474,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;
@@ -5584,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;
                 }
@@ -5606,50 +6291,79 @@ 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 false;
+            return globalThis.Object.getOwnPropertySymbols(value).length === 0;
         }
-        return true;
-    };
-    const getTypeIssues = createObjectRuntimeTypeIssues(formatError, runtimeProps, recordType);
-    return createTypeNode("Object", parent, fromUnknown, is, validateOutput, from, to, getTypeIssues, recordType
-        ? {
-            props: runtimeProps,
-            record: recordType,
-        }
-        : { props: runtimeProps });
+        : (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();
@@ -5665,7 +6379,7 @@ const createDefaultObjectType = (props, recordType) => {
         else {
             inputProps[key] = property;
             const type = objectPropertyToType(property);
-            const output = createRootType(type.name, type[outputValidationSymbol], type.formatError, type[getRuntimeTypeIssuesSymbol]);
+            const output = createRootType(type.name, type[outputValidationSymbol], type.formatError, { getTypeIssues: type[getRuntimeTypeIssuesSymbol] });
             outputProps[key] =
                 optionalPropertySymbol in property
                     ? createOptionalProperty(output)
@@ -5698,16 +6412,18 @@ const createDefaultObjectType = (props, recordType) => {
         }
         return source[encoderSymbol](result);
     };
-    return createTypeNode("Object", parent, (value, options) => flatMapResult(source.fromUnknown(value, options), finish), output.is, output[outputValidationSymbol], createFromOperation(fromParent), to, createObjectRuntimeTypeIssues(source.formatError, props, recordType), recordType
-        ? { props, record: recordType }
-        : { props });
+    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 &&
@@ -5931,13 +6647,13 @@ export const objectKeys = (key) => (type) => {
             ? result
             : err({ type: "ObjectKeys", outputError: result.error });
     };
-    const getTypeIssues = (error, mode) => {
+    const getTypeIssues = (error, mode, path) => {
         if ("outputError" in error) {
-            return runtimeOutput[getRuntimeTypeIssuesSymbol](error.outputError, mode);
+            return runtimeOutput[getRuntimeTypeIssuesSymbol](error.outputError, mode, path);
         }
-        return input[getRuntimeTypeIssuesSymbol](error.error, mode);
+        return input[getRuntimeTypeIssuesSymbol](error.error, mode, path);
     };
-    return createTypeNode("ObjectKeys", Unknown, fromUnknown, runtimeOutput.is, validateOutput, createFromOperation(fromUnknown), to, getTypeIssues, { key, output: type });
+    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({
@@ -5995,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 } },
+                },
             });
         }
-        const input = objectResult.value;
+        if (!isPlainObject(value)) {
+            return err({
+                type: "DiscriminatedUnion",
+                reason: {
+                    kind: "Object",
+                    error: {
+                        type: "Object",
+                        reason: { kind: "UnexpectedPrototype", value },
+                    },
+                },
+            });
+        }
+        const input = value;
         const descriptor = globalThis.Object.getOwnPropertyDescriptor(input, key);
         let discriminator;
         if (descriptor === undefined) {
@@ -6050,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)
@@ -6098,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) => {
@@ -6125,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" };
@@ -6167,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;
@@ -6242,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;
@@ -6280,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({
@@ -6394,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]]
@@ -6407,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) {
@@ -6451,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) => {
@@ -6534,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;
@@ -6581,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({
@@ -6636,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]]
@@ -6649,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) {
@@ -6766,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}.
  *
@@ -6902,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);