Generalize numeric key handling

Author: colinhacks

packages/zod/src/v4/classic/tests/record.test.ts

@@ -487,6 +487,38 @@ test("partialRecord with z.literal([key, ...])", () => {
   `);
 });
 
+test("partialRecord with numeric literal keys", () => {
+  const Keys = z.literal([1, 2, 3]);
+  const schema = z.partialRecord(Keys, z.string());
+  type Schema = z.infer<typeof schema>;
+  expectTypeOf<Schema>().toEqualTypeOf<Partial<Record<1 | 2 | 3, string>>>();
+
+  // Should parse valid partials with numeric keys (as strings in JS objects)
+  expect(schema.parse({})).toEqual({});
+  expect(schema.parse({ 1: "one" })).toEqual({ 1: "one" });
+  expect(schema.parse({ 2: "two", 3: "three" })).toEqual({ 2: "two", 3: "three" });
+
+  // Should fail with unrecognized key
+  expect(schema.safeParse({ 4: "four" }).success).toBe(false);
+});
+
+test("partialRecord with union of string and numeric literal keys", () => {
+  const StringKeys = z.literal(["a", "b", "c"]);
+  const NumericKeys = z.literal([1, 2, 3]);
+  const schema = z.partialRecord(z.union([StringKeys, NumericKeys]), z.string());
+  type Schema = z.infer<typeof schema>;
+  expectTypeOf<Schema>().toEqualTypeOf<Partial<Record<"a" | "b" | "c" | 1 | 2 | 3, string>>>();
+
+  // Should parse valid partials with mixed keys
+  expect(schema.parse({})).toEqual({});
+  expect(schema.parse({ a: "1", 2: "4" })).toEqual({ a: "1", 2: "4" });
+  expect(schema.parse({ a: "a", b: "b", 1: "1", 2: "2" })).toEqual({ a: "a", b: "b", 1: "1", 2: "2" });
+
+  // Should fail with unrecognized key
+  expect(schema.safeParse({ d: "d" }).success).toBe(false);
+  expect(schema.safeParse({ 4: "4" }).success).toBe(false);
+});
+
 test("looseRecord passes through non-matching keys", () => {
   const schema = z.looseRecord(z.string().regex(/^S_/), z.string());
 

packages/zod/src/v4/core/schemas.ts

@@ -2804,14 +2804,9 @@ export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$con
           throw new Error("Async schemas not supported in object keys currently");
         }
 
-        // Numeric string fallback: if key failed with "expected number", retry with Number(key)
-        const checkNumericKey =
-          typeof key === "string" &&
-          regexes.number.test(key) &&
-          keyResult.issues.length &&
-          keyResult.issues.some(
-            (iss) => iss.code === "invalid_type" && (iss as errors.$ZodIssueInvalidType).expected === "number"
-          );
+        // Numeric string fallback: if key is a numeric string and failed, retry with Number(key)
+        // This handles z.number(), z.literal([1, 2, 3]), and unions containing numeric literals
+        const checkNumericKey = typeof key === "string" && regexes.number.test(key) && keyResult.issues.length;
         if (checkNumericKey) {
           const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
           if (retryResult instanceof Promise) {

play.ts

@@ -1,10 +1,8 @@
-import * as z from "./packages/zod/src/v4/index.js";
+import { z } from "zod";
 
-z;
+const type1 = z.literal(["a", "b", "c"]);
+const type2 = z.literal([1, 2, 3]);
 
-const schema = z.object({ name: z.string() }).and(z.looseRecord(z.string().regex(/_phone$/), z.e164()));
+const record = z.partialRecord(z.union([type1, type2]), z.string());
 
-type _schema = z.infer<typeof schema>;
-// { name: string } & Record<string, string> & Record<string, number>
-
-z.e164();
+console.log(record.parse({ a: "1", 2: "4" }));