zod 3.26.0-canary.20250703T214020 → 3.26.0-canary.20250703T215303

package/package.json

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

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/to-json-schema.test.ts

@@ -31,7 +31,7 @@ describe("toJSONSchema", () => {
     expect(z.toJSONSchema(z.undefined())).toMatchInlineSnapshot(`
       {
         "$schema": "https://json-schema.org/draft/2020-12/schema",
-        "type": "null",
+        "not": {},
       }
     `);
     expect(z.toJSONSchema(z.any())).toMatchInlineSnapshot(`
@@ -1856,6 +1856,11 @@ 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.undefined(),
+    i: z.union([z.string(), z.number().default(2)]),
+    j: z.union([z.string(), z.string().optional()]),
   });
   expect(z.toJSONSchema(schema, { io: "input" })).toMatchInlineSnapshot(`
     {
@@ -1885,10 +1890,42 @@ test("input type", () => {
           "default": "hello",
           "type": "string",
         },
+        "f": {
+          "default": "hello",
+          "type": "string",
+        },
+        "g": {
+          "not": {},
+        },
+        "h": {
+          "not": {},
+        },
+        "i": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "default": 2,
+              "type": "number",
+            },
+          ],
+        },
+        "j": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "type": "string",
+            },
+          ],
+        },
       },
       "required": [
         "a",
         "d",
+        "g",
       ],
       "type": "object",
     }
@@ -1921,12 +1958,46 @@ test("input type", () => {
         "e": {
           "type": "string",
         },
+        "f": {
+          "default": "hello",
+          "type": "string",
+        },
+        "g": {
+          "not": {},
+        },
+        "h": {
+          "not": {},
+        },
+        "i": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "default": 2,
+              "type": "number",
+            },
+          ],
+        },
+        "j": {
+          "anyOf": [
+            {
+              "type": "string",
+            },
+            {
+              "type": "string",
+            },
+          ],
+        },
       },
       "required": [
         "a",
         "c",
         "d",
         "e",
+        "f",
+        "g",
+        "i",
       ],
       "type": "object",
     }

package/src/v4/core/schemas.ts

@@ -1238,6 +1238,8 @@ export const $ZodUndefined: core.$constructor<$ZodUndefined> = /*@__PURE__*/ cor
     $ZodType.init(inst, def);
     inst._zod.pattern = regexes.undefined;
     inst._zod.values = new Set([undefined]);
