zod 4.4.0 → 4.4.1

package/package.json

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

package/src/v3/tests/all-errors.test.ts

@@ -16,7 +16,7 @@ type TestFormErrors = z.inferFlattenedErrors<typeof Test>;
 test("default flattened errors type inference", () => {
   type TestTypeErrors = {
     formErrors: string[];
-    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] | undefined };
+    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] };
   };
 
   util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(true);
@@ -28,7 +28,7 @@ test("custom flattened errors type inference", () => {
   type TestTypeErrors = {
     formErrors: ErrorType[];
     fieldErrors: {
-      [P in keyof z.TypeOf<typeof Test>]?: ErrorType[] | undefined;
+      [P in keyof z.TypeOf<typeof Test>]?: ErrorType[];
     };
   };
 
@@ -40,7 +40,7 @@ test("custom flattened errors type inference", () => {
 test("form errors type inference", () => {
   type TestTypeErrors = {
     formErrors: string[];
-    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] | undefined };
+    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] };
   };
 
   util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(true);

package/src/v3/tests/object.test.ts

@@ -212,9 +212,9 @@ test("inferred merged object type with optional properties", async () => {
     .object({ a: z.string(), b: z.string().optional() })
     .merge(z.object({ a: z.string().optional(), b: z.string() }));
   type Merged = z.infer<typeof Merged>;
-  util.assertEqual<Merged, { a?: string; b: string }>(true);
+  util.assertEqual<Merged, { a?: string | undefined; b: string }>(true);
   // todo
-  // util.assertEqual<Merged, { a?: string; b: string }>(true);
+  // util.assertEqual<Merged, { a?: string | undefined; b: string }>(true);
 });
 
 test("inferred unioned object type with optional properties", async () => {
@@ -223,7 +223,7 @@ test("inferred unioned object type with optional properties", async () => {
     z.object({ a: z.string().optional(), b: z.string() }),
   ]);
   type Unioned = z.infer<typeof Unioned>;
-  util.assertEqual<Unioned, { a: string; b?: string } | { a?: string; b: string }>(true);
+  util.assertEqual<Unioned, { a: string; b?: string | undefined } | { a?: string | undefined; b: string }>(true);
 });
 
 test("inferred enum type", async () => {
@@ -245,13 +245,13 @@ test("inferred enum type", async () => {
 test("inferred partial object type with optional properties", async () => {
   const Partial = z.object({ a: z.string(), b: z.string().optional() }).partial();
   type Partial = z.infer<typeof Partial>;
-  util.assertEqual<Partial, { a?: string; b?: string }>(true);
+  util.assertEqual<Partial, { a?: string | undefined; b?: string | undefined }>(true);
 });
 
 test("inferred picked object type with optional properties", async () => {
   const Picked = z.object({ a: z.string(), b: z.string().optional() }).pick({ b: true });
   type Picked = z.infer<typeof Picked>;
-  util.assertEqual<Picked, { b?: string }>(true);
+  util.assertEqual<Picked, { b?: string | undefined }>(true);
 });
 
 test("inferred type for unknown/any keys", () => {

package/src/v3/tests/partials.test.ts

@@ -21,7 +21,7 @@ test("shallow inference", () => {
     name?: string | undefined;
     age?: number | undefined;
     outer?: { inner: string } | undefined;
-    array?: { asdf: string }[];
+    array?: { asdf: string }[] | undefined;
   };
   util.assertEqual<shallow, correct>(true);
 });
@@ -41,7 +41,7 @@ test("deep partial inference", () => {
   asdf.parse("asdf");
   type deep = z.infer<typeof deep>;
   type correct = {
-    array?: { asdf?: string }[];
+    array?: { asdf?: string | undefined }[] | undefined;
     name?: string | undefined;
     age?: number | undefined;
     outer?: { inner?: string | undefined } | undefined;
@@ -118,7 +118,7 @@ test("deep partial inference", () => {
           asdf?: string | undefined;
         }[]
       | undefined;
-    tuple?: [{ value?: string }] | undefined;
+    tuple?: [{ value?: string | undefined }] | undefined;
   };
   util.assertEqual<expected, partialed>(true);
 });

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

@@ -282,11 +282,10 @@ test("tuple result is dense when optional precedes a default", () => {
   expect(1 in out && 3 in out).toEqual(true);
 });
 
-test("tuple breaks and truncates on first absent-optional rejection", () => {
-  // An `.optional()` slot that rejects `undefined` (e.g. via a refine) past
-  // optStart must (a) swallow the issue, (b) truncate the result there, and
-  // (c) NOT materialize any later defaults — otherwise the parser would
-  // happily fill in slots after a slot it just decided was missing/invalid.
+test("tuple truncates absent optional rejections only when the output tail is optional", () => {
+  // An absent optional-output slot can only be swallowed when every later
+  // output slot is optional too. If a later default would make the output tail
+  // required, truncating would violate the tuple's output type.
   const refusesUndefined = z
     .string()
     .optional()
@@ -294,13 +293,15 @@ test("tuple breaks and truncates on first absent-optional rejection", () => {
 
   const trailingDefault = z.tuple([z.string(), refusesUndefined, z.string().default("d")]);
   const r1 = trailingDefault.safeParse(["alpha"]);
-  expect(r1.success).toBe(true);
-  expect(r1.data).toEqual(["alpha"]);
+  expect(r1.success).toBe(false);
+  expect(r1.error!.issues[0].path).toEqual([1]);
 
-  // Optional slots BEFORE the rejected one collapse away with the truncate
-  // (mirrors the trailing-trim behaviour for absent optionals).
+  // Optional slots BEFORE the rejected one still cannot hide a later required
+  // output slot.
   const beforeReject = z.tuple([z.string(), z.string().optional(), refusesUndefined, z.string().default("d")]);
-  expect(beforeReject.safeParse(["alpha"]).data).toEqual(["alpha"]);
+  const r2 = beforeReject.safeParse(["alpha"]);
+  expect(r2.success).toBe(false);
+  expect(r2.error!.issues[0].path).toEqual([2]);
 
   // No default after — truncate still applies, no spurious issue surfaces.
   const noTrailingDefault = z.tuple([z.string(), refusesUndefined]);
@@ -309,7 +310,7 @@ test("tuple breaks and truncates on first absent-optional rejection", () => {
   expect(r3.data).toEqual(["alpha"]);
 });
 
-test("tuple breaks on absent-optional rejection under async parse", async () => {
+test("tuple rejects absent optional before required output under async parse", async () => {
   const refusesUndefined = z
     .string()
     .optional()
@@ -317,8 +318,24 @@ test("tuple breaks on absent-optional rejection under async parse", async () =>
 
   const schema = z.tuple([z.string(), refusesUndefined, z.string().default("d")]);
   const r = await schema.safeParseAsync(["alpha"]);
-  expect(r.success).toBe(true);
-  expect(r.data).toEqual(["alpha"]);
+  expect(r.success).toBe(false);
+  expect(r.error!.issues[0].path).toEqual([1]);
+});
+
+test("tuple rejects absent exact optional before defaulted output", () => {
+  const schema = z.tuple([z.string(), z.string().exactOptional(), z.string().default("fallback")]);
+  expectTypeOf<typeof schema._output>().toEqualTypeOf<[string, string, string]>();
+
+  const missingExact = schema.safeParse(["alpha"]);
+  expect(missingExact.success).toBe(false);
+  expect(missingExact.error!.issues[0].path).toEqual([1]);
+
+  expect(schema.parse(["alpha", "bravo"])).toEqual(["alpha", "bravo", "fallback"]);
+  expect(schema.safeParse(["alpha", undefined]).success).toBe(false);
+
+  // With no later required output slot, exact optional still behaves like an
+  // omitted tuple tail and truncates cleanly.
+  expect(z.tuple([z.string(), z.string().exactOptional(), z.string().optional()]).parse(["alpha"])).toEqual(["alpha"]);
 });
 
 test("tuple preserves explicit undefined inside input even for optional-out schemas", () => {

package/src/v4/core/schemas.ts

@@ -2677,14 +2677,14 @@ export const $ZodTuple: core.$constructor<$ZodTuple> = /*@__PURE__*/ core.$const
     payload.value = [];
     const proms: Promise<any>[] = [];
 
-    const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
-    const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
+    const optinStart = getTupleOptStart(items, "optin");
+    const optoutStart = getTupleOptStart(items, "optout");
 
     if (!def.rest) {
-      if (input.length < optStart) {
+      if (input.length < optinStart) {
         payload.issues.push({
           code: "too_small",
-          minimum: optStart,
+          minimum: optinStart,
           inclusive: true,
           input,
           inst,
@@ -2706,9 +2706,8 @@ export const $ZodTuple: core.$constructor<$ZodTuple> = /*@__PURE__*/ core.$const
 
     // Run every item in parallel, collecting results into an indexed
     // array. The post-processing in `handleTupleResults` walks them in
-    // order so it can break on the first absent-optional error: once a
-    // slot rejects `undefined`, the tuple is malformed at that index and
-    // any later defaults must NOT fire.
+    // order so it can decide whether an absent optional-output error can
+    // truncate the tail or must be reported to preserve required output.
     const itemResults: ParsePayload[] = new Array(items.length);
     for (let i = 0; i < items.length; i++) {
       const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx);
@@ -2737,11 +2736,20 @@ export const $ZodTuple: core.$constructor<$ZodTuple> = /*@__PURE__*/ core.$const
       }
     }
 
-    if (proms.length) return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input));
-    return handleTupleResults(itemResults, payload, items, input);
+    if (proms.length) {
+      return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
+    }
+    return handleTupleResults(itemResults, payload, items, input, optoutStart);
   };
 });
 
+function getTupleOptStart(items: readonly $ZodType[], key: "optin" | "optout") {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (items[i]._zod[key] !== "optional") return i + 1;
+  }
+  return 0;
+}
+
 function handleTupleResult(result: ParsePayload, final: ParsePayload<any[]>, index: number) {
   if (result.issues.length) {
     final.issues.push(...util.prefixIssues(index, result.issues));
@@ -2749,30 +2757,21 @@ function handleTupleResult(result: ParsePayload, final: ParsePayload<any[]>, ind
   final.value[index] = result.value;
 }
 
-// Post-processes the per-item results collected by the tuple parser.
-// `optStart` is intentionally NOT consulted here — it's an input-length
-// concern handled by the `too_small` precheck at the top of parse. This
-// step is purely about output shaping, which is governed by `optout`:
-// a `.default()` tail item sits inside the optStart region (its `optin`
-// is optional), but it must NOT be dropped or have its errors swallowed
-// because it materializes a defined value (`optout !== "optional"`).
 function handleTupleResults(
   itemResults: ParsePayload[],
   final: ParsePayload<any[]>,
   items: readonly $ZodType[],
-  input: unknown[]
+  input: unknown[],
+  optoutStart: number
 ) {
   // Walk results in order. Mirror $ZodObject's swallow-on-absent-optional
-  // rule, but for a tuple "absent" is a positional concept: once we
-  // swallow at index k, every later index is also absent-or-corrupted,
-  // so we truncate the result there and stop processing — including
-  // skipping any later defaults.
+  // rule, but only after `optoutStart`: the first index where the output
+  // tuple tail can be absent.
   for (let i = 0; i < items.length; i++) {
     const r = itemResults[i];
-    const isOptionalOut = items[i]._zod.optout === "optional";
     const isPresent = i < input.length;
     if (r.issues.length) {
-      if (isOptionalOut && !isPresent) {
+      if (!isPresent && i >= optoutStart) {
         final.value.length = i;
         break;
       }

package/src/v4/core/versions.ts

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

package/v4/core/schemas.cjs

@@ -1344,13 +1344,13 @@ exports.$ZodTuple = core.$constructor("$ZodTuple", (inst, def) => {
         }
         payload.value = [];
         const proms = [];
-        const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
-        const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
+        const optinStart = getTupleOptStart(items, "optin");
+        const optoutStart = getTupleOptStart(items, "optout");
         if (!def.rest) {
-            if (input.length < optStart) {
+            if (input.length < optinStart) {
                 payload.issues.push({
                     code: "too_small",
-                    minimum: optStart,
+                    minimum: optinStart,
                     inclusive: true,
                     input,
                     inst,
@@ -1371,9 +1371,8 @@ exports.$ZodTuple = core.$constructor("$ZodTuple", (inst, def) => {
         }
         // Run every item in parallel, collecting results into an indexed
         // array. The post-processing in `handleTupleResults` walks them in
-        // order so it can break on the first absent-optional error: once a
-        // slot rejects `undefined`, the tuple is malformed at that index and
-        // any later defaults must NOT fire.
+        // order so it can decide whether an absent optional-output error can
+        // truncate the tail or must be reported to preserve required output.
         const itemResults = new Array(items.length);
         for (let i = 0; i < items.length; i++) {
             const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx);
@@ -1400,36 +1399,34 @@ exports.$ZodTuple = core.$constructor("$ZodTuple", (inst, def) => {
                 }
             }
         }
-        if (proms.length)
-            return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input));
-        return handleTupleResults(itemResults, payload, items, input);
+        if (proms.length) {
+            return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
+        }
+        return handleTupleResults(itemResults, payload, items, input, optoutStart);
     };
 });
+function getTupleOptStart(items, key) {
+    for (let i = items.length - 1; i >= 0; i--) {
+        if (items[i]._zod[key] !== "optional")
+            return i + 1;
+    }
+    return 0;
+}
 function handleTupleResult(result, final, index) {
     if (result.issues.length) {
         final.issues.push(...util.prefixIssues(index, result.issues));
     }
     final.value[index] = result.value;
 }
-// Post-processes the per-item results collected by the tuple parser.
-// `optStart` is intentionally NOT consulted here — it's an input-length
-// concern handled by the `too_small` precheck at the top of parse. This
-// step is purely about output shaping, which is governed by `optout`:
-// a `.default()` tail item sits inside the optStart region (its `optin`
-// is optional), but it must NOT be dropped or have its errors swallowed
-// because it materializes a defined value (`optout !== "optional"`).
-function handleTupleResults(itemResults, final, items, input) {
+function handleTupleResults(itemResults, final, items, input, optoutStart) {
     // Walk results in order. Mirror $ZodObject's swallow-on-absent-optional
-    // rule, but for a tuple "absent" is a positional concept: once we
-    // swallow at index k, every later index is also absent-or-corrupted,
-    // so we truncate the result there and stop processing — including
-    // skipping any later defaults.
+    // rule, but only after `optoutStart`: the first index where the output
+    // tuple tail can be absent.
     for (let i = 0; i < items.length; i++) {
         const r = itemResults[i];
-        const isOptionalOut = items[i]._zod.optout === "optional";
         const isPresent = i < input.length;
         if (r.issues.length) {
-            if (isOptionalOut && !isPresent) {
+            if (!isPresent && i >= optoutStart) {
                 final.value.length = i;
                 break;
             }

package/v4/core/schemas.js

@@ -1313,13 +1313,13 @@ export const $ZodTuple = /*@__PURE__*/ core.$constructor("$ZodTuple", (inst, def
         }
         payload.value = [];
         const proms = [];
-        const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
-        const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
+        const optinStart = getTupleOptStart(items, "optin");
+        const optoutStart = getTupleOptStart(items, "optout");
         if (!def.rest) {
-            if (input.length < optStart) {
+            if (input.length < optinStart) {
                 payload.issues.push({
                     code: "too_small",
-                    minimum: optStart,
+                    minimum: optinStart,
                     inclusive: true,
                     input,
                     inst,
@@ -1340,9 +1340,8 @@ export const $ZodTuple = /*@__PURE__*/ core.$constructor("$ZodTuple", (inst, def
         }
         // Run every item in parallel, collecting results into an indexed
         // array. The post-processing in `handleTupleResults` walks them in
-        // order so it can break on the first absent-optional error: once a
-        // slot rejects `undefined`, the tuple is malformed at that index and
-        // any later defaults must NOT fire.
+        // order so it can decide whether an absent optional-output error can
+        // truncate the tail or must be reported to preserve required output.
         const itemResults = new Array(items.length);
         for (let i = 0; i < items.length; i++) {
             const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx);
@@ -1369,36 +1368,34 @@ export const $ZodTuple = /*@__PURE__*/ core.$constructor("$ZodTuple", (inst, def
                 }
             }
         }
-        if (proms.length)
-            return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input));
-        return handleTupleResults(itemResults, payload, items, input);
+        if (proms.length) {
+            return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
+        }
+        return handleTupleResults(itemResults, payload, items, input, optoutStart);
     };
 });
+function getTupleOptStart(items, key) {
+    for (let i = items.length - 1; i >= 0; i--) {
+        if (items[i]._zod[key] !== "optional")
+            return i + 1;
+    }
+    return 0;
+}
 function handleTupleResult(result, final, index) {
     if (result.issues.length) {
         final.issues.push(...util.prefixIssues(index, result.issues));
     }
     final.value[index] = result.value;
 }
-// Post-processes the per-item results collected by the tuple parser.
-// `optStart` is intentionally NOT consulted here — it's an input-length
-// concern handled by the `too_small` precheck at the top of parse. This
-// step is purely about output shaping, which is governed by `optout`:
-// a `.default()` tail item sits inside the optStart region (its `optin`
-// is optional), but it must NOT be dropped or have its errors swallowed
-// because it materializes a defined value (`optout !== "optional"`).
-function handleTupleResults(itemResults, final, items, input) {
+function handleTupleResults(itemResults, final, items, input, optoutStart) {
     // Walk results in order. Mirror $ZodObject's swallow-on-absent-optional
-    // rule, but for a tuple "absent" is a positional concept: once we
-    // swallow at index k, every later index is also absent-or-corrupted,
-    // so we truncate the result there and stop processing — including
-    // skipping any later defaults.
+    // rule, but only after `optoutStart`: the first index where the output
+    // tuple tail can be absent.
     for (let i = 0; i < items.length; i++) {
         const r = itemResults[i];
-        const isOptionalOut = items[i]._zod.optout === "optional";
         const isPresent = i < input.length;
         if (r.issues.length) {
-            if (isOptionalOut && !isPresent) {
+            if (!isPresent && i >= optoutStart) {
                 final.value.length = i;
                 break;
             }

package/v4/core/versions.cjs

@@ -4,5 +4,5 @@ exports.version = void 0;
 exports.version = {
     major: 4,
     minor: 4,
-    patch: 0,
+    patch: 1,
 };

package/v4/core/versions.js

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