zod 4.6.1 → 4.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.6.1",
+  "version": "4.6.2",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

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

@@ -1,6 +1,76 @@
 import { expect, expectTypeOf, test } from "vitest";
 import { z } from "zod/v4";
 
+test.each([false, true])("undefined prefault preserves object keys (jitless: %s)", async (jitless) => {
+  const previous = z.config().jitless;
+  z.config({ jitless });
+  try {
+    let calls = 0;
+    const field = z.union([z.string(), z.undefined()]).prefault(() => {
+      calls++;
+      return undefined;
+    });
+    const schema = z.object({ a: field });
+    expectTypeOf<z.output<typeof field>>().toEqualTypeOf<string | undefined>();
+    expectTypeOf<z.input<typeof schema>>().toEqualTypeOf<{ a?: string | undefined }>();
+    expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: string | undefined }>();
+    expect(schema.parse({})).toStrictEqual({ a: undefined });
+    expect(calls).toBe(1);
+    expect(schema.parse({ a: undefined })).toStrictEqual({ a: undefined });
+    expect(calls).toBe(2);
+    expect(await schema.parseAsync({})).toStrictEqual({ a: undefined });
+    expect(calls).toBe(3);
+    expect(schema.parse({ a: "value" })).toStrictEqual({ a: "value" });
+    expect(schema.safeParse({ a: 123 }).success).toBe(false);
+    expect(calls).toBe(3);
+
+    const literal = z.prefault(z.string().optional(), undefined);
+    expect(z.core.compileFn(z.object({ a: literal }))({})).toStrictEqual({ a: undefined });
+    for (const wrapped of [literal, literal.readonly(), literal.nullable(), z.lazy(() => literal)]) {
+      expect(z.object({ a: wrapped }).parse({})).toStrictEqual({ a: undefined });
+    }
+    expect(z.object({ a: literal.optional() }).parse({})).toStrictEqual({});
+    expect(z.object({ a: literal.optional() }).parse({ a: undefined })).toStrictEqual({ a: undefined });
+    expect(z.tuple([literal]).parse([])).toStrictEqual([undefined]);
+  } finally {
+    z.config({ jitless: previous });
+  }
+});
+
+test("prefault preserves transformed undefined output", async () => {
+  const field = z
+    .string()
+    .transform(() => undefined)
+    .prefault("fallback");
+  expectTypeOf<z.output<typeof field>>().toEqualTypeOf<undefined>();
+  expect(field.parse(undefined)).toBeUndefined();
+  const schema = z.object({ a: field, optional: z.string().optional() });
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: undefined; optional?: string | undefined }>();
+  expect(schema.parse({})).toStrictEqual({ a: undefined });
+  expect(z.core.compileFn(schema)({})).toStrictEqual({ a: undefined });
+  expect(z.compile(schema).parse({})).toStrictEqual({ a: undefined });
+  expect(
+    await z
+      .object({
+        a: z
+          .string()
+          .transform(async () => undefined)
+          .prefault("fallback"),
+      })
+      .parseAsync({})
+  ).toStrictEqual({ a: undefined });
+  expect(
+    z
+      .object({
+        a: z
+          .string()
+          .prefault("fallback")
+          .transform(() => undefined),
+      })
+      .parse({})
+  ).toStrictEqual({ a: undefined });
+});
+
 test("basic prefault", () => {
   const a = z.prefault(z.string().trim(), "  default  ");
   expect(a).toBeInstanceOf(z.ZodPrefault);

package/src/v4/core/compile.ts

@@ -1270,9 +1270,9 @@ function generateObjectCheck(
   }
   // else: strip mode (no catchall) - unknown keys ignored, only include known keys
 
-  // Shape keys in declared order, then unknown keys in for...in order. A middle-rung key is included iff present on the input, else iff its output is not undefined.
+  // defaulted required outputs keep their keys even when undefined
   const outputVar = newVar(ctx);
-  const hasConditionalKeys = allKeys.some((k) => mayOutputUndefined(propShape[k]!) || dropsWhenAbsent(propShape[k]!));
+  const hasConditionalKeys = allKeys.some((k) => mayOmitUndefined(propShape[k]!) || dropsWhenAbsent(propShape[k]!));
 
   // Assert mode: every declared key is validated above, so the output literal and the unknown-key copy are pure waste. A `never` catchall already emitted its rejection loop; a schema catchall still has to validate the values it would otherwise have stored.
   if (!buildsValue) {
@@ -1301,7 +1301,7 @@ function generateObjectCheck(
       const out = propOutputs.get(k);
       if (dropsWhenAbsent(propShape[k]!)) {
         doc.write(`if (${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
-      } else if (mayOutputUndefined(propShape[k]!)) {
+      } else if (mayOmitUndefined(propShape[k]!)) {
         doc.write(`if (${out} !== undefined || ${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
       } else {
         doc.write(`${outputVar}[${kx}] = ${out};`);
@@ -1464,9 +1464,11 @@ function dropsWhenAbsent(schema: SomeType): boolean {
   return schema._zod.optin === "optional" && schema._zod.optout === "optional";
 }
 
-// Whether a schema's success-path output can be `undefined`. Object output
-// assembly gives such props the runtime's value-or-presence inclusion rule;
-// everything else keeps the unconditional object-literal slot.
+function mayOmitUndefined(schema: SomeType): boolean {
+  return (schema._zod.optin !== "defaulted" || schema._zod.optout === "optional") && mayOutputUndefined(schema);
+}
+
+// whether a schema's success-path output can be undefined
 function mayOutputUndefined(schema: SomeType): boolean {
   const def = schema._zod.def as {
     type: string;

package/src/v4/core/schemas.ts

@@ -1983,7 +1983,7 @@ function handlePropertyResult(
   }
 
   if (result.value === undefined) {
-    if (isPresent) {
+    if (isPresent || (optin === "defaulted" && !isOptionalOut)) {
       (final.value as any)[key] = undefined;
     }
   } else {
@@ -2314,16 +2314,16 @@ export const $ZodObjectJIT: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$
           doc.write(`
         if (${id}.issues.length) {${prefixStr(id, k)}
         }
-        
-        if (${id}.value === undefined) {
-          if (${isPresent}) {
-            newResult[${k}] = undefined;
-          }
-        } else {
+      `);
+          if (optin === "defaulted") {
+            doc.write(`newResult[${k}] = ${id}.value;`);
+          } else {
+            doc.write(`
+        if (${id}.value !== undefined || ${isPresent}) {
           newResult[${k}] = ${id}.value;
         }
-
       `);
+          }
         }
       }
 
@@ -4077,7 +4077,7 @@ export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodType
 }
 
 export interface $ZodPrefaultInternals<T extends SomeType = $ZodType>
-  extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
+  extends $ZodTypeInternals<core.output<T>, core.input<T> | undefined> {
   def: $ZodPrefaultDef<T>;
   optin: "defaulted";
   optout?: "optional" | undefined;

package/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 6,
-  patch: 1 as number,
+  patch: 2 as number,
 } as const;

package/src/v4/mini/schemas.ts

@@ -1597,7 +1597,7 @@ export const ZodMiniPrefault: core.$constructor<ZodMiniPrefault> = /*@__PURE__*/
 // @__NO_SIDE_EFFECTS__
 export function prefault<T extends SomeType>(
   innerType: T,
-  defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)
+  defaultValue: core.input<T> | (() => core.input<T>)
 ): ZodMiniPrefault<T> {
   return new ZodMiniPrefault({
     type: "prefault",

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

@@ -165,6 +165,28 @@ test("z.iso.duration", () => {
   expect(z.safeParse(b, d2).success).toEqual(false);
 });
 
+test("z.prefault preserves undefined output", async () => {
+  const field = z.prefault(z.union([z.string(), z.undefined()]), () => undefined);
+  const schema = z.object({ a: field });
+  expectTypeOf<z.output<typeof field>>().toEqualTypeOf<string | undefined>();
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: string | undefined }>();
+  expect(z.parse(schema, {})).toStrictEqual({ a: undefined });
+  expect(z.parse(schema, { a: undefined })).toStrictEqual({ a: undefined });
+  expect(z.parse(schema, { a: "value" })).toStrictEqual({ a: "value" });
+  expect(z.safeParse(schema, { a: 123 }).success).toBe(false);
+  expect(await z.parseAsync(schema, {})).toStrictEqual({ a: undefined });
+  expect(z.parse(z.object({ a: z.prefault(z.optional(z.string()), undefined) }), {})).toStrictEqual({ a: undefined });
+  const transformed = z.prefault(
+    z.pipe(
+      z.string(),
+      z.transform(() => undefined)
+    ),
+    "fallback"
+  );
+  expectTypeOf<z.output<typeof transformed>>().toEqualTypeOf<undefined>();
+  expect(z.parse(z.object({ a: transformed }), {})).toStrictEqual({ a: undefined });
+});
+
 test("z.undefined", () => {
   const a = z.undefined();
   expect(z.parse(a, undefined)).toEqual(undefined);

package/v4/core/compile.cjs

@@ -1010,9 +1010,9 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
         }
     }
     // else: strip mode (no catchall) - unknown keys ignored, only include known keys
-    // Shape keys in declared order, then unknown keys in for...in order. A middle-rung key is included iff present on the input, else iff its output is not undefined.
+    // defaulted required outputs keep their keys even when undefined
     const outputVar = newVar(ctx);
-    const hasConditionalKeys = allKeys.some((k) => mayOutputUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
+    const hasConditionalKeys = allKeys.some((k) => mayOmitUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
     // Assert mode: every declared key is validated above, so the output literal and the unknown-key copy are pure waste. A `never` catchall already emitted its rejection loop; a schema catchall still has to validate the values it would otherwise have stored.
     if (!buildsValue) {
         if (unknownKeysMode === "schema") {
@@ -1042,7 +1042,7 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
             if (dropsWhenAbsent(propShape[k])) {
                 doc.write(`if (${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
             }
-            else if (mayOutputUndefined(propShape[k])) {
+            else if (mayOmitUndefined(propShape[k])) {
                 doc.write(`if (${out} !== undefined || ${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
             }
             else {
@@ -1185,9 +1185,10 @@ function fastPathAcceptsAbsence(schema) {
 function dropsWhenAbsent(schema) {
     return schema._zod.optin === "optional" && schema._zod.optout === "optional";
 }
-// Whether a schema's success-path output can be `undefined`. Object output
-// assembly gives such props the runtime's value-or-presence inclusion rule;
-// everything else keeps the unconditional object-literal slot.
+function mayOmitUndefined(schema) {
+    return (schema._zod.optin !== "defaulted" || schema._zod.optout === "optional") && mayOutputUndefined(schema);
+}
+// whether a schema's success-path output can be undefined
 function mayOutputUndefined(schema) {
     const def = schema._zod.def;
     switch (def.type) {

package/v4/core/compile.js

@@ -979,9 +979,9 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
         }
     }
     // else: strip mode (no catchall) - unknown keys ignored, only include known keys
-    // Shape keys in declared order, then unknown keys in for...in order. A middle-rung key is included iff present on the input, else iff its output is not undefined.
+    // defaulted required outputs keep their keys even when undefined
     const outputVar = newVar(ctx);
-    const hasConditionalKeys = allKeys.some((k) => mayOutputUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
+    const hasConditionalKeys = allKeys.some((k) => mayOmitUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
     // Assert mode: every declared key is validated above, so the output literal and the unknown-key copy are pure waste. A `never` catchall already emitted its rejection loop; a schema catchall still has to validate the values it would otherwise have stored.
     if (!buildsValue) {
         if (unknownKeysMode === "schema") {
@@ -1011,7 +1011,7 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
             if (dropsWhenAbsent(propShape[k])) {
                 doc.write(`if (${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
             }
-            else if (mayOutputUndefined(propShape[k])) {
+            else if (mayOmitUndefined(propShape[k])) {
                 doc.write(`if (${out} !== undefined || ${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
             }
             else {
@@ -1154,9 +1154,10 @@ function fastPathAcceptsAbsence(schema) {
 function dropsWhenAbsent(schema) {
     return schema._zod.optin === "optional" && schema._zod.optout === "optional";
 }
-// Whether a schema's success-path output can be `undefined`. Object output
-// assembly gives such props the runtime's value-or-presence inclusion rule;
-// everything else keeps the unconditional object-literal slot.
+function mayOmitUndefined(schema) {
+    return (schema._zod.optin !== "defaulted" || schema._zod.optout === "optional") && mayOutputUndefined(schema);
+}
+// whether a schema's success-path output can be undefined
 function mayOutputUndefined(schema) {
     const def = schema._zod.def;
     switch (def.type) {

package/v4/core/schemas.cjs

@@ -911,7 +911,7 @@ function handlePropertyResult(result, final, key, input, optin, optout) {
         return;
     }
     if (result.value === undefined) {
-        if (isPresent) {
+        if (isPresent || (optin === "defaulted" && !isOptionalOut)) {
             final.value[key] = undefined;
         }
     }
@@ -1166,16 +1166,17 @@ exports.$ZodObjectJIT = core.$constructor("$ZodObjectJIT", (inst, def) => {
                 doc.write(`
         if (${id}.issues.length) {${prefixStr(id, k)}
         }
-        
-        if (${id}.value === undefined) {
-          if (${isPresent}) {
-            newResult[${k}] = undefined;
-          }
-        } else {
+      `);
+                if (optin === "defaulted") {
+                    doc.write(`newResult[${k}] = ${id}.value;`);
+                }
+                else {
+                    doc.write(`
+        if (${id}.value !== undefined || ${isPresent}) {
           newResult[${k}] = ${id}.value;
         }
-
       `);
+                }
             }
         }
         doc.write(`payload.value = newResult;`);

package/v4/core/schemas.d.cts

@@ -1010,7 +1010,7 @@ export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodType
     /** The default value. May be a getter. */
     defaultValue: core.input<T>;
 }
-export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
+export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T> | undefined> {
     def: $ZodPrefaultDef<T>;
     optin: "defaulted";
     optout?: "optional" | undefined;

package/v4/core/schemas.d.ts

@@ -1010,7 +1010,7 @@ export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodType
     /** The default value. May be a getter. */
     defaultValue: core.input<T>;
 }
-export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
+export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T> | undefined> {
     def: $ZodPrefaultDef<T>;
     optin: "defaulted";
     optout?: "optional" | undefined;

package/v4/core/schemas.js

@@ -869,7 +869,7 @@ function handlePropertyResult(result, final, key, input, optin, optout) {
         return;
     }
     if (result.value === undefined) {
-        if (isPresent) {
+        if (isPresent || (optin === "defaulted" && !isOptionalOut)) {
             final.value[key] = undefined;
         }
     }
@@ -1124,16 +1124,17 @@ export const $ZodObjectJIT = /*@__PURE__*/ core.$constructor("$ZodObjectJIT", (i
                 doc.write(`
         if (${id}.issues.length) {${prefixStr(id, k)}
         }
-        
-        if (${id}.value === undefined) {
-          if (${isPresent}) {
-            newResult[${k}] = undefined;
-          }
-        } else {
+      `);
+                if (optin === "defaulted") {
+                    doc.write(`newResult[${k}] = ${id}.value;`);
+                }
+                else {
+                    doc.write(`
+        if (${id}.value !== undefined || ${isPresent}) {
           newResult[${k}] = ${id}.value;
         }
-
       `);
+                }
             }
         }
         doc.write(`payload.value = newResult;`);

package/v4/core/versions.cjs

@@ -4,7 +4,7 @@ exports.version = void 0;
 exports.version = {
     major: 4,
     minor: 6,
-    patch: 1,
+    patch: 2,
 };
 
 // seal-cjs-exports

package/v4/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
     minor: 6,
-    patch: 1,
+    patch: 2,
 };

package/v4/mini/schemas.d.cts

@@ -367,7 +367,7 @@ export declare function _default<T extends SomeType>(innerType: T, defaultValue:
 export interface ZodMiniPrefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPrefaultInternals<T>> {
 }
 export declare const ZodMiniPrefault: core.$constructor<ZodMiniPrefault>;
-export declare function prefault<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)): ZodMiniPrefault<T>;
+export declare function prefault<T extends SomeType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodMiniPrefault<T>;
 export interface ZodMiniNonOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodNonOptionalInternals<T>> {
 }
 export declare const ZodMiniNonOptional: core.$constructor<ZodMiniNonOptional>;

package/v4/mini/schemas.d.ts

@@ -367,7 +367,7 @@ export declare function _default<T extends SomeType>(innerType: T, defaultValue:
 export interface ZodMiniPrefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPrefaultInternals<T>> {
 }
 export declare const ZodMiniPrefault: core.$constructor<ZodMiniPrefault>;
-export declare function prefault<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)): ZodMiniPrefault<T>;
+export declare function prefault<T extends SomeType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodMiniPrefault<T>;
 export interface ZodMiniNonOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodNonOptionalInternals<T>> {
 }
 export declare const ZodMiniNonOptional: core.$constructor<ZodMiniNonOptional>;