@evolu/common 8.10.0 → 8.11.0

package/src/Type.test.ts

@@ -315,6 +315,9 @@ import {
   type RecordNotRecordError,
   type RecordType,
   type RecordValueIssue,
+  type RootMapType,
+  type RootRecordType,
+  type RootTupleType,
   type SetElementIssue,
   type SetElementsError,
   type SetError,
@@ -1171,6 +1174,263 @@ describe("Type operations", () => {
   });
 });
 
+describe("identity Types", () => {
+  // Transforms returning their input keep the Result-based container paths, so
+  // they show that containers of identity Types validate the same way.
+  const SameString = transform("SameString", String, String, {
+    from: (value) => ok(value),
+    to: (value) => value,
+  });
+  const SameNumber = transform("SameNumber", Number, Number, {
+    from: (value) => ok(value),
+    to: (value) => value,
+  });
+
+  const withProperty = <T extends object>(
+    value: T,
+    key: PropertyKey,
+    descriptor: PropertyDescriptor,
+  ): T => globalThis.Object.defineProperty(value, key, descriptor);
+  const accessor = { get: () => "value", enumerable: true };
+  const nonEnumerable = { value: "value", enumerable: false };
+  const symbol = globalThis.Symbol("key");
+
+  // A Map without own properties whose inherited iterator repeats keys.
+  const setupRepeatedKeyMap = (
+    entries: ReadonlyArray<readonly [unknown, unknown]>,
+  ): ReadonlyMap<unknown, unknown> =>
+    globalThis.Object.create(
+      globalThis.Object.create(Map.prototype, {
+        [globalThis.Symbol.iterator]: { value: () => entries.values() },
+      }) as object,
+    ) as ReadonlyMap<unknown, unknown>;
+
+  const assertSameValidation = (
+    identityType: TypeNode,
+    decodingType: TypeNode,
+    values: ReadonlyArray<unknown>,
+  ): void => {
+    for (const value of values) {
+      for (const options of [
+        { errors: "first" },
+        { errors: "all" },
+      ] satisfies ReadonlyArray<ValidationOptions>) {
+        const result = identityType.fromUnknown(value, options);
+        // Unlike assertEqual, this compares symbol keys of error records.
+        nodeAssert.deepStrictEqual(
+          result,
+          decodingType.fromUnknown(value, options),
+        );
+        if (result.ok) assertSame(result.value, value);
+      }
+      assertSame(identityType.is(value), decodingType.is(value));
+
+      // Output validation of a transform wraps its errors, so only the identity
+      // Type is expected to report its decoding error.
+      const outputError = (type: TypeNode) => {
+        try {
+          assertType(type, value);
+          return undefined;
+        } catch (error) {
+          return (error as Error).cause;
+        }
+      };
+      const result = identityType.fromUnknown(value);
+      nodeAssert.deepStrictEqual(
+        outputError(identityType),
+        result.ok ? undefined : result.error,
+      );
+      assertSame(outputError(decodingType) === undefined, result.ok);
+    }
+  };
+
+  it("validate collections like decoding collections", () => {
+    assertSameValidation(array(String), array(SameString), [
+      ["a", "b"],
+      ["a", 1, "b", 2],
+      globalThis.Object.assign(createMutableArray<unknown>(3), {
+        0: "a",
+        2: "b",
+      }),
+      withProperty(["a", "b"], 1, accessor),
+      globalThis.Object.assign(["a"], { extra: 1 }),
+      1,
+    ]);
+    assertSameValidation(set(String), set(SameString), [
+      new Set(["a", "b"]),
+      new Set(["a", 1, 2]),
+      withProperty(new Set(["a", 1]), "extra", { value: 1 }),
+      globalThis.Object.assign(new Set(["a", 1]), { extra: 1, other: 2 }),
+      1,
+    ]);
+    assertSameValidation(map(String, Number), map(SameString, SameNumber), [
+      new Map([["a", 1]]),
+      new Map<unknown, unknown>([
+        ["a", 1],
+        [1, "b"],
+        ["c", "d"],
+      ]),
+      withProperty(new Map<unknown, unknown>([[1, "b"]]), "extra", {
+        value: 1,
+      }),
+      globalThis.Object.assign(new Map<unknown, unknown>([[1, "b"]]), {
+        extra: 1,
+        other: 2,
+      }),
+      setupRepeatedKeyMap([
+        ["a", 1],
+        ["a", 2],
+      ]),
+      setupRepeatedKeyMap([
+        [1, 1],
+        [1, 2],
+      ]),
+      setupRepeatedKeyMap([
+        ["a", 1],
+        ["b", "x"],
+        [1, 2],
+        ["a", 2],
+      ]),
+      1,
+    ]);
+    assertSameValidation(tuple(String, Number), tuple(SameString, SameNumber), [
+      ["a", 1],
+      [1, "b"],
+      ["a"],
+      globalThis.Object.assign(["a", 1], { extra: 1 }),
+      1,
+    ]);
+  });
+
+  it("reject values without the expected class or tag", () => {
+    class User {
+      readonly name = "Ada";
+    }
+    const UserInstance = instanceOf(User);
+
+    assertFalse(Date.is(1));
+    assertEqual(
+      array(Date).fromUnknown([new globalThis.Date(0), 1], { errors: "all" }),
+      err({
+        type: "Array",
+        reason: {
+          kind: "Items",
+          issues: [
+            {
+              kind: "Element",
+              index: 1,
+              error: { type: "ObjectTag", expected: "Date", value: 1 },
+            },
+          ],
+        },
+      }),
+    );
+    assertEqual(
+      array(UserInstance).fromUnknown([new User(), 1], { errors: "all" }),
+      err({
+        type: "Array",
+        reason: {
+          kind: "Items",
+          issues: [
+            {
+              kind: "Element",
+              index: 1,
+              error: { type: "InstanceOf", constructorName: "User", value: 1 },
+            },
+          ],
+        },
+      }),
+    );
+  });
+
+  it("validate objects and records like decoding ones", () => {
+    const invalidObjects = [
+      1,
+      globalThis.Object.create({}),
+      {},
+      { a: "x", b: "x", c: 1, [symbol]: 1 },
+      withProperty({}, "a", accessor),
+      withProperty({}, "a", nonEnumerable),
+    ];
+    const invalidRecords = [
+      { a: 1, c: "y", [symbol]: 1 },
+      withProperty({ a: 1 }, "c", accessor),
+      withProperty({ a: 1 }, "c", nonEnumerable),
+    ];
+
+    assertSameValidation(
+      object({ a: Number, b: optional(String) }),
+      object({ a: SameNumber, b: optional(SameString) }),
+      [{ a: 1 }, { a: 1, b: "x" }, { b: "x", a: 1 }, ...invalidObjects],
+    );
+    assertSameValidation(
+      record(String, Number),
+      record(SameString, SameNumber),
+      [{ a: 1 }, new globalThis.Date(0), ...invalidObjects, ...invalidRecords],
+    );
+    for (const decodingType of [
+      object({ a: SameNumber }, record(String, Number)),
+      object({ a: Number }, record(String, SameNumber)),
+    ]) {
+      assertSameValidation(
+        object({ a: Number }, record(String, Number)),
+        decodingType,
+        [{ a: 1, c: 1 }, ...invalidObjects, ...invalidRecords],
+      );
+    }
+  });
+
+  it("copies identity Record properties into a decoded object", () => {
+    const Model = object(
+      { count: setupNumberFromString() },
+      record(String, union(String, Number)),
+    );
+
+    const result = Model.fromUnknown({ count: "1", first: 2, second: "3" });
+
+    assertOk(result, { count: 1, first: 2, second: "3" });
+    assertSame(globalThis.Object.getPrototypeOf(result.value), null);
+  });
+
+  it("validate unions like decoding unions", () => {
+    const Created = object({ type: literal("Created"), name: String });
+    const Deleted = object({ type: literal("Deleted"), id: Number });
+
+    assertSameValidation(
+      union(String, Number, null),
+      union(SameString, SameNumber, null),
+      ["a", 1, null, true],
+    );
+    // Lazy Types have no identity check, so this Union input validates
+    // members with Results.
+    assertSameValidation(
+      union(String, Number).parent,
+      union(
+        lazy(() => String),
+        Number,
+      ).parent,
+      ["a", 1, true],
+    );
+    assertSameValidation(
+      array(discriminatedUnion(Created, Deleted)),
+      array(
+        discriminatedUnion(
+          object({ type: literal("Created"), name: SameString }),
+          Deleted,
+        ),
+      ),
+      [
+        [
+          { type: "Created", name: "Ada" },
+          { type: "Deleted", id: 1 },
+        ],
+        [{ type: "Created", name: 1 }, { type: "Deleted" }, { type: "Moved" }],
+        [1],
+      ],
+    );
+  });
+});
+
 describe("Type.orThrow", () => {
   it("formats a returned validation error once and preserves its identity", () => {
     const cause = { type: "Text", value: "invalid" } as const;
@@ -1666,6 +1926,27 @@ describe("Standard Schema", () => {
       ],
     });
   });
+
+  it("prefixes nested JsonValue and Data issue paths", async () => {
+    const Model = object({ json: JsonValue, data: array(Data) });
+    const result = await Model["~standard"].validate({
+      json: { values: [globalThis.Number.NaN] },
+      data: [1, { value: /value/u }],
+    });
+
+    assertEqual(result, {
+      issues: [
+        {
+          message: "A JSON number must be finite.",
+          path: ["json", "values", 0],
+        },
+        {
+          message: "A Data Object has an unexpected prototype.",
+          path: ["data", 1, "value"],
+        },
+      ],
+    });
+  });
 });
 
 describe("assertType", () => {
@@ -1675,7 +1956,7 @@ describe("assertType", () => {
     assertType<never, never>();
     assertType<{ readonly value?: string }, { readonly value?: string }>();
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error ⛔ assertType error: Actual and expected types must be identical
       assertType<"value", string>();
       // @ts-expect-error ⛔ assertType error: Actual and expected types must be identical
@@ -1687,13 +1968,7 @@ describe("assertType", () => {
         { readonly value?: string },
         { readonly value: string | undefined }
       >();
-    };
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("narrows values that satisfy a Type Output", () => {
@@ -2279,7 +2554,7 @@ describe("localizeTypes", () => {
       "Localized String.",
     );
 
-    const compileTimeAssertions = () => {
+    void (() => {
       localizeTypes(
         { Strings },
         {
@@ -2294,14 +2569,7 @@ describe("localizeTypes", () => {
           missingSet: { String: () => "String." },
         },
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("localizes a Union summary and its retained member failures", () => {
@@ -2332,7 +2600,7 @@ describe("localizeTypes", () => {
       "Localized String.",
     );
 
-    const compileTimeAssertions = () => {
+    void (() => {
       localizeTypes(
         { Value },
         {
@@ -2340,14 +2608,7 @@ describe("localizeTypes", () => {
           test: { Union: () => "Union." },
         },
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("localizes nested Union details and can localize the result again", async () => {
@@ -2419,7 +2680,7 @@ describe("localizeTypes", () => {
       "Localized Literal.",
     );
 
-    const compileTimeAssertions = () => {
+    void (() => {
       localizeTypes(
         { Value },
         {
@@ -2431,14 +2692,7 @@ describe("localizeTypes", () => {
           },
         },
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("localizes fallible members of an infallible Union", () => {
@@ -2458,7 +2712,7 @@ describe("localizeTypes", () => {
       "Localized String.",
     );
 
-    const compileTimeAssertions = () => {
+    void (() => {
       localizeTypes(
         { Value },
         {
@@ -2466,14 +2720,7 @@ describe("localizeTypes", () => {
           test: {},
         },
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires fallible Types reachable only through reflection", () => {
@@ -2509,7 +2756,7 @@ describe("localizeTypes", () => {
       "Localized String.",
     );
 
-    const compileTimeAssertions = () => {
+    void (() => {
       localizeTypes(
         { Model, NonEmptyValues },
         {
@@ -2521,14 +2768,7 @@ describe("localizeTypes", () => {
           },
         },
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("routes DiscriminatedUnion member errors", () => {
@@ -2607,7 +2847,7 @@ describe("localizeTypes", () => {
       },
     ).test.Refined;
     const result = LocalizedRefined.fromUnknown("value");
-    const compileTimeAssertions = () => {
+    void (() => {
       localizeTypes(
         { Refined },
         {
@@ -2615,7 +2855,7 @@ describe("localizeTypes", () => {
           test: { String: () => "Localized String." },
         },
       );
-    };
+    });
 
     assertErr(result);
     assertEqual(
@@ -2625,12 +2865,6 @@ describe("localizeTypes", () => {
     assertEqual(await LocalizedRefined["~standard"].validate("value"), {
       issues: [{ message: "Localized Refined.", path: [] }],
     });
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
   });
 
   it("routes custom root TypeOf errors by their expected Types", async () => {
@@ -2837,7 +3071,7 @@ describe("localizeTypes", () => {
   it("requires plain string-keyed maps", () => {
     const selected = globalThis.Symbol("selected");
     const locale = globalThis.Symbol("locale");
-    const compileTimeAssertions = () => {
+    void (() => {
       localizeTypes(
         // @ts-expect-error Selected Type names must be strings.
         { [selected]: String },
@@ -2848,7 +3082,7 @@ describe("localizeTypes", () => {
         // @ts-expect-error Locale names must be strings.
         { [locale]: { String: () => "String." } },
       );
-    };
+    });
 
     const selectedByName = { [selected]: String } as unknown as {
       readonly String: typeof String;
@@ -2929,13 +3163,6 @@ describe("localizeTypes", () => {
         "localizeTypes maps must be plain objects with own enumerable string-keyed data properties.",
       ),
     );
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
   });
 
   it("requires exactly the reachable formatters", () => {
@@ -2949,7 +3176,7 @@ describe("localizeTypes", () => {
       ...formatters,
       Number: () => "Number.",
     };
-    const compileTimeAssertions = () => {
+    void (() => {
       localizeTypes({ Label }, { valid: formatters });
       localizeTypes(
         { Label },
@@ -2976,14 +3203,7 @@ describe("localizeTypes", () => {
           excessStored: excessFormatters,
         },
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires formatters for every union-typed selection branch", () => {
@@ -3015,19 +3235,12 @@ describe("localizeTypes", () => {
       "Localized Number.",
     );
 
-    const compileTimeAssertions = (selected: Selected) => {
+    void ((selected: Selected) => {
       localizeTypes(selected, {
         // @ts-expect-error Every possible selection branch requires its formatter.
         test: {},
       });
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 });
 
@@ -3114,6 +3327,11 @@ describe("createType", () => {
       NonEmptyString.formatError({ type: "NonEmptyString", value: "" }),
       "Enter some text.",
     );
+    assertAssertionError(
+      () => assertType(NonEmptyString, ""),
+      "Expected NonEmptyString.",
+      { type: "NonEmptyString", value: "" },
+    );
   });
 
   it("asserts that validation callbacks preserve identity", () => {
@@ -3173,7 +3391,7 @@ describe("createType", () => {
     assertEqual(FortyTwo.from(42), ok(42));
     assertType<typeof FortyTwo.Output, 42>();
 
-    const compileTimeAssertions = () => {
+    void (() => {
       createType(
         "Length",
         String,
@@ -3197,14 +3415,7 @@ describe("createType", () => {
         // @ts-expect-error An infallible child Type must not provide a formatter.
         () => "Unreachable.",
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires a formatter for root and fallible child Types", () => {
@@ -3217,21 +3428,14 @@ describe("createType", () => {
     ): Result<never, ChildWithoutFormatterError> =>
       err({ type: "ChildWithoutFormatter", value });
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A root Type must format its validation errors.
       createType("RootWithoutFormatter", (_value): Result<never, TypeError> =>
         err({ type: "RootWithoutFormatter" }),
       );
       // @ts-expect-error A fallible child Type must format its own error.
       createType("ChildWithoutFormatter", String, fromChildWithoutFormatter);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("inherits the parent formatter when a child is infallible", () => {
@@ -3283,7 +3487,7 @@ describe("createType", () => {
       readonly value: string;
     }
 
-    const compileTimeAssertions = () => {
+    void (() => {
       createType(
         "TypeOf",
         // @ts-expect-error A child error type must not duplicate an inherited error type.
@@ -3292,14 +3496,7 @@ describe("createType", () => {
           err({ type: "TypeOf", value }),
         () => "Duplicate TypeOf error.",
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires one concrete name for a fallible child Type", () => {
@@ -3314,37 +3511,28 @@ describe("createType", () => {
       err({ type: "A", value });
     const formatError = () => "A error.";
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A union does not identify one concrete Type name.
       createType(unionName, String, from, formatError);
       // @ts-expect-error A widened string does not identify one concrete Type name.
       createType(broadName, String, from, formatError);
       // @ts-expect-error A template pattern does not identify one concrete Type name.
       createType(patternedName, String, from, formatError);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires one concrete name for root and infallible child Types", () => {
     const unionName = "A" as "A" | "B";
     const broadName = "A" as Capitalize<string>;
     const patternedName = "A" as `A${string}`;
-    const genericCompileTimeAssertion = <Name extends "A" | "B">(
-      name: Name,
-    ): Name => {
+    void (<Name extends "A" | "B">(name: Name): Name => {
       // @ts-expect-error An unresolved generic root name might be a union.
       createType(name, ok, () => "Generic root error.");
       // @ts-expect-error An unresolved generic child name might be a union.
       createType(name, String, ok);
       return name;
-    };
-    const compileTimeAssertions = () => {
+    });
+    void (() => {
       // @ts-expect-error A union does not identify one concrete root Type name.
       createType(unionName, ok, () => "Root error.");
       // @ts-expect-error A widened string does not identify one concrete root Type name.
@@ -3357,30 +3545,13 @@ describe("createType", () => {
       createType(broadName, String, ok);
       // @ts-expect-error A template pattern does not identify one concrete child Type name.
       createType(patternedName, String, ok);
-    };
-
-    assertType<
-      typeof genericCompileTimeAssertion extends (
-        ...args: Array<never>
-      ) => unknown
-        ? true
-        : false,
-      true
-    >();
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("rejects a parent with erased concrete Type information", () => {
     const erased: FormattableTypeNode = brand("ErasedParent", String);
 
-    const compileTimeAssertions = <
-      Parent extends typeof String | typeof Number,
-    >(
+    void (<Parent extends typeof String | typeof Number>(
       parent: Parent,
     ): Parent => {
       // @ts-expect-error A parent must preserve its concrete Type.
@@ -3388,14 +3559,7 @@ describe("createType", () => {
       // @ts-expect-error An unresolved generic parent might be a union.
       createType("GenericChild", parent, ok);
       return parent;
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires a child error type matching the child name", () => {
@@ -3403,7 +3567,7 @@ describe("createType", () => {
       readonly value: string;
     }
 
-    const compileTimeAssertions = () => {
+    void (() => {
       createType(
         "ChildName",
         String,
@@ -3412,14 +3576,7 @@ describe("createType", () => {
           err({ type: "DifferentName", value }),
         () => "Different name error.",
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   describe("Type", () => {
@@ -3691,10 +3848,41 @@ describe("createTypeWithError", () => {
     ]);
   });
 
+  it("maps only invalid values inside structural Types", () => {
+    const mapError = mock.fn((cause: InferErrors<typeof String>) => ({
+      type: "Value" as const,
+      cause,
+    }));
+    const Values = array(
+      createTypeWithError("Value", String, mapError, () => "Invalid value."),
+    );
+    const valid = ["a", "b"];
+
+    assertOk(Values.fromUnknown(valid), valid);
+    assertSame(mapError.mock.callCount(), 0);
+    assertEqual(Values.fromUnknown(["a", 1]), {
+      ok: false,
+      error: {
+        type: "Array",
+        reason: {
+          kind: "Items",
+          issues: [
+            {
+              kind: "Element",
+              index: 1,
+              error: {
+                type: "Value",
+                cause: { type: "TypeOf", expected: "String", value: 1 },
+              },
+            },
+          ],
+        },
+      },
+    });
+  });
+
   it("rejects transforming sources and incompatible error names", () => {
-    const compileTimeAssertions = (
-      uncertain: typeof String | typeof Number,
-    ) => {
+    void ((uncertain: typeof String | typeof Number) => {
       createTypeWithError(
         "Value",
         // @ts-expect-error Source Type must use identity encoding.
@@ -3716,11 +3904,7 @@ describe("createTypeWithError", () => {
         () => ({ type: "Other" as const }),
         () => "Invalid value.",
       );
-    };
-    assertType<
-      typeof compileTimeAssertions,
-      (uncertain: typeof String | typeof Number) => void
-    >();
+    });
   });
 });
 
@@ -4136,7 +4320,7 @@ describe("transform", () => {
   });
 
   it("requires a formatter exactly when decoding adds an own error", () => {
-    const compileTimeAssertions = () => {
+    void (() => {
       interface MissingFormatterError extends TypeError<"MissingFormatter"> {
         readonly value: string;
       }
@@ -4158,18 +4342,11 @@ describe("transform", () => {
         // @ts-expect-error An infallible transformation has no own error to format.
         formatTestTypeError,
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires callbacks to return their declared boundary types", () => {
-    const compileTimeAssertions = () => {
+    void (() => {
       transform("InvalidOutput", String, Number, {
         // @ts-expect-error A callback must return the output Type Input.
         from: () => ok("not a number"),
@@ -4180,14 +4357,7 @@ describe("transform", () => {
         // @ts-expect-error An encoder must return the parent Type Output.
         to: () => 42,
       });
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("asserts successful decoding callback results", () => {
@@ -4267,8 +4437,10 @@ describe("transform", () => {
     );
     const erased: FormattableTypeNode = PositiveNumber;
 
-    const compileTimeAssertions = () => {
-      // @ts-expect-error A parent must preserve its concrete Type.
+    void (() => {
+      // An erased parent exposes every error type, so the name check rejects it
+      // before the concrete Type check.
+      // @ts-expect-error Error type must not duplicate an error inherited from the parent Type.
       transform("ErasedParent", erased, Number, {
         from: () => ok(42),
         to: () => 42,
@@ -4278,28 +4450,21 @@ describe("transform", () => {
         from: () => ok(-1),
         to: globalThis.String,
       });
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("rejects unresolved generic parent and output Types", () => {
     const _A = literal("a");
     const _B = literal("b");
 
-    const compileTimeAssertions = <
+    void (<
       Parent extends typeof String | typeof Number,
       Output extends typeof _A | typeof _B,
     >(
       parent: Parent,
       output: Output,
     ): readonly [Parent, Output] => {
-      // @ts-expect-error An unresolved generic parent might be a union.
+      // @ts-expect-error The name cannot be checked against an unresolved generic parent.
       transform("GenericParent", parent, Number, {
         from: () => ok(1),
         to: () => "1",
@@ -4310,14 +4475,24 @@ describe("transform", () => {
         to: (value) => value,
       });
       return [parent, output];
-    };
+    });
+  });
 
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+  it("rejects a union of parent Types", () => {
+    const parent = String as typeof String | typeof TrimmedString;
+
+    void (() => {
+      transform(
+        "UnionParent",
+        // @ts-expect-error Parent must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
+        parent,
+        Number,
+        {
+          from: () => ok(1),
+          to: () => "1",
+        },
+      );
+    });
   });
 
   it("requires an own error to use the transformation name", () => {
@@ -4325,7 +4500,7 @@ describe("transform", () => {
       readonly value: string;
     }
 
-    const compileTimeAssertions = () => {
+    void (() => {
       transform(
         "NumberFromString",
         String,
@@ -4338,14 +4513,7 @@ describe("transform", () => {
         },
         formatTestTypeError,
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("reserves outputError for errors from the output Type", () => {
@@ -4353,7 +4521,7 @@ describe("transform", () => {
       readonly outputError: TypeOfError<"Number">;
     }
 
-    const compileTimeAssertions = () => {
+    void (() => {
       transform(
         "NumberFromString",
         String,
@@ -4373,14 +4541,7 @@ describe("transform", () => {
         },
         formatTestTypeError,
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("does not widen its own errors from a broad formatter", () => {
@@ -4587,10 +4748,10 @@ describe("objectTag", () => {
     const fromParentResult = Tagged.from.parent(value);
     const transformedResult = TaggedFromString.fromUnknown("Tagged");
     const wrongTag = new TaggedValue("Other");
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A raw parent Output has no validated object-tag evidence.
       Tagged.to(value);
-    };
+    });
 
     assertType<
       typeof Tagged,
@@ -4636,12 +4797,6 @@ describe("objectTag", () => {
       }),
       'A value {"tag":"Other"} does not have the expected object tag "Tagged".',
     );
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
   });
 
   it("requires one concrete tag name and a Type for custom tags", () => {
@@ -4661,14 +4816,12 @@ describe("objectTag", () => {
     const outputType = TaggedValueInstance as
       typeof TaggedValueInstance | typeof _OtherValueInstance;
     const erasedOutputType: TypeNode = TaggedValueInstance;
-    const genericNameAssertion = <Name extends "Tagged" | "Other">(
-      name: Name,
-    ): Name => {
+    void (<Name extends "Tagged" | "Other">(name: Name): Name => {
       // @ts-expect-error An unresolved generic could be instantiated with a tag union.
       objectTag(name, TaggedValueInstance);
       return name;
-    };
-    const genericOutputAssertion = <
+    });
+    void (<
       OutputType extends
         typeof TaggedValueInstance | typeof _OtherValueInstance,
     >(
@@ -4677,8 +4830,8 @@ describe("objectTag", () => {
       // @ts-expect-error An unresolved generic could be instantiated with an output Type union.
       objectTag("Tagged", outputType);
       return outputType;
-    };
-    const compileTimeAssertions = () => {
+    });
+    void (() => {
       // @ts-expect-error A union does not identify one concrete object tag.
       objectTag(unionName, TaggedValueInstance);
       // @ts-expect-error A union does not identify one predefined object tag.
@@ -4695,26 +4848,7 @@ describe("objectTag", () => {
       objectTag("Tagged", outputType);
       // @ts-expect-error The output Type must retain its concrete information.
       objectTag("Tagged", erasedOutputType);
-    };
-
-    assertType<
-      typeof genericNameAssertion extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
-    assertType<
-      typeof genericOutputAssertion extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("rejects an ObjectTag error inherited from the output Type", () => {
@@ -4723,20 +4857,13 @@ describe("objectTag", () => {
     }
 
     const Tagged = objectTag("Tagged", instanceOf(TaggedValue));
-    const compileTimeAssertions = () => {
+    void (() => {
       objectTag(
         "Other",
         // @ts-expect-error An ObjectTag error must not duplicate one inherited from the output Type.
         Tagged,
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("infers ObjectTag localization", () => {
@@ -4808,22 +4935,17 @@ describe("instanceOf", () => {
     type ErasedConstructorParameter = Parameters<
       typeof instanceOf<ErasedConstructor>
     >[0];
-    const compileTimeAssertions = (
-      constructor: Constructor,
-      erasedConstructor: ErasedConstructor,
-    ) => {
+    void ((constructor: Constructor, erasedConstructor: ErasedConstructor) => {
       // @ts-expect-error An Instance Type requires one concrete constructor.
       instanceOf(constructor);
       // @ts-expect-error An Instance Type requires concrete constructor information.
       instanceOf(erasedConstructor);
-    };
-    const genericCompileTimeAssertion = <C extends Constructor>(
-      constructor: C,
-    ): C => {
+    });
+    void (<C extends Constructor>(constructor: C): C => {
       // @ts-expect-error An unresolved generic could be instantiated with a constructor union.
       instanceOf(constructor);
       return constructor;
-    };
+    });
 
     assertType<
       Constructor extends ConstructorParameter ? true : false,
@@ -4838,20 +4960,6 @@ describe("instanceOf", () => {
       "⛔ Type error: Constructor must preserve one concrete constructor. Create a Union Type from separate Instance Types instead of passing a union or erased constructor."
     >();
     assertType<ErasedConstructorParameter, ConstructorParameter>();
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
-    assertType<
-      typeof genericCompileTimeAssertion extends (
-        ...args: Array<never>
-      ) => unknown
-        ? true
-        : false,
-      true
-    >();
   });
 
   it("composes multiple constructors through one Union Type", () => {
@@ -4973,11 +5081,10 @@ it("ValidateOutput accepts concrete Types and rejects unions of Type nodes", ()
   assertType<ValidateOutput<typeof String>, typeof String>();
   assertType<ValidateOutput<typeof Value>, typeof Value>();
   const uncertain = String as typeof String | typeof Number;
-  const reject = () => {
+  void (() => {
     // @ts-expect-error Output Type must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
     defineOutput(uncertain);
-  };
-  assertType<typeof reject, () => void>();
+  });
 });
 
 describe("literal", () => {
@@ -4993,7 +5100,7 @@ describe("literal", () => {
       prefix: Prefix & ValidateLiteral<Prefix>,
     ): Prefix => prefix;
     assertEqual(definePrefix("APP_"), "APP_");
-    const reject = () => {
+    void (() => {
       // @ts-expect-error Expected must be one concrete literal value.
       definePrefix("APP_" as string);
       // @ts-expect-error Expected must be one concrete literal value.
@@ -5002,8 +5109,7 @@ describe("literal", () => {
       definePrefix(TrimmedString.orThrow("APP_"));
       // @ts-expect-error Expected must be one concrete literal value.
       definePrefix("APP_" as `APP_${string}`);
-    };
-    assertType<typeof reject, () => void>();
+    });
   });
 
   const Hello = literal("Hello");
@@ -5152,7 +5258,7 @@ describe("literal", () => {
     const Amount = brand("Amount", Number);
     const amount = getOrThrow(Amount.from.parent(42));
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A widened string does not identify one literal.
       literal(stringValue);
       // @ts-expect-error A widened number does not identify one literal.
@@ -5173,13 +5279,7 @@ describe("literal", () => {
       literal(globalThis.Number.POSITIVE_INFINITY);
       // @ts-expect-error NaN has the widened `number` type.
       literal(globalThis.Number.NaN);
-    };
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   describe("Type", () => {
@@ -5831,7 +5931,7 @@ describe("union", () => {
     const uncertain = String as typeof String | typeof Number;
     const possiblyInfallible = String as typeof String | typeof Unknown;
     const erased: FormattableTypeNode = String;
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A member must use one concrete Type node.
       union(uncertain, Boolean).to(42);
       // @ts-expect-error A member must preserve its concrete Type information.
@@ -5842,14 +5942,7 @@ describe("union", () => {
       union("draft", erased).to(true);
       // @ts-expect-error Infallibility must not depend on a runtime member choice.
       union(possiblyInfallible, Number).to(true);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("forwards all-errors mode to member Types", () => {
@@ -6253,7 +6346,7 @@ describe("union", () => {
     const stringValue = "draft" as string;
     const unionValue = "draft" as "draft" | "published";
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A Union requires at least two member Types.
       union();
       // @ts-expect-error A Union requires at least two member Types.
@@ -6268,14 +6361,7 @@ describe("union", () => {
       union(Number, stringValue);
       // @ts-expect-error A union does not identify one literal.
       union(Number, unionValue);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 });
 
@@ -6310,19 +6396,12 @@ describe("undefinedOr", () => {
     type Value = typeof String | typeof Number;
     const value = String as Value;
     const erased: FormattableTypeNode = String;
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error The supplied Type must use one concrete Type node.
       undefinedOr(value);
       // @ts-expect-error The supplied Type must preserve its concrete information.
       undefinedOr(erased);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 });
 
@@ -6345,19 +6424,12 @@ describe("nullOr", () => {
     type Value = typeof String | typeof Number;
     const value = String as Value;
     const erased: FormattableTypeNode = String;
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error The supplied Type must use one concrete Type node.
       nullOr(value);
       // @ts-expect-error The supplied Type must preserve its concrete information.
       nullOr(erased);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 });
 
@@ -6380,19 +6452,12 @@ describe("nullishOr", () => {
     type Value = typeof String | typeof Number;
     const value = String as Value;
     const erased: FormattableTypeNode = String;
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error The supplied Type must use one concrete Type node.
       nullishOr(value);
       // @ts-expect-error The supplied Type must preserve its concrete information.
       nullishOr(erased);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 });
 
@@ -6610,14 +6675,13 @@ describe("templateLiteralParser", () => {
     const FixedWidth = union("🙂", "a");
     const VariableWidth = union("🙂", "ab");
     const Value = templateLiteralParser(FixedWidth, String);
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error At most one Type capture can have a variable-width string representation.
       templateLiteralParser(VariableWidth, String);
-    };
+    });
 
     assertOk(Value.fromUnknown("🙂value"), ["🙂", "value"]);
     assertOk(Value.fromUnknown("avalue"), ["a", "value"]);
-    void compileTimeAssertions;
   });
 
   it("rejects surrogate pairs formed across part boundaries", () => {
@@ -6718,14 +6782,13 @@ describe("templateLiteralParser", () => {
     assertFalse(NumberValue.parent.is("number:not-a-number"));
     assertOk(NumberValue.from.parent(encoded), [42]);
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A matching string is not necessarily canonical.
       const validLooking: NumberLiteral = "number:42";
       // @ts-expect-error An invalid string is not canonical.
       const invalid: NumberLiteral = "number:not-a-number";
       return [validLooking, invalid];
-    };
-    void compileTimeAssertions;
+    });
   });
 
   it("distinguishes transforming templates with the same string shape", () => {
@@ -6787,23 +6850,21 @@ describe("templateLiteralParser", () => {
   it("rejects ambiguous variable-width captures statically", () => {
     const VariableUnion = union("a", "bb");
     const Inner = templateLiteralParser("<", String, ">");
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error At most one Type capture can have a variable-width string representation.
       templateLiteralParser(String, ":", String);
       // @ts-expect-error At most one Type capture can have a variable-width string representation.
       templateLiteralParser(VariableUnion, String);
       // @ts-expect-error At most one Type capture can have a variable-width string representation.
       templateLiteralParser(Inner, String);
-    };
-
-    void compileTimeAssertions;
+    });
   });
 
   it("requires a capture and canonically string-encoded concrete parts", () => {
     const widened = "value" as string;
     const uncertain = String as typeof String | typeof Number;
     const parts: ReadonlyArray<typeof String> = [String];
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error At least one part must be a Type capture.
       templateLiteralParser("value");
       // @ts-expect-error Part must be a raw string literal or a Type canonically encoded as a string.
@@ -6818,9 +6879,7 @@ describe("templateLiteralParser", () => {
       templateLiteralParser(uncertain);
       // @ts-expect-error Parts must use one concrete finite non-empty tuple.
       templateLiteralParser(...parts);
-    };
-
-    void compileTimeAssertions;
+    });
   });
 
   it("decodes every capture exactly once", () => {
@@ -7073,13 +7132,12 @@ describe("templateLiteralParser", () => {
     );
     assertEqual(SupportedLocale.to(["en", "US"]), "en-US");
 
-    const compileTimeAssertions = () => {
+    void (() => {
       const supported: SupportedLocaleLiteral = "cs-CZ";
       // @ts-expect-error Unsupported language.
       const unsupported: SupportedLocaleLiteral = "fr-CZ";
       return [supported, unsupported];
-    };
-    void compileTimeAssertions;
+    });
   });
 
   it("normalizes broader capture input into a canonical literal", () => {
@@ -7107,11 +7165,10 @@ describe("templateLiteralParser", () => {
     );
     assertEqual(Tag.to([lowercase]), "tag:evolu");
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error Encoding requires a lowercase branded Output.
       Tag.to(["EVOLU"]);
-    };
-    void compileTimeAssertions;
+    });
   });
 
   it("exposes canonical and parsed Standard Schema stages", async () => {
@@ -7196,14 +7253,13 @@ describe("templateLiteral", () => {
   it("uses the same reversible framing rules as templateLiteralParser", () => {
     const Value = templateLiteral(String, "::");
     const Parser = templateLiteralParser(String, "::");
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error At most one Type capture can have a variable-width string representation.
       templateLiteral(String, ":", String);
-    };
+    });
 
     assertOk(Value.fromUnknown("a::::"), "a::::");
     assertSame(Value.is("a::::"), Parser.parent.is("a::::"));
-    void compileTimeAssertions;
   });
 });
 
@@ -7288,21 +7344,76 @@ describe("brand", () => {
     >();
   });
 
+  it("refines decoded values and Outputs of a transformed base", () => {
+    const Positive = brand(
+      "Positive",
+      setupNumberFromString(),
+      (value) => (value > 0 ? ok() : err({ type: "Positive", value })),
+      formatTestTypeError,
+    );
+    const Small = brand(
+      "Small",
+      Positive,
+      (value) => (value < 10 ? ok() : err({ type: "Small", value })),
+      formatTestTypeError,
+    );
+
+    assertOk(Small.fromUnknown("5"), 5);
+    assertEqual(Small.fromUnknown("0"), err({ type: "Positive", value: 0 }));
+    assertEqual(Small.fromUnknown("50"), err({ type: "Small", value: 50 }));
+    assertTrue(Small.is(5));
+    assertFalse(Small.is(50));
+    assertAssertionError(() => assertType(Small, 50), "Expected Small.", {
+      type: "Small",
+      value: 50,
+    });
+    assertAssertionError(() => assertType(Small, "5"), "Expected Small.", {
+      type: "NumberFromString",
+      outputError: { type: "TypeOf", expected: "Number", value: "5" },
+    });
+  });
+
+  it("calls validators with only the value and without a receiver", () => {
+    const receivers = new Set<unknown>();
+    const argumentCounts = new Set<number>();
+    const Small = brand(
+      "Small",
+      Number,
+      function (this: unknown, value, ...rest: ReadonlyArray<unknown>) {
+        receivers.add(this);
+        argumentCounts.add(1 + rest.length);
+        return value < 10 ? ok() : err({ type: "Small", value });
+      },
+      formatTestTypeError,
+    );
+    // A default parameter keeps its default.
+    const SmallEven = brand(
+      "SmallEven",
+      Small,
+      (value, divisor = 2) =>
+        value % divisor === 0 ? ok() : err({ type: "SmallEven", value }),
+      formatTestTypeError,
+    );
+
+    assertOk(Small.fromUnknown(4), 4);
+    assertTrue(Small.is(4));
+    assertOk(SmallEven.fromUnknown(4), 4);
+    assertTrue(SmallEven.is(4));
+    assertEqual(SmallEven.fromUnknown(3), err({ type: "SmallEven", value: 3 }));
+    assertOk(array(SmallEven).fromUnknown([4]), [4]);
+    assertOk(object({ value: SmallEven }).fromUnknown({ value: 4 }), {
+      value: 4,
+    });
+    assertEqual([...receivers], [undefined]);
+    assertEqual([...argumentCounts], [1]);
+  });
+
   it("rejects an unresolved generic infallible name", () => {
-    const compileTimeAssertions = <Name extends "A" | "B">(
-      name: Name,
-    ): Name => {
+    void (<Name extends "A" | "B">(name: Name): Name => {
       // @ts-expect-error An unresolved generic name might be a union.
       brand<Name, typeof String>(name, String);
       return name;
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("rejects a union of parent Types", () => {
@@ -7321,17 +7432,10 @@ describe("brand", () => {
   it("rejects a parent with erased concrete Type information", () => {
     const erased: FormattableTypeNode = brand("Erased", String);
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A parent must preserve its concrete Type.
       brand("Wrapped", erased);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("inherits the parent formatter when validation is infallible", () => {
@@ -7351,17 +7455,10 @@ describe("brand", () => {
     ): Result<void, ValidatedWithoutFormatterError> =>
       err({ type: "ValidatedWithoutFormatter", value });
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A fallible brand must format its own error.
       brand("ValidatedWithoutFormatter", String, validateWithoutFormatter);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires one concrete name when validation is fallible", () => {
@@ -7376,21 +7473,14 @@ describe("brand", () => {
       err({ type: "A", value });
     const formatError = () => "A error.";
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A union does not identify one concrete Brand name.
       brand(unionName, String, validate, formatError);
       // @ts-expect-error A widened string does not identify one concrete Brand name.
       brand(broadName, String, validate, formatError);
       // @ts-expect-error A template pattern does not identify one concrete Brand name.
       brand(patternedName, String, validate, formatError);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("rejects an error type inherited from the parent Type", () => {
@@ -7398,7 +7488,7 @@ describe("brand", () => {
       readonly value: string;
     }
 
-    const compileTimeAssertions = () => {
+    void (() => {
       brand(
         "TypeOf",
         // @ts-expect-error A Brand error must not duplicate an inherited error type.
@@ -7407,14 +7497,7 @@ describe("brand", () => {
           err({ type: "TypeOf", value }),
         () => "Duplicate TypeOf error.",
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires a brand error type matching the brand name", () => {
@@ -7422,7 +7505,7 @@ describe("brand", () => {
       readonly value: string;
     }
 
-    const compileTimeAssertions = () => {
+    void (() => {
       brand(
         "BrandName",
         String,
@@ -7431,18 +7514,11 @@ describe("brand", () => {
           err({ type: "DifferentName", value }),
         () => "Different name error.",
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("requires validation to report success without replacing the parent value", () => {
-    const compileTimeAssertions = () => {
+    void (() => {
       brand(
         "Lowercase",
         String,
@@ -7450,14 +7526,7 @@ describe("brand", () => {
         (value) => ok(value.toLowerCase()),
         formatTestTypeError,
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("validates only the brand after a validated Literal parent through from.parent", () => {
@@ -8508,54 +8577,34 @@ describe("BrandFactory", () => {
     type Parent = typeof _NumberFromString | typeof _NumberFromBoolean;
     type ParentParameter = Parameters<typeof positive<Parent>>[0];
 
-    const compileTimeAssertions = (parent: Parent) => {
+    void ((parent: Parent) => {
       // @ts-expect-error A Brand Factory requires one concrete parent Type.
       positive(parent);
-    };
+    });
 
     assertType<Parent extends ParentParameter ? true : false, false>();
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
   });
 
   it("rejects incompatible and erased parents", () => {
     const { nonEmpty } = createNonEmpty();
     const erased: FormattableTypeNode = String;
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error The parent Output must have a length.
       nonEmpty(Number);
       // @ts-expect-error The parent must preserve its concrete Type information.
       nonEmpty(erased);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("rejects a parent that already exposes the factory error type", () => {
     const { nonEmpty } = createNonEmpty();
     const NonEmptyString = nonEmpty(String);
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A Brand Factory error must not duplicate an inherited error type.
       nonEmpty(NonEmptyString);
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   describe("ValidateBrandFactoryNumber", () => {
@@ -8563,7 +8612,7 @@ describe("BrandFactory", () => {
       const value = globalThis.Number(1);
       const unionValue = 1 as 1 | 2;
       const nonNegativeInt = NonNegativeInt.orThrow(1);
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error Numeric Brand parameters must not widen to number.
         minLength(1 + 1);
         // @ts-expect-error Numeric Brand parameters must not be widened.
@@ -8580,14 +8629,7 @@ describe("BrandFactory", () => {
         minLength(unionValue);
         // @ts-expect-error A branded runtime number does not identify one literal.
         maxLength(nonNegativeInt);
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
   });
 
@@ -9221,7 +9263,7 @@ describe("BrandFactory", () => {
         const constant = camelCaseToConstantCase(short);
         assertEqual(constant, "A_B_C");
         assertType<typeof constant, ConstantCaseIdentifier>();
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error Requires the CamelCaseIdentifier brand.
           camelCaseToPascalCase("example");
           // @ts-expect-error Requires the CamelCaseIdentifier brand.
@@ -9269,8 +9311,7 @@ describe("BrandFactory", () => {
           // @ts-expect-error Uppercase text does not prove the ConstantCaseIdentifier grammar.
           const _constant: ConstantCaseIdentifier =
             "HTTP PORT" as Uppercase<string>;
-        };
-        assertType<typeof compileTimeAssertions, () => void>();
+        });
       });
     });
 
@@ -9416,7 +9457,7 @@ describe("BrandFactory", () => {
         const unionPrefix = "APP_" as "APP_" | "OTHER_";
         const branded = TrimmedString.orThrow("APP_");
         const templatePrefix = "APP_" as `APP_${string}`;
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error Expected must be one concrete literal value.
           startsWith(widened);
           // @ts-expect-error Expected must be one concrete literal value.
@@ -9431,16 +9472,7 @@ describe("BrandFactory", () => {
           startsWith("APP_")(AppName);
           // @ts-expect-error OTHER_ values do not carry the StartsWithAPP_ brand.
           AppName.from(otherName);
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
     });
 
@@ -9604,7 +9636,7 @@ describe("BrandFactory", () => {
             value === "PORT" ? ok(value) : err({ type: "LiteralRoot" }),
           () => "Expected PORT.",
         );
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error Expected must be one concrete literal value.
           prefixed(widened);
           // @ts-expect-error Expected must be one concrete literal value.
@@ -9625,15 +9657,7 @@ describe("BrandFactory", () => {
           Setting.from.parent("port:4000");
           // @ts-expect-error Encoding requires a validated Port, not a plain number.
           Setting.to(4000);
-        };
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
     });
 
@@ -9663,19 +9687,10 @@ describe("BrandFactory", () => {
       });
 
       it("returns a Brand Factory that accepts the parent separately", () => {
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error Parameterized Brand Factories accept their parent separately.
           minLength(1, String);
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
 
       describe("Type", () => {
@@ -9732,19 +9747,10 @@ describe("BrandFactory", () => {
       });
 
       it("requires a parent value with a length", () => {
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error Length constraints require a value with a length.
           maxLength(1)(Number);
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
 
       describe("Type", () => {
@@ -9847,19 +9853,10 @@ describe("BrandFactory", () => {
 
       it("requires one concrete parent Type", () => {
         const parent = String as typeof String | typeof Number;
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error A constraint requires one concrete parent Type.
           length(1)(parent);
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
     });
 
@@ -9868,23 +9865,14 @@ describe("BrandFactory", () => {
         const unionName = "Pattern" as "Pattern" | "Other";
         const broadName = "Pattern" as TypeName;
         const patternedName = "Pattern" as `Pattern${string}`;
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error A union does not identify one concrete Regex name.
           regex(unionName, /./u);
           // @ts-expect-error A widened string does not identify one concrete Regex name.
           regex(broadName, /./u);
           // @ts-expect-error A template pattern does not identify one concrete Regex name.
           regex(patternedName, /./u);
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
 
       it("keeps stateful matching private and returns immutable pattern data", () => {
@@ -9927,37 +9915,19 @@ describe("BrandFactory", () => {
         assertType<typeof failure.error.source, string>();
         assertType<typeof failure.error.flags, string>();
 
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error Regex errors do not expose the live matcher.
           failure.error.pattern.test = () => true; // oxlint-disable-line typescript/no-unsafe-member-access -- The unavailable matcher access is intentionally rejected above.
           // @ts-expect-error Pattern data is readonly.
           failure.error.source = ".*";
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
 
       it("requires a string parent Output", () => {
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error Regex constraints require string Outputs.
           regex("NumberPattern", /1/u)(Number);
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
 
       describe("Type", () => {
@@ -10124,15 +10094,13 @@ describe("BrandFactory", () => {
           const _unionBrand = "Todo" as "Todo" | "User";
           const _broadBrand = "Todo" as string;
           const _patternedBrand = "Todo" as `Todo${string}`;
-          const genericBrandAssertion = <B extends "Todo" | "User">(
-            brand: B,
-          ): B => {
+          void (<B extends "Todo" | "User">(brand: B): B => {
             // @ts-expect-error An unresolved generic brand might be a union.
             createId<B>(deps);
             return brand;
-          };
+          });
 
-          const compileTimeAssertions = () => {
+          void (() => {
             // @ts-expect-error A union would assign multiple brands to one Id.
             createId<typeof _unionBrand>(deps);
             // @ts-expect-error Every Id creator rejects union brands.
@@ -10147,24 +10115,7 @@ describe("BrandFactory", () => {
             const _todoId: Id & Brand<"Todo"> = random;
             // @ts-expect-error A Todo Id must not satisfy a User Id API.
             const _userId: Id & Brand<"User"> = todoRandom;
-          };
-
-          assertType<
-            typeof genericBrandAssertion extends (
-              ...args: Array<never>
-            ) => unknown
-              ? true
-              : false,
-            true
-          >();
-          assertType<
-            typeof compileTimeAssertions extends (
-              ...args: Array<never>
-            ) => unknown
-              ? true
-              : false,
-            true
-          >();
+          });
         });
 
         it("validates the encoded representation", () => {
@@ -10210,57 +10161,29 @@ describe("BrandFactory", () => {
           assertType<typeof TodoId.Error, TableIdError<"Todo">>();
           assertType<typeof value, Id & Brand<"Todo">>();
 
-          const compileTimeAssertions = () => {
-            // @ts-expect-error A Todo Id must not satisfy a User Id API.
-            const _userId: Id & Brand<"User"> = value;
-          };
-
-          assertType<
-            typeof compileTimeAssertions extends (
-              ...args: Array<never>
-            ) => unknown
-              ? true
-              : false,
-            true
-          >();
+          void (() => {
+            // @ts-expect-error A Todo Id must not satisfy a User Id API.
+            const _userId: Id & Brand<"User"> = value;
+          });
         });
 
         it("requires one concrete table name", () => {
           const unionTable = "Todo" as "Todo" | "User";
           const broadTable = "Todo" as TypeName;
           const patternedTable = "Todo" as `Todo${string}`;
-          const genericTableAssertion = <Table extends "Todo" | "User">(
-            table: Table,
-          ): Table => {
+          void (<Table extends "Todo" | "User">(table: Table): Table => {
             // @ts-expect-error An unresolved generic table might be a union.
             id(table);
             return table;
-          };
-          const compileTimeAssertions = () => {
+          });
+          void (() => {
             // @ts-expect-error A union would assign multiple table brands to one Id.
             id(unionTable);
             // @ts-expect-error A widened TypeName does not identify one table.
             id(broadTable);
             // @ts-expect-error A template pattern does not identify one table.
             id(patternedTable);
-          };
-
-          assertType<
-            typeof genericTableAssertion extends (
-              ...args: Array<never>
-            ) => unknown
-              ? true
-              : false,
-            true
-          >();
-          assertType<
-            typeof compileTimeAssertions extends (
-              ...args: Array<never>
-            ) => unknown
-              ? true
-              : false,
-            true
-          >();
+          });
         });
 
         it("converts to and from its 16-byte representation", () => {
@@ -10621,19 +10544,10 @@ describe("BrandFactory", () => {
       });
 
       it("requires a number parent Output", () => {
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error Numeric constraints require number Outputs.
           lessThan(1)(String);
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
     });
 
@@ -11015,19 +10929,10 @@ describe("BrandFactory", () => {
         });
 
         it("requires a DecimalString parent", () => {
-          const compileTimeAssertions = () => {
+          void (() => {
             // @ts-expect-error The parent must output DecimalString.
             nonNegativeDecimalString(String);
-          };
-
-          assertType<
-            typeof compileTimeAssertions extends (
-              ...args: Array<never>
-            ) => unknown
-              ? true
-              : false,
-            true
-          >();
+          });
         });
 
         describe("Type", () => {
@@ -11244,7 +11149,7 @@ describe("BrandFactory", () => {
         const value = globalThis.String("0.1");
         const unionValue = "0.1" as "0.1" | "0.2";
         const positiveDecimalString = PositiveDecimalString.orThrow("0.1");
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error The divisor must be an exact decimal string.
           multipleOf(0.1);
           // @ts-expect-error Arithmetic expressions are numbers, not exact decimal strings.
@@ -11263,16 +11168,7 @@ describe("BrandFactory", () => {
           multipleOf(unionValue);
           // @ts-expect-error A validated runtime string still has no literal value.
           multipleOf(positiveDecimalString);
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
 
       it("creates a Brand Factory requiring an exact multiple", () => {
@@ -11384,19 +11280,10 @@ describe("BrandFactory", () => {
       });
 
       it("returns a Brand Factory that accepts the parent separately", () => {
-        const compileTimeAssertions = () => {
+        void (() => {
           // @ts-expect-error Parameterized Brand Factories accept their parent separately.
           between(1, 2, Number);
-        };
-
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
+        });
       });
     });
   });
@@ -11527,6 +11414,66 @@ describe("array", () => {
       assertSame(array(array(Number)), array(array(Number)));
     });
 
+    it("reuses Array and Set Types of a frozen element Type", () => {
+      const Frozen = globalThis.Object.freeze(brand("Frozen", String));
+      const Frozens = array(Frozen);
+
+      assertSame(array(Frozen), Frozens);
+      assertSame(Frozens.element, Frozen);
+      assertSame(set(Frozen), set(Frozen));
+      assertOk(Frozens.fromUnknown(["a"]), ["a"]);
+    });
+
+    it("creates Array and Set Types of copied element Types", () => {
+      const Label = brand("Label", String);
+      const Labels = array(Label);
+      const LabelSet = set(Label);
+      const copies = [
+        { ...Label },
+        globalThis.Object.freeze({ ...Label }),
+        globalThis.Object.create(Label) as typeof Label,
+      ];
+
+      for (const copy of copies) {
+        const Copies = array(copy);
+        assertFalse(globalThis.Object.is(Copies, Labels));
+        assertSame(Copies.element, copy);
+        assertSame(array(copy), Copies);
+        assertSame(set(copy).element, copy);
+        assertSame(set(copy), set(copy));
+      }
+      assertSame(array(Label), Labels);
+      assertSame(set(Label), LabelSet);
+    });
+
+    it("keeps cached Collection Types out of localized element Types", () => {
+      const Label = minLength(1)(String);
+      const Labels = array(Label);
+      set(Label);
+      const LocalizedLabel = localizeTypes(
+        { Label },
+        {
+          test: {
+            MinLength1: () => "Localized MinLength1.",
+            String: () => "Localized String.",
+          },
+        },
+      ).test.Label;
+      const LocalizedLabels = array(LocalizedLabel);
+
+      assertFalse(globalThis.Object.is(LocalizedLabels, Labels));
+      assertSame(LocalizedLabels.element, LocalizedLabel);
+      assertSame(array(LocalizedLabel), LocalizedLabels);
+      assertSame(set(LocalizedLabel).element, LocalizedLabel);
+
+      const result = LocalizedLabels.fromUnknown(null);
+      assertErr(result);
+      assertEqual(
+        LocalizedLabels.formatError(result.error),
+        "A value null is not an array.",
+      );
+    });
+
     it("allows heterogeneous element issues in one error", () => {
       interface AError extends TypeError<"A"> {
         readonly value: number;
@@ -11573,38 +11520,22 @@ describe("array", () => {
     });
 
     it("rejects an unresolved generic element Type", () => {
-      const compileTimeAssertions = <
-        Element extends typeof String | typeof Number,
-      >(
+      void (<Element extends typeof String | typeof Number>(
         element: Element,
       ): Element => {
         // @ts-expect-error An unresolved generic element might be a union.
         array(element);
         return element;
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
 
     it("rejects an element with erased concrete Type information", () => {
       const erased: FormattableTypeNode = brand("Erased", String);
 
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error An element must preserve its concrete Type.
         array(erased);
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
   });
 
@@ -11775,6 +11706,35 @@ describe("array", () => {
       assertEqual(reads, 0);
     });
 
+    it("rejects index-like keys that are not canonical indices below the length", () => {
+      const Numbers = array(Number);
+      const keys = [
+        "",
+        "01",
+        "-0",
+        "1.0",
+        "4294967295",
+        "4294967296",
+        "12345678901",
+      ];
+      const value = globalThis.Object.assign(
+        [1],
+        globalThis.Object.fromEntries(keys.map((key) => [key, 1])),
+      );
+
+      assertFalse(Numbers.is(value));
+      assertEqual(
+        Numbers.fromUnknown(value, { errors: "all" }),
+        err({
+          type: "Array",
+          reason: {
+            kind: "Items",
+            issues: keys.map((key) => ({ kind: "ExcessProperty", key })),
+          },
+        }),
+      );
+    });
+
     it("accepts ordinary Record elements through typed operations", () => {
       const Values = array(record(String, Number));
       const input = [{ value: 1 }];
@@ -12029,18 +11989,12 @@ describe("array", () => {
     assertType<Parameters<typeof UserIds.is>, [unknown]>();
     assertType<Parameters<typeof UserIds.orNull>, [ReadonlyArray<number>]>();
 
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error Error collection is not observable through `is`.
       UserIds.is([], { errors: "all" });
       // @ts-expect-error Error collection is not observable through `orNull`.
       UserIds.orNull([], { errors: "all" });
-    };
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   describe("is", () => {
@@ -13165,18 +13119,12 @@ describe("set", () => {
 
     const uncertain = Math.random() ? String : Number;
     const erased: FormattableTypeNode = String;
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error An element must use one concrete Type node.
       set(uncertain);
       // @ts-expect-error An element must preserve its concrete Type.
       set(erased);
-    };
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("validates the Set boundary and elements", () => {
@@ -13362,7 +13310,7 @@ describe("map", () => {
 
     const uncertain = Math.random() ? String : Number;
     const erased: FormattableTypeNode = String;
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error Map key must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
       map(uncertain, Number);
       // @ts-expect-error Map value must use one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
@@ -13371,13 +13319,7 @@ describe("map", () => {
       map(erased, Number);
       // @ts-expect-error A value must preserve its concrete Type.
       map(String, erased);
-    };
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("validates the Map boundary, structure, keys, and values", () => {
@@ -13515,6 +13457,10 @@ describe("map", () => {
     assertTrue(Counts.is(output));
     assertFalse(Counts.is(input));
     assertSame(Counts.parent, map(String, String));
+    assertType<
+      typeof Counts.parent,
+      RootMapType<typeof String, typeof String>
+    >();
     assertOk(Counts.from.parent(input), output);
     assertType<
       typeof Counts,
@@ -13538,6 +13484,15 @@ describe("map", () => {
     assertSame(map(String, TransparentNumber).to(unchanged), unchanged);
   });
 
+  it("keeps the parent chain finite for widened keys and values", () => {
+    const createLazyMap = (element: AnyType) =>
+      lazy(() => map(element, element));
+    const Names = createLazyMap(String);
+    const names = new Map([["Ada", "Lovelace"]]);
+
+    assertOk(Names.fromUnknown(names), names);
+  });
+
   it("rejects decoded key collisions and invalid encoding collisions", () => {
     const NumberFromString = setupNumberFromString();
     const Counts = map(NumberFromString, Number);
@@ -13757,7 +13712,7 @@ describe("map", () => {
     assertEqual(formatError(new Map([["Ada", "bad"]])), "Localized Number.");
     assertEqual(formatError(null), "Localized Map.");
 
-    const compileTimeAssertions = () => {
+    void (() => {
       localizeTypes(
         { Scores },
         {
@@ -13788,14 +13743,7 @@ describe("map", () => {
           },
         },
       );
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 });
 
@@ -13833,6 +13781,10 @@ describe("tuple", () => {
           readonly [typeof String, typeof NumberFromString, typeof Positive]
         >
       >();
+      assertType<
+        typeof Entry.parent,
+        RootTupleType<readonly [typeof String, typeof String, typeof Number]>
+      >();
       assertType<typeof Entry.Input, readonly [string, string, number]>();
       assertType<
         typeof Entry.Output,
@@ -13853,6 +13805,13 @@ describe("tuple", () => {
       >();
     });
 
+    it("keeps the parent chain finite for widened elements", () => {
+      const createLazyTuple = (element: AnyType) => lazy(() => tuple(element));
+      const Names = createLazyTuple(String);
+
+      assertOk(Names.fromUnknown(["Ada"]), ["Ada"]);
+    });
+
     it("creates a root Tuple without a parent", () => {
       const Pair = tuple(String, Number);
 
@@ -13902,16 +13861,14 @@ describe("tuple", () => {
       const uncertain: FormattableTypeNode = String;
       const widened: NonEmptyReadonlyArray<typeof String> = [String];
 
-      const validateUnionElement = <
-        Element extends typeof String | typeof Number,
-      >(
+      void (<Element extends typeof String | typeof Number>(
         element: Element,
       ): Element => {
         // @ts-expect-error An unresolved element might be a union of Types.
         tuple(element);
         return element;
-      };
-      const validateTupleSchema = <
+      });
+      void (<
         Elements extends
           readonly [typeof String] | readonly [typeof String, typeof Number],
       >(
@@ -13920,35 +13877,16 @@ describe("tuple", () => {
         // @ts-expect-error A union of Tuple schemas is not one concrete schema.
         tuple(...elements);
         return elements;
-      };
+      });
 
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error A Tuple must contain at least one Type.
         tuple();
         // @ts-expect-error An element must preserve its concrete Type.
         tuple(uncertain);
         // @ts-expect-error A widened array is not a finite Tuple schema.
         tuple(...widened);
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
-      assertType<
-        typeof validateUnionElement extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
-      assertType<
-        typeof validateTupleSchema extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
   });
 
@@ -14811,6 +14749,10 @@ describe("record", () => {
       assertSame(transformed.Values.parent.key, String);
       assertSame(transformed.Values.parent.value, String);
       assertSame(transformed.Values.parent.parent, null);
+      assertType<
+        typeof transformed.Values.parent,
+        RootRecordType<typeof String, typeof String>
+      >();
       assertTrue("parent" in transformed.Values.from);
       assertType<
         "parent" extends keyof typeof transformed.Values.from ? true : false,
@@ -14871,11 +14813,19 @@ describe("record", () => {
       >();
     });
 
+    it("keeps the parent chain finite for widened values", () => {
+      const createLazyRecord = (element: AnyType) =>
+        lazy(() => record(String, element));
+      const Names = createLazyRecord(String);
+
+      assertOk(Names.fromUnknown({ ada: "Lovelace" }), { ada: "Lovelace" });
+    });
+
     it("rejects every key in an empty key domain", () => {
       const Values = record(Never, Number);
       const symbol = globalThis.Symbol();
       const value = { anything: 1 };
-      const compileTimeAssertions = () => {
+      void (() => {
         Values.from({});
         Values.to({});
         Values.from({ [symbol]: true });
@@ -14888,16 +14838,10 @@ describe("record", () => {
         Values.orNull(value);
         // @ts-expect-error A Record with Never keys has no properties.
         Values.to(value);
-      };
+      });
 
       assertType<typeof Values.Input, Readonly<Record<string, never>>>();
       assertType<typeof Values.Output, Readonly<Record<string, never>>>();
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
       assertEqual(Values.fromUnknown({}), ok(createNullRecord({})));
       assertEqual(
         Values.fromUnknown(value),
@@ -14948,7 +14892,7 @@ describe("record", () => {
       type Value = typeof String | typeof Number;
       const key = String as Key;
       const value = String as Value;
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error Record key Input and Output must extend string.
         record(Number, String);
         // @ts-expect-error Record key Input and Output must extend string.
@@ -14958,14 +14902,7 @@ describe("record", () => {
         // @ts-expect-error Record value requires one concrete Type node.
         record(String, value);
         record(String, union(String, Number));
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
 
     it("distributes key and value errors inside one issue container", () => {
@@ -15400,6 +15337,53 @@ describe("record", () => {
       );
     });
 
+    it("visits Proxy own keys in their listed order", () => {
+      const Values = record(String, Number);
+      const key = globalThis.Symbol("key");
+      const input = new Proxy(
+        { value: "wrong", [key]: 1 },
+        { ownKeys: () => [key, "value"] },
+      );
+
+      assertEqual(
+        Values.fromUnknown(input),
+        err({
+          type: "Record",
+          reason: {
+            kind: "Entries",
+            issues: [
+              {
+                kind: "Key",
+                key,
+                error: { type: "TypeOf", expected: "String", value: key },
+              },
+            ],
+          },
+        }),
+      );
+      assertFalse(Values.is(input));
+    });
+
+    it("rejects a symbol key listed first without reading descriptors", () => {
+      const key = globalThis.Symbol("key");
+      let reads = 0;
+      const input = new Proxy(
+        { value: 1, [key]: 1 },
+        {
+          ownKeys: () => [key, "value"],
+          getOwnPropertyDescriptor: (target, property) => {
+            reads++;
+            return Reflect.getOwnPropertyDescriptor(target, property);
+          },
+        },
+      );
+
+      assertFalse(record(String, Number).is(input));
+      assertEqual(reads, 0);
+      assertFalse(object({}, record(String, Number)).is(input));
+      assertEqual(reads, 0);
+    });
+
     it("collects key and value issues in own-key order", () => {
       const Values = record(literal("allowed"), Number);
       const input = { wrong: "x", allowed: "y" };
@@ -16622,22 +16606,16 @@ describe("object", () => {
     it("exposes readonly properties", () => {
       const props = { value: String, note: optional(Number) };
       const Model = object(props);
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error Object properties are readonly.
         Model.props.value = String;
         // @ts-expect-error Optional Object properties are readonly.
         Model.props.note = optional(Number);
         // @ts-expect-error The Type wrapped by an optional property is readonly.
         Model.props.note.type = Number;
-      };
+      });
 
       assertType<typeof Model.props, Readonly<typeof props>>();
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
     });
 
     it("composes declared properties with a Record", () => {
@@ -16676,16 +16654,14 @@ describe("object", () => {
       const numbersFromStrings = record(String, NumberFromString);
       const recordUnion = Math.random() > 0.5 ? Values : otherRecord;
       const erased: TypeNode = Values;
-      const genericRecordAssertion = <
-        Rest extends typeof Values | typeof otherRecord,
-      >(
+      void (<Rest extends typeof Values | typeof otherRecord>(
         rest: Rest,
       ): Rest => {
         // @ts-expect-error An unresolved generic could be instantiated with a Record Type union.
         object({}, rest);
         return rest;
-      };
-      const compileTimeAssertions = () => {
+      });
+      void (() => {
         object({ count: Number });
         object({ count: Number }, Values);
         // @ts-expect-error The second argument must be a Record Type.
@@ -16710,18 +16686,12 @@ describe("object", () => {
         Model.from({ count: 0, other: "not a number" });
         // @ts-expect-error Undeclared properties must match the Record value Output.
         Model.to({ count: 0, other: "not a number" });
-      };
+      });
       interface Errors {
         readonly count: TypeOfError<"Number">;
       }
 
       assertSame(Model.record, Values);
-      assertType<
-        typeof genericRecordAssertion extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
       assertSame(Model.parent, null);
       assertType<
         typeof Model extends ObjectType<
@@ -16761,26 +16731,20 @@ describe("object", () => {
           : false,
         false
       >();
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
     });
 
     it("rejects every property in an empty schema", () => {
       const Model = object({});
       const symbol = globalThis.Symbol();
       const value = { anything: 1 };
-      const compileTimeAssertions = () => {
+      void (() => {
         Model.from({ [symbol]: true });
         Model.to({ [symbol]: true });
         // @ts-expect-error Object.from requires an object value.
         Model.from(42);
         // @ts-expect-error An empty Object schema has no properties.
         Model.from(value);
-      };
+      });
 
       assertType<typeof Model.Input, Readonly<Record<string, never>>>();
       assertType<typeof Model.Output, Readonly<Record<string, never>>>();
@@ -16792,12 +16756,6 @@ describe("object", () => {
         InferErrors<typeof Model>,
         ObjectError<Readonly<Record<never, never>>>
       >();
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
       assertEqual(
         Model.fromUnknown(value),
         err({
@@ -16892,9 +16850,7 @@ describe("object", () => {
       const optionalProperty: OptionalProperty<Property> = optional(String);
       const requiredOrOptional = String as
         typeof String | OptionalProperty<typeof String>;
-      const genericCompileTimeAssertion = <
-        Property extends typeof String | typeof Number,
-      >(
+      void (<Property extends typeof String | typeof Number>(
         genericProperty: Property,
       ): Property => {
         // @ts-expect-error An unresolved generic could be instantiated with a property Type union.
@@ -16902,33 +16858,19 @@ describe("object", () => {
         // @ts-expect-error typed preserves Object property validation.
         typed("Generic", { value: genericProperty });
         return genericProperty;
-      };
-      const compileTimeAssertions = () => {
+      });
+      void (() => {
         // @ts-expect-error A property requires one concrete Type node.
         object({ value: property });
         // @ts-expect-error An optional property requires one concrete Type node.
         optional(property);
-        // @ts-expect-error An Object property requires one concrete wrapped Type node.
-        object({ value: optionalProperty });
-        // @ts-expect-error Requiredness must not depend on a runtime union.
-        object({ value: requiredOrOptional });
-      };
-
-      assertType<Property extends OptionalParameter ? true : false, false>();
-      assertType<
-        typeof genericCompileTimeAssertion extends (
-          ...args: Array<never>
-        ) => unknown
-          ? true
-          : false,
-        true
-      >();
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+        // @ts-expect-error An Object property requires one concrete wrapped Type node.
+        object({ value: optionalProperty });
+        // @ts-expect-error Requiredness must not depend on a runtime union.
+        object({ value: requiredOrOptional });
+      });
+
+      assertType<Property extends OptionalParameter ? true : false, false>();
     });
 
     it("rejects erased property Types and a union of schemas", () => {
@@ -16940,7 +16882,7 @@ describe("object", () => {
       const getSubsumedProps = (): typeof baseProps | typeof extendedProps =>
         Math.random() > 0.5 ? baseProps : extendedProps;
       const subsumedProps = getSubsumedProps();
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error Optional requires a property Type with concrete information.
         optional(type);
         // @ts-expect-error Object requires a property Type with a concrete parent.
@@ -16949,14 +16891,7 @@ describe("object", () => {
         object(props);
         // @ts-expect-error A structurally wider branch is still a schema union.
         object(subsumedProps);
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
 
     it("rejects reserved structural error tags in property Types", () => {
@@ -16995,7 +16930,7 @@ describe("object", () => {
         formatTestTypeError,
       );
       const ExcessChild = brand("ExcessChild", Excess);
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error ObjectMissingProperty is reserved for Object structure.
         object({ value: Missing });
         // @ts-expect-error Reserved errors are rejected for optional properties too.
@@ -17008,14 +16943,7 @@ describe("object", () => {
         object({ value: optional(Access) });
         // @ts-expect-error ObjectExcessProperty is reserved through child Types and optional properties.
         object({ value: optional(ExcessChild) });
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
 
     it("requires a fixed set of string property names", () => {
@@ -17030,7 +16958,7 @@ describe("object", () => {
       const symbol = globalThis.Symbol();
       const number = { 0: String };
       const proto = { ["__proto__"]: String };
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error Broad keys belong to a Record Type.
         object(broad);
         // @ts-expect-error Template-pattern keys belong to a Record Type.
@@ -17045,14 +16973,7 @@ describe("object", () => {
         object(number);
         // @ts-expect-error __proto__ is not an Object property name.
         object(proto);
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
   });
 
@@ -18086,6 +18007,48 @@ describe("object", () => {
       assertTrue(Model.is({ name: "Ada" }));
     });
 
+    it("compares own keys with the declared keys, not only their count", () => {
+      const Model = object({ name: String, role: String });
+      const reordered = { role: "admin", name: "Ada" };
+      const renamed: unknown = { name: "Ada", title: "admin" };
+
+      const reorderedResult = Model.fromUnknown(reordered);
+      assertOk(reorderedResult);
+      assertSame(reorderedResult.value, reordered);
+      assertTrue(Model.is(reordered));
+
+      const result = Model.fromUnknown(renamed, { errors: "all" });
+      assertEqual(
+        result,
+        err({
+          type: "Object",
+          reason: {
+            kind: "Properties",
+            errors: {
+              role: { type: "ObjectMissingProperty" },
+              title: { type: "ObjectExcessProperty" },
+            },
+          },
+        }),
+      );
+      assertErr(result);
+      assertSame(result.error.reason.kind, "Properties");
+      assertEqual(Reflect.ownKeys(result.error.reason.errors), [
+        "role",
+        "title",
+      ]);
+      assertFalse(Model.is(renamed));
+
+      // Position alone must not skip an undeclared key before declared ones.
+      const prefixed = { title: 1, name: "Ada", role: "admin" };
+      assertFalse(Model.is(prefixed));
+      assertFalse(
+        object({ name: String, role: String }, record(String, String)).is(
+          prefixed,
+        ),
+      );
+    });
+
     it("rejects non-enumerable and symbol excess properties", () => {
       const Model = object({ name: String });
       const symbol = globalThis.Symbol("excess");
@@ -18108,6 +18071,44 @@ describe("object", () => {
       assertEqual(Reflect.ownKeys(errors), ["hidden", symbol]);
     });
 
+    it("visits Proxy own keys in their listed order", () => {
+      const Model = object({ name: String });
+      const symbol = globalThis.Symbol("excess");
+      const value = new Proxy(
+        { name: "Ada", role: "admin", [symbol]: true },
+        { ownKeys: () => [symbol, "role", "name"] },
+      );
+
+      const result = Model.fromUnknown(value);
+      assertErr(result);
+      assertSame(result.error.reason.kind, "Properties");
+      assertEqual(Reflect.ownKeys(result.error.reason.errors), [symbol]);
+      assertFalse(Model.is(value));
+    });
+
+    it("copies earlier unchanged Record properties into a decoded object", () => {
+      const Model = object(
+        { count: Number },
+        record(String, union(Number, setupNumberFromString())),
+      );
+
+      const result = Model.fromUnknown({
+        count: 0,
+        first: 1,
+        second: "2",
+        third: 3,
+      });
+
+      assertOk(result, { count: 0, first: 1, second: 2, third: 3 });
+      assertSame(globalThis.Object.getPrototypeOf(result.value), null);
+      assertEqual(globalThis.Object.keys(result.value), [
+        "count",
+        "first",
+        "second",
+        "third",
+      ]);
+    });
+
     it("rejects exotic declared and Record properties without reading them", () => {
       const Model = object({ count: Number }, record(String, Number));
       let reads = 0;
@@ -18562,6 +18563,43 @@ describe("object", () => {
       });
     });
 
+    it("validates Record property Outputs without decoding them", () => {
+      const Model = object({}, record(String, setupNumberFromString()));
+      const invalid = {
+        first: 1,
+        second: "2",
+      } as unknown as typeof Model.Output;
+
+      assertAssertionError(() => Model.from(invalid), "Expected Object.", {
+        type: "Object",
+        reason: {
+          kind: "Properties",
+          errors: {
+            second: {
+              type: "Record",
+              reason: {
+                kind: "Entries",
+                issues: [
+                  {
+                    kind: "Value",
+                    key: "second",
+                    error: {
+                      type: "NumberFromString",
+                      outputError: {
+                        type: "TypeOf",
+                        expected: "Number",
+                        value: "2",
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        },
+      });
+    });
+
     it("validates every property chain from its parent in declaration order", () => {
       const {
         Model,
@@ -18638,10 +18676,10 @@ describe("object", () => {
       const Model = object({ name: String });
       const symbol = globalThis.Symbol();
       const value = { name: "Ada", [symbol]: true };
-      const compileTimeAssertions = () => {
+      void (() => {
         Model.from(value);
         Model.to(value);
-      };
+      });
 
       assertType<
         typeof Model.Input extends {
@@ -18667,12 +18705,6 @@ describe("object", () => {
         { readonly name: string } extends typeof Model.Output ? true : false,
         true
       >();
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
     });
 
     it("return valid Object and Record values", () => {
@@ -18756,7 +18788,7 @@ describe("object", () => {
         name: String,
       };
       const uncertain = String as typeof String | typeof Number;
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error Partial Object properties require fixed keys.
         partial(dynamic);
         // @ts-expect-error Nullable Object properties require fixed keys.
@@ -18765,14 +18797,7 @@ describe("object", () => {
         partial({ value: uncertain });
         // @ts-expect-error Nullable Object properties require one concrete Type node.
         nullableToOptional({ value: uncertain });
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
 
     describe("omit", () => {
@@ -18796,15 +18821,12 @@ describe("object", () => {
         assertEqual(Empty.props, {});
         assertType<typeof Empty, ObjectType<{}>>();
 
-        const compileTimeAssertions = (
-          key: "name" | "age",
-          keys: ReadonlyArray<"name" | "age">,
-        ) => {
+        void ((key: "name" | "age", keys: ReadonlyArray<"name" | "age">) => {
           // @ts-expect-error A runtime key must identify one statically known property.
           omit(User, key);
           // @ts-expect-error A runtime array does not guarantee which properties are omitted.
           omit(User, ...keys);
-        };
+        });
 
         const Metadata = object(
           { name: String, age: Number },
@@ -18824,14 +18846,6 @@ describe("object", () => {
           MetadataWithoutAge.fromUnknown({ name: "Ada", age: "unknown" }),
           { name: "Ada", age: "unknown" },
         );
-        assertType<
-          typeof compileTimeAssertions extends (
-            ...args: Array<never>
-          ) => unknown
-            ? true
-            : false,
-          true
-        >();
       });
 
       it("retains defaulted fields and can remove every default", () => {
@@ -18906,10 +18920,10 @@ describe("result", () => {
     const Pair = tuple(String, Number);
     const PairResult = result(Pair, Pair);
     const NeverResult = result(Never, Never);
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error The exact ok discriminator must select the value branch.
       StringResult.from({ ok: false, value: "value" });
-    };
+    });
 
     assertEqual(StringResult.name, "DiscriminatedUnion");
     assertEqual(StringResult.key, "ok");
@@ -18929,12 +18943,6 @@ describe("result", () => {
         ]
       >
     >();
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
     assertOk(StringResult.fromUnknown({ ok: true, value: "value" }), {
       ok: true,
       value: "value",
@@ -19037,19 +19045,13 @@ describe("typed", () => {
       const Message = discriminatedUnion(Create, Delete);
       type Message = typeof Message.Output;
       type CreateMessage = ExtractTyped<Message, "Create">;
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error The selected type must exist in the Output union.
         type Typo = ExtractTyped<Message, "Cretae">;
         assertType<Typo, never>();
-      };
+      });
 
       assertType<CreateMessage, typeof Create.Output>();
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
     });
 
     it("creates a strict Object with only a literal type property", () => {
@@ -19340,12 +19342,12 @@ describe("typed", () => {
         ValuesWithTag,
       );
       const value = { type: "Open", label: "Label", note: "Note" } as const;
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error Additional properties must match the Record value Type.
         Open.from({ type: "Open", label: "Label", score: 1 });
         // @ts-expect-error The declared CanonicalInput must extend the Record value CanonicalInput.
         typed("Open", { fixed: AFromString }, ValuesWithTag);
-      };
+      });
 
       assertSame(Open.record, Values);
       assertType<
@@ -19400,12 +19402,6 @@ describe("typed", () => {
           },
         }),
       );
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
     });
 
     it("requires one concrete Type name and reserves the type property", () => {
@@ -19423,14 +19419,12 @@ describe("typed", () => {
       const recordUnion = Math.random() > 0.5 ? Values : UnknownValues;
       const erasedRecord: TypeNode = Values;
       const restrictedKeys = record(literal("value"), String);
-      const genericTagAssertion = <Tag extends "One" | "Two">(
-        tag: Tag,
-      ): Tag => {
+      void (<Tag extends "One" | "Two">(tag: Tag): Tag => {
         // @ts-expect-error An unresolved generic could be instantiated with a tag union.
         typed(tag);
         return tag;
-      };
-      const compileTimeAssertions = () => {
+      });
+      void (() => {
         // @ts-expect-error Type names start with an uppercase letter.
         typed("one");
         // @ts-expect-error A union does not identify one concrete Type name.
@@ -19458,20 +19452,7 @@ describe("typed", () => {
         typed("One", {}, restrictedKeys);
         // @ts-expect-error Declared Inputs and Outputs must extend the Record value Type.
         typed("One", { value: Number }, Values);
-      };
-
-      assertType<
-        typeof genericTagAssertion extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
   });
 
@@ -19479,10 +19460,10 @@ describe("typed", () => {
     it("rejects missing, mismatched, and excess properties", () => {
       const Empty = typed("Empty");
       const valueWithExcessProperty = { type: "Empty", extra: true } as const;
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error Strict typed Input excludes excess properties.
         Empty.from({ type: "Empty", extra: true });
-      };
+      });
 
       assertEqual(
         Empty.fromUnknown({}),
@@ -19506,12 +19487,6 @@ describe("typed", () => {
         }),
       );
       assertFalse(Empty.is(valueWithExcessProperty));
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
     });
   });
 
@@ -19771,7 +19746,7 @@ describe("discriminatedUnion", () => {
       const broadKey = "type" as string;
       const unionKey = "type" as "type" | "kind";
       const patternedKey = "type" as `type${string}`;
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error A Discriminated Union requires at least two members.
         discriminatedUnion();
         // @ts-expect-error A Discriminated Union requires at least two members.
@@ -19798,14 +19773,7 @@ describe("discriminatedUnion", () => {
         discriminatedUnion(unionKey, Valid, typed("Other"));
         // @ts-expect-error The explicit discriminator key must not be a template pattern.
         discriminatedUnion(patternedKey, Valid, typed("Other"));
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
 
     it("requires one concrete finite member tuple", () => {
@@ -19830,7 +19798,7 @@ describe("discriminatedUnion", () => {
       ] = [OneWithString, TwoWithString];
       const uncertainThird = ThreeWithString as
         typeof ThreeWithString | typeof _ThreeWithNumber;
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error Members must use one concrete finite tuple.
         discriminatedUnion(...members);
         // @ts-expect-error Explicit-key members must also use one concrete finite tuple.
@@ -19841,14 +19809,7 @@ describe("discriminatedUnion", () => {
         discriminatedUnion(...widenedMembers);
         // @ts-expect-error Every member slot must use one concrete Object Type.
         discriminatedUnion(OneWithString, TwoWithString, uncertainThird);
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
   });
 
@@ -19987,10 +19948,10 @@ describe("discriminatedUnion", () => {
       const Deleted = typed("Deleted", { reason: String });
       const Event = discriminatedUnion(Created, Deleted);
       const uncorrelated = { type: "Created", reason: "reason" } as const;
-      const compileTimeAssertions = () => {
+      void (() => {
         // @ts-expect-error The exact discriminator must correlate with its member Input.
         Event.from(uncorrelated);
-      };
+      });
 
       assertType<
         typeof uncorrelated extends typeof Event.Input ? true : false,
@@ -20016,12 +19977,6 @@ describe("discriminatedUnion", () => {
           },
         }),
       );
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
     });
 
     it("returns routed discriminator, access, and member errors", () => {
@@ -20397,43 +20352,28 @@ describe("lazy", () => {
     type Definition = Parameters<typeof lazy<Target>>[0];
     type DefinitionOutput = ReturnType<Definition>;
     const getTarget = (): Target => chooseTarget(true);
-    const compileTimeAssertions = () => {
+    void (() => {
       // @ts-expect-error A Lazy Type definition must return one concrete Type node.
       lazy(getTarget);
       // @ts-expect-error An inferred Lazy Type definition must also return one concrete Type node.
       lazy(() => chooseTarget(true));
-    };
+    });
 
     assertType<Target extends DefinitionOutput ? true : false, false>();
     assertType<
       DefinitionOutput,
       "⛔ Type error: Lazy Type definition must return one concrete Type node. Pass a Union Type node instead of a union of Type nodes."
     >();
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
   });
 
   it("rejects an unresolved generic definition", () => {
-    const compileTimeAssertions = <
-      Target extends typeof String | typeof Number,
-    >(
+    void (<Target extends typeof String | typeof Number>(
       target: Target,
     ): Target => {
       // @ts-expect-error An unresolved generic target might be a union.
       lazy(() => target);
       return target;
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("accepts one Union Type node as its definition", () => {
@@ -21310,6 +21250,20 @@ describe("Data", () => {
     );
     assertFalse(Data.fromUnknown(sparse, { errors: "all" }).ok);
 
+    // The index after a hole is listed at an earlier position.
+    const trailing = createMutableArray<Data>(2);
+    trailing[1] = 1;
+    assertEqual(
+      Data.fromUnknown(trailing, { errors: "all" }),
+      err({
+        type: "Data",
+        reason: {
+          kind: "Issues",
+          issues: [{ kind: "Hole", path: [0] }],
+        },
+      }),
+    );
+
     let reads = 0;
     const accessor = createMutableArray<Data>(1);
     globalThis.Object.defineProperty(accessor, 0, {
@@ -22136,7 +22090,7 @@ describe("json", () => {
     >();
     assertType<ReturnType<typeof Person.to>, typeof Person.CanonicalInput>();
 
-    const compileTimeAssertions = () => {
+    void (() => {
       type InvalidCanonicalInput = Type<
         "InvalidCanonicalInput",
         string,
@@ -22154,14 +22108,7 @@ describe("json", () => {
       // The encoder's actual image is finite, but CanonicalInput is number.
       // @ts-expect-error Type CanonicalInput must be JSON-compatible.
       json(_FiniteAfterNumberTransform, "FiniteAfterNumberTransformJson");
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("creates a branded Json Type and total typed conversions", () => {
@@ -22405,7 +22352,7 @@ describe("json", () => {
   });
 
   it("accepts only Types with a JSON-compatible canonical Input", () => {
-    const compileTimeAssertions = () => {
+    void (() => {
       interface StringTree {
         readonly value: string;
         readonly children: ReadonlyArray<StringTree>;
@@ -22762,14 +22709,7 @@ describe("json", () => {
 
       // @ts-expect-error Type CanonicalInput must be JSON-compatible.
       json(NonCanonicalArrayIndex, "NonCanonicalArrayIndexJson");
-    };
-
-    assertType<
-      typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-        ? true
-        : false,
-      true
-    >();
+    });
   });
 
   it("forwards ValidationOptions to the represented Type", () => {
@@ -22911,7 +22851,7 @@ describe("json", () => {
 describe("design decisions", () => {
   describe("typed inputs", () => {
     it("protect append-only fields from incompatible component changes", () => {
-      const compileTimeAssertions = () => {
+      void (() => {
         const Todo = object({ title: NonEmptyTrimmedString100 });
 
         // The input guarantees the same constraints as the domain model.
@@ -22939,18 +22879,11 @@ describe("design decisions", () => {
         };
 
         return { inputOnChange, longerInputOnChange };
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
 
     it("compose one weaker component output", () => {
-      const compileTimeAssertions = () => {
+      void (() => {
         const Todo = object({
           title: NonEmptyTrimmedString100,
           note: NonEmptyTrimmedString100,
@@ -22980,18 +22913,11 @@ describe("design decisions", () => {
         };
 
         return saveTodo;
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
 
     it("compose trim-only component outputs", () => {
-      const compileTimeAssertions = () => {
+      void (() => {
         const Todo = object({
           title: NonEmptyTrimmedString100,
           note: NonEmptyTrimmedString100,
@@ -23013,14 +22939,7 @@ describe("design decisions", () => {
         >();
 
         return saveTodo;
-      };
-
-      assertType<
-        typeof compileTimeAssertions extends (...args: Array<never>) => unknown
-          ? true
-          : false,
-        true
-      >();
+      });
     });
   });
 
@@ -23380,7 +23299,7 @@ describe("objectKeys", () => {
   });
 
   it("requires string key codecs and a concrete strict object", () => {
-    const reject = () => {
+    void (() => {
       // @ts-expect-error Key Output must be string.
       objectKeys(PortFromString);
       // @ts-expect-error objectKeys requires a strict Object Type without a record rest.
@@ -23392,8 +23311,7 @@ describe("objectKeys", () => {
         : object({ age: Number });
       // @ts-expect-error Output Type must be one concrete Type node. Pass a Union Type node instead of a union of Type nodes.
       objectKeys(String)(objectType);
-    };
-    assertType<typeof reject, () => void>();
+    });
   });
 });