+    inst._zod.optin = "optional";
+    inst._zod.optout = "optional";
 
     inst._zod.parse = (payload, _ctx) => {
       const input = payload.value;
@@ -1374,7 +1376,6 @@ export interface $ZodNever extends $ZodType {
 
 export const $ZodNever: core.$constructor<$ZodNever> = /*@__PURE__*/ core.$constructor("$ZodNever", (inst, def) => {
   $ZodType.init(inst, def);
-
   inst._zod.parse = (payload, _ctx) => {
     payload.issues.push({
       expected: "never",
@@ -1882,11 +1883,17 @@ export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $Zo
   options: Options;
 }
 
+type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
+type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
+
 export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]>
   extends $ZodTypeInternals<$InferUnionOutput<T[number]>, $InferUnionInput<T[number]>> {
   def: $ZodUnionDef<T>;
   isst: errors.$ZodIssueInvalidUnion;
   pattern: T[number]["_zod"]["pattern"];
+  // if any element in the union is optional, then the union is optional
+  optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
+  optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
 }
 
 export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
@@ -1914,6 +1921,14 @@ function handleUnionResults(results: ParsePayload[], final: ParsePayload, inst:
 export const $ZodUnion: core.$constructor<$ZodUnion> = /*@__PURE__*/ core.$constructor("$ZodUnion", (inst, def) => {
   $ZodType.init(inst, def);
 
+  util.defineLazy(inst._zod, "optin", () =>
+    def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined
+  );
+
+  util.defineLazy(inst._zod, "optout", () =>
+    def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined
+  );
+
   util.defineLazy(inst._zod, "values", () => {
     if (def.options.every((o) => o._zod.values)) {
       return new Set<util.Primitive>(def.options.flatMap((option) => Array.from(option._zod.values!)));
@@ -3272,7 +3287,7 @@ export interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
 
 export const $ZodCatch: core.$constructor<$ZodCatch> = /*@__PURE__*/ core.$constructor("$ZodCatch", (inst, def) => {
   $ZodType.init(inst, def);
-  util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  inst._zod.optin = "optional";
   util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
   util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
 

package/src/v4/core/to-json-schema.ts

@@ -207,11 +207,6 @@ export class JSONSchemaGenerator {
             }
             break;
           }
-          case "undefined": {
-            const json = _json as JSONSchema.NullSchema;
-            json.type = "null";
-            break;
-          }
           case "null": {
             _json.type = "null";
             break;
@@ -222,6 +217,7 @@ export class JSONSchemaGenerator {
           case "unknown": {
             break;
           }
+          case "undefined":
           case "never": {
             _json.not = {};
             break;

package/v4/core/schemas.cjs

@@ -546,6 +546,8 @@ exports.$ZodUndefined = core.$constructor("$ZodUndefined", (inst, def) => {
     exports.$ZodType.init(inst, def);
     inst._zod.pattern = regexes.undefined;
     inst._zod.values = new Set([undefined]);
+    inst._zod.optin = "optional";
+    inst._zod.optout = "optional";
     inst._zod.parse = (payload, _ctx) => {
         const input = payload.value;
         if (typeof input === "undefined")
@@ -909,6 +911,8 @@ function handleUnionResults(results, final, inst, ctx) {
 }
 exports.$ZodUnion = core.$constructor("$ZodUnion", (inst, def) => {
     exports.$ZodType.init(inst, def);
+    util.defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined);
+    util.defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined);
     util.defineLazy(inst._zod, "values", () => {
         if (def.options.every((o) => o._zod.values)) {
             return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
@@ -1550,7 +1554,7 @@ exports.$ZodSuccess = core.$constructor("$ZodSuccess", (inst, def) => {
 });
 exports.$ZodCatch = core.$constructor("$ZodCatch", (inst, def) => {
     exports.$ZodType.init(inst, def);
-    util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+    inst._zod.optin = "optional";
     util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
     util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     inst._zod.parse = (payload, ctx) => {

package/v4/core/schemas.d.cts

@@ -598,10 +598,14 @@ export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $Zo
     type: "union";
     options: Options;
 }
+type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
+type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
 export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeInternals<$InferUnionOutput<T[number]>, $InferUnionInput<T[number]>> {
     def: $ZodUnionDef<T>;
     isst: errors.$ZodIssueInvalidUnion;
     pattern: T[number]["_zod"]["pattern"];
+    optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
+    optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
 }
 export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
     _zod: $ZodUnionInternals<T>;

package/v4/core/schemas.d.ts

@@ -598,10 +598,14 @@ export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $Zo
     type: "union";
     options: Options;
 }
+type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
+type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
 export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeInternals<$InferUnionOutput<T[number]>, $InferUnionInput<T[number]>> {
     def: $ZodUnionDef<T>;
     isst: errors.$ZodIssueInvalidUnion;
     pattern: T[number]["_zod"]["pattern"];
+    optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
+    optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
 }
 export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
     _zod: $ZodUnionInternals<T>;

package/v4/core/schemas.js

@@ -515,6 +515,8 @@ export const $ZodUndefined = /*@__PURE__*/ core.$constructor("$ZodUndefined", (i
     $ZodType.init(inst, def);
     inst._zod.pattern = regexes.undefined;
     inst._zod.values = new Set([undefined]);
+    inst._zod.optin = "optional";
+    inst._zod.optout = "optional";
     inst._zod.parse = (payload, _ctx) => {
         const input = payload.value;
         if (typeof input === "undefined")
@@ -878,6 +880,8 @@ function handleUnionResults(results, final, inst, ctx) {
 }
 export const $ZodUnion = /*@__PURE__*/ core.$constructor("$ZodUnion", (inst, def) => {
     $ZodType.init(inst, def);
+    util.defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined);
+    util.defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined);
     util.defineLazy(inst._zod, "values", () => {
         if (def.options.every((o) => o._zod.values)) {
             return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
@@ -1519,7 +1523,7 @@ export const $ZodSuccess = /*@__PURE__*/ core.$constructor("$ZodSuccess", (inst,
 });
 export const $ZodCatch = /*@__PURE__*/ core.$constructor("$ZodCatch", (inst, def) => {
     $ZodType.init(inst, def);
-    util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+    inst._zod.optin = "optional";
     util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
     util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     inst._zod.parse = (payload, ctx) => {

package/v4/core/to-json-schema.cjs

@@ -141,11 +141,6 @@ class JSONSchemaGenerator {
                         }
                         break;
                     }
-                    case "undefined": {
-                        const json = _json;
-                        json.type = "null";
-                        break;
-                    }
                     case "null": {
                         _json.type = "null";
                         break;
@@ -156,6 +151,7 @@ class JSONSchemaGenerator {
                     case "unknown": {
                         break;
                     }
+                    case "undefined":
                     case "never": {
                         _json.not = {};
                         break;

package/v4/core/to-json-schema.js

@@ -137,11 +137,6 @@ export class JSONSchemaGenerator {
                         }
                         break;
                     }
-                    case "undefined": {
-                        const json = _json;
-                        json.type = "null";
-                        break;
-                    }
                     case "null": {
                         _json.type = "null";
                         break;
@@ -152,6 +147,7 @@ export class JSONSchemaGenerator {
                     case "unknown": {
                         break;
                     }
+                    case "undefined":
                     case "never": {
                         _json.not = {};
                         break;