zod 3.26.0-canary.20250703T214020 → 3.26.0-canary.20250707T201657

package/index.cjs

@@ -27,7 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.z = void 0;
-const z = __importStar(require("./v3/index.cjs"));
+const z = __importStar(require("./v3/external.cjs"));
 exports.z = z;
-__exportStar(require("./v3/index.cjs"), exports);
+__exportStar(require("./v3/external.cjs"), exports);
 exports.default = z;

package/index.d.cts

@@ -1,4 +1,4 @@
-import * as z from "./v3/index.cjs";
-export * from "./v3/index.cjs";
+import * as z from "./v3/external.cjs";
+export * from "./v3/external.cjs";
 export { z };
 export default z;

package/index.d.ts

@@ -1,4 +1,4 @@
-import * as z from "./v3/index.js";
-export * from "./v3/index.js";
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
 export { z };
 export default z;

package/index.js

@@ -1,4 +1,4 @@
-import * as z from "./v3/index.js";
-export * from "./v3/index.js";
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
 export { z };
 export default z;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.26.0-canary.20250703T214020",
+  "version": "3.26.0-canary.20250707T201657",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as z from "./v3/index.js";
-export * from "./v3/index.js";
+import * as z from "./v3/external.js";
+export * from "./v3/external.js";
 export { z };
 export default z;

package/src/v4/classic/schemas.ts

@@ -365,6 +365,8 @@ export const ZodString: core.$constructor<ZodString> = /*@__PURE__*/ core.$const
   inst.duration = (params) => inst.check(iso.duration(params as any));
 });
 
+export function string(params?: string | core.$ZodStringParams): ZodString;
+export function string<T extends string>(params?: string | core.$ZodStringParams): core.$ZodType<T, T>;
 export function string(params?: string | core.$ZodStringParams): ZodString {
   return core._string(ZodString, params) as any;
 }
@@ -1357,11 +1359,11 @@ export function partialRecord<Key extends core.$ZodRecordKey, Value extends core
   keyType: Key,
   valueType: Value,
   params?: string | core.$ZodRecordParams
-): ZodRecord<ZodUnion<[Key, ZodNever]>, Value> {
+): ZodRecord<Key & core.$partial, Value> {
   return new ZodRecord({
     type: "record",
     keyType: union([keyType, never()]),
-    valueType: valueType as any as core.$ZodType,
+    valueType: valueType as any,
     ...util.normalizeParams(params),
   }) as any;
 }

package/src/v4/classic/tests/brand.test.ts

@@ -59,7 +59,5 @@ test("$branded", () => {
 test("branded record", () => {
   const recordWithBrandedNumberKeys = z.record(z.string().brand("SomeBrand"), z.number());
   type recordWithBrandedNumberKeys = z.infer<typeof recordWithBrandedNumberKeys>;
-  expectTypeOf<recordWithBrandedNumberKeys>().toEqualTypeOf<
-    Record<string & z.core.$brand<"SomeBrand">, number | undefined>
-  >();
+  expectTypeOf<recordWithBrandedNumberKeys>().toEqualTypeOf<Record<string & z.core.$brand<"SomeBrand">, number>>();
 });

package/src/v4/classic/tests/discriminated-unions.test.ts

@@ -24,6 +24,9 @@ test("_values", () => {
 
   const post = z.literal("test").transform((_) => Math.random());
   expect(post._zod.values).toEqual(new Set(["test"]));
+
+  // Test that readonly literals pass through their values property
+  expect(z.literal("test").readonly()._zod.values).toEqual(new Set(["test"]));
 });
 
 test("valid parse - object", () => {
@@ -590,3 +593,27 @@ test("nested discriminated unions", () => {
     }
   `);
 });
+
+test("readonly literal discriminator", () => {
+  const discUnion = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("a").readonly(), a: z.string() }),
+    z.object({ type: z.literal("b"), b: z.number() }),
+  ]);
+
+  // Test that both discriminator values are correctly included in propValues
+  const propValues = discUnion._zod.propValues;
+  expect(propValues?.type?.has("a")).toBe(true);
+  expect(propValues?.type?.has("b")).toBe(true);
+
+  // Test that the discriminated union works correctly
+  const result1 = discUnion.parse({ type: "a", a: "hello" });
+  expect(result1).toEqual({ type: "a", a: "hello" });
+
+  const result2 = discUnion.parse({ type: "b", b: 42 });
+  expect(result2).toEqual({ type: "b", b: 42 });
+
+  // Test that invalid discriminator values are rejected
+  expect(() => {
+    discUnion.parse({ type: "c", a: "hello" });
+  }).toThrow();
+});

package/src/v4/classic/tests/index.test.ts

@@ -301,7 +301,7 @@ test("z.record", () => {
   // partial enum
   const d = z.record(z.enum(["a", "b"]).or(z.never()), z.string());
   type d = z.output<typeof d>;
-  expectTypeOf<d>().toEqualTypeOf<Partial<Record<"a" | "b", string>>>();
+  expectTypeOf<d>().toEqualTypeOf<Record<"a" | "b", string>>();
 });
 
 test("z.map", () => {

package/src/v4/classic/tests/object.test.ts

@@ -217,6 +217,16 @@ test("test inferred merged type", async () => {
   expectTypeOf<asdf>().toEqualTypeOf<{ a: number }>();
 });
 
+test("inferred type with Record shape", () => {
+  type A = z.ZodObject<Record<string, z.ZodType<string, number>>>;
+  expectTypeOf<z.infer<A>>().toEqualTypeOf<Record<string, string>>();
+  expectTypeOf<z.input<A>>().toEqualTypeOf<Record<string, number>>();
+
+  type B = z.ZodObject;
+  expectTypeOf<z.infer<B>>().toEqualTypeOf<Record<string, unknown>>();
+  expectTypeOf<z.input<B>>().toEqualTypeOf<Record<string, unknown>>();
+});
+
 test("inferred merged object type with optional properties", async () => {
   const Merged = z
     .object({ a: z.string(), b: z.string().optional() })
@@ -549,5 +559,5 @@ test("index signature in shape", () => {
   const schema = makeZodObj("foo");
   type schema = z.infer<typeof schema>;
 
-  expectTypeOf<schema>().toEqualTypeOf<Record<string, unknown>>();
+  expectTypeOf<schema>().toEqualTypeOf<Record<string, string>>();
 });

package/src/v4/classic/tests/optional.test.ts

@@ -37,6 +37,26 @@ test("optionality", () => {
   const e = z.string().default("asdf").nullable();
   expect(e._zod.optin).toEqual("optional");
   expect(e._zod.optout).toEqual(undefined);
+
+  // z.undefined should NOT be optional
+  const f = z.undefined();
+  expect(f._zod.optin).toEqual("optional");
+  expect(f._zod.optout).toEqual("optional");
+  expectTypeOf<typeof f._zod.optin>().toEqualTypeOf<"optional" | undefined>();
+  expectTypeOf<typeof f._zod.optout>().toEqualTypeOf<"optional" | undefined>();
+
+  // z.union should be optional if any of the types are optional
+  const g = z.union([z.string(), z.undefined()]);
+  expect(g._zod.optin).toEqual("optional");
+  expect(g._zod.optout).toEqual("optional");
+  expectTypeOf<typeof g._zod.optin>().toEqualTypeOf<"optional" | undefined>();
+  expectTypeOf<typeof g._zod.optout>().toEqualTypeOf<"optional" | undefined>();
+
+  const h = z.union([z.string(), z.optional(z.string())]);
+  expect(h._zod.optin).toEqual("optional");
+  expect(h._zod.optout).toEqual("optional");
+  expectTypeOf<typeof h._zod.optin>().toEqualTypeOf<"optional">();
+  expectTypeOf<typeof h._zod.optout>().toEqualTypeOf<"optional">();
 });
 
 test("pipe optionality", () => {

package/src/v4/classic/tests/record.test.ts

@@ -17,7 +17,7 @@ test("type inference", () => {
   expectTypeOf<booleanRecord>().toEqualTypeOf<Record<string, boolean>>();
   expectTypeOf<recordWithEnumKeys>().toEqualTypeOf<Record<"Tuna" | "Salmon", string>>();
   expectTypeOf<recordWithLiteralKey>().toEqualTypeOf<Record<"Tuna" | "Salmon", string>>();
-  expectTypeOf<recordWithLiteralUnionKeys>().toEqualTypeOf<Partial<Record<"Tuna" | "Salmon", string>>>();
+  expectTypeOf<recordWithLiteralUnionKeys>().toEqualTypeOf<Record<"Tuna" | "Salmon", string>>();
 });
 
 test("enum exhaustiveness", () => {
@@ -330,3 +330,13 @@ test("async parsing", async () => {
     ]]
   `);
 });
+
+test("partial record", () => {
+  const schema = z.partialRecord(z.string(), z.string());
+  type schema = z.infer<typeof schema>;
+  expectTypeOf<schema>().toEqualTypeOf<Partial<Record<string, string>>>();
+
+  const Keys = z.enum(["id", "name", "email"]).or(z.never());
+  const Person = z.partialRecord(Keys, z.string());
+  expectTypeOf<z.infer<typeof Person>>().toEqualTypeOf<Partial<Record<"id" | "name" | "email", string>>>();
+});

package/src/v4/classic/tests/recursive-types.test.ts

@@ -160,9 +160,10 @@ test("deferred self-recursion", () => {
   const Output = z.object({
     id: z.int(), //.nonnegative(),
     name: z.string(),
-    features: z.array(Feature), //.array(), // <—
+    get features(): z.ZodArray<typeof Feature> {
+      return Feature.array();
+    },
   });
-
   type Output = z.output<typeof Output>;
 
   type _Feature = {

package/src/v4/classic/tests/to-json-schema.test.ts

@@ -28,10 +28,9 @@ describe("toJSONSchema", () => {
         "type": "null",
       }
     `);
-    expect(z.toJSONSchema(z.undefined())).toMatchInlineSnapshot(`
+    expect(z.toJSONSchema(z.undefined(), { unrepresentable: "any" })).toMatchInlineSnapshot(`
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
-        "type": "null",
       }
     `);
     expect(z.toJSONSchema(z.any())).toMatchInlineSnapshot(`
@@ -232,6 +231,7 @@ describe("toJSONSchema", () => {
     expect(() => z.toJSONSchema(z.int64())).toThrow("BigInt cannot be represented in JSON Schema");
     expect(() => z.toJSONSchema(z.symbol())).toThrow("Symbols cannot be represented in JSON Schema");
     expect(() => z.toJSONSchema(z.void())).toThrow("Void cannot be represented in JSON Schema");
+    expect(() => z.toJSONSchema(z.undefined())).toThrow("Undefined cannot be represented in JSON Schema");
     expect(() => z.toJSONSchema(z.date())).toThrow("Date cannot be represented in JSON Schema");
     expect(() => z.toJSONSchema(z.map(z.string(), z.number()))).toThrow("Map cannot be represented in JSON Schema");
     expect(() => z.toJSONSchema(z.set(z.string()))).toThrow("Set cannot be represented in JSON Schema");
@@ -1259,6 +1259,35 @@ test("override execution order", () => {
   `);
 });
 
+test("override with path", () => {
+  const userSchema = z.object({
+    name: z.string(),
+    age: z.number(),
+  });
+
+  const capturedPaths: (string | number)[][] = [];
+
+  z.toJSONSchema(userSchema, {
+    override(ctx) {
+      capturedPaths.push(ctx.path);
+    },
+  });
+
+  expect(capturedPaths).toMatchInlineSnapshot(`
+    [
+      [
+        "properties",
+        "age",
+      ],
+      [
+        "properties",
+        "name",
+      ],
+      [],
+    ]
+  `);
+});
+
 test("pipe", () => {
   const mySchema = z
     .string()
@@ -1856,6 +1885,10 @@ test("input type", () => {
     c: z.string().default("hello"),
     d: z.string().nullable(),
     e: z.string().prefault("hello"),
+    f: z.string().catch("hello"),
+    g: z.never(),
+    h: z.union([z.string(), z.number().default(2)]),
+    i: z.union([z.string(), z.string().optional()]),
   });
   expect(z.toJSONSchema(schema, { io: "input" })).toMatchInlineSnapshot(`
     {
@@ -1885,10 +1918,39 @@ test("input type", () => {
           "default": "hello",
           "type": "string",
         },
+        "f": {
+          "default": "hello",
+          "type": "string",
+        },
+        "g": {
+          "not": {},
+        },
+        "h": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "default": 2,
+              "type": "number",
+            },
+          ],
+        },
+        "i": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "type": "string",
+            },
+          ],
+        },
       },
       "required": [
         "a",
         "d",
+        "g",
       ],
       "type": "object",
     }
@@ -1921,12 +1983,43 @@ test("input type", () => {
         "e": {
           "type": "string",
         },
+        "f": {
+          "default": "hello",
+          "type": "string",
+        },
+        "g": {
+          "not": {},
+        },
+        "h": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "default": 2,
+              "type": "number",
+            },
+          ],
+        },
+        "i": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "type": "string",
+            },
+          ],
+        },
       },
       "required": [
         "a",
         "c",
         "d",
         "e",
+        "f",
+        "g",
+        "h",
       ],
       "type": "object",
     }

package/src/v4/core/registries.ts

@@ -46,6 +46,10 @@ export class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema exten
   }
 
   remove(schema: Schema): this {
+    const meta: any = this._map.get(schema);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      this._idmap.delete(meta.id!);
+    }
     this._map.delete(schema);
     return this;
   }