zod 4.4.0 → 4.4.2

package/README.md

@@ -31,23 +31,6 @@
 <br/>
 <br/>
 
-<h2 align="center">Featured sponsor: Jazz</h2>
-
-<div align="center">
-  <a href="https://jazz.tools/?utm_source=zod">
-    <picture width="85%" >
-      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png">
-      <img alt="jazz logo" src="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png" width="85%">
-    </picture>
-  </a>
-  <br/>
-  <p><sub>Learn more about <a target="_blank" rel="noopener noreferrer" href="mailto:sponsorship@colinhacks.com">featured sponsorships</a></sub></p>
-</div>
-
-<br/>
-<br/>
-<br/>
-
 ### [Read the docs →](https://zod.dev/api)
 
 <br/>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.4.0",
+  "version": "4.4.2",
   "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/schemas.ts

@@ -1617,7 +1617,7 @@ export const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion> = /
 );
 
 export function discriminatedUnion<
-  Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]],
+  Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]],
   Disc extends string,
 >(
   discriminator: Disc,
@@ -2361,6 +2361,22 @@ export function invertCodec<A extends core.SomeType, B extends core.SomeType>(co
   }) as any;
 }
 
+// ZodPreprocess
+export interface ZodPreprocess<B extends core.SomeType = core.$ZodType>
+  extends ZodPipe<core.$ZodTransform, B>,
+    core.$ZodPreprocess<B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _zod: core.$ZodPreprocessInternals<B>;
+  def: core.$ZodPreprocessDef<B>;
+}
+export const ZodPreprocess: core.$constructor<ZodPreprocess> = /*@__PURE__*/ core.$constructor(
+  "ZodPreprocess",
+  (inst, def) => {
+    ZodPipe.init(inst, def);
+    core.$ZodPreprocess.init(inst, def);
+  }
+);
+
 // ZodReadonly
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType>
   extends _ZodType<core.$ZodReadonlyInternals<T>>,
@@ -2645,6 +2661,10 @@ export function json(params?: string | core.$ZodCustomParams): ZodJSONSchema {
 export function preprocess<A, U extends core.SomeType, B = unknown>(
   fn: (arg: B, ctx: core.$RefinementCtx) => A,
   schema: U
-): ZodPipe<ZodTransform<A, B>, U> {
-  return pipe(transform(fn as any), schema as any) as any;
+): ZodPreprocess<U> {
+  return new ZodPreprocess({
+    type: "pipe",
+    in: transform(fn as any) as any as core.$ZodTransform,
+    out: schema as any as core.$ZodType,
+  }) as any;
 }

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

@@ -143,6 +143,12 @@ test("assignability", () => {
   z.unknown().pipe(z.number()) satisfies z.core.$ZodPipe;
   z.unknown().pipe(z.number()) satisfies z.ZodPipe;
 
+  // $ZodPreprocess
+  z.preprocess((v) => v, z.number()) satisfies z.core.$ZodPreprocess;
+  z.preprocess((v) => v, z.number()) satisfies z.ZodPreprocess;
+  z.preprocess((v) => v, z.number()) satisfies z.core.$ZodPipe<z.core.$ZodTransform, z.ZodNumber>;
+  z.preprocess((v) => v, z.number()) satisfies z.ZodPipe<z.core.$ZodTransform, z.ZodNumber>;
+
   // $ZodSuccess
   z.success(z.string()) satisfies z.core.$ZodSuccess;
   z.success(z.string()) satisfies z.ZodSuccess;

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

@@ -264,6 +264,9 @@ test("valid discriminator value, invalid data", () => {
 });
 
 test("wrong schema - missing discriminator", () => {
+  // @ts-expect-error missing discriminator property
+  z.discriminatedUnion("type", [z.object({ value: z.string() })]);
+
   try {
     z.discriminatedUnion("type", [
       z.object({ type: z.literal("a"), a: z.string() }),

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

@@ -0,0 +1,26 @@
+import { expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("ZodPreprocess<B> assignable to ZodPipe<$ZodTransform, B>", () => {
+  const pre = z.preprocess((v) => v, z.string().optional());
+  const _asPipe: z.ZodPipe<z.core.$ZodTransform, z.ZodOptional<z.ZodString>> = pre;
+  const _asCorePipe: z.core.$ZodPipe<z.core.$ZodTransform, z.ZodOptional<z.ZodString>> = pre;
+  expectTypeOf(_asPipe).toMatchTypeOf<z.ZodPipe>();
+  expectTypeOf(_asCorePipe).toMatchTypeOf<z.core.$ZodPipe>();
+});
+
+test("ZodPreprocess optin/optout defer to B", () => {
+  const optionalInside = z.preprocess((v) => v, z.string().optional());
+  expectTypeOf<(typeof optionalInside)["_zod"]["optin"]>().toEqualTypeOf<"optional">();
+  expectTypeOf<(typeof optionalInside)["_zod"]["optout"]>().toEqualTypeOf<"optional">();
+
+  const required = z.preprocess((v) => v, z.string());
+  expectTypeOf<(typeof required)["_zod"]["optin"]>().toEqualTypeOf<"optional" | undefined>();
+  expectTypeOf<(typeof required)["_zod"]["optout"]>().toEqualTypeOf<"optional" | undefined>();
+});
+
+test("ZodPreprocess input/output inference", () => {
+  const pre = z.preprocess((v) => v, z.number().optional());
+  expectTypeOf<z.output<typeof pre>>().toEqualTypeOf<number | undefined>();
+  expectTypeOf<z.input<typeof pre>>().toEqualTypeOf<unknown>();
+});

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

@@ -280,3 +280,47 @@ test("perform transform with non-fatal issues", () => {
     ]]
   `);
 });
+
+// https://github.com/colinhacks/zod/issues/5917
+test("optional propagates through preprocess inside object", () => {
+  const outer = z.object({ x: z.preprocess((v) => v, z.number()).optional() });
+  const inner = z.object({ x: z.preprocess((v) => v, z.number().optional()) });
+
+  expect(outer.safeParse({}).success).toBe(true);
+  expect(inner.safeParse({}).success).toBe(true);
+
+  expect(outer.safeParse({ x: 1 })).toEqual({ success: true, data: { x: 1 } });
+  expect(inner.safeParse({ x: 1 })).toEqual({ success: true, data: { x: 1 } });
+
+  expect(inner._zod.def.shape.x._zod.optin).toBe("optional");
+  expect(inner._zod.def.shape.x._zod.optout).toBe("optional");
+});
+
+test("preprocess is a structural subtype of ZodPipe", () => {
+  const schema = z.preprocess((v) => v, z.string());
+  expect(schema).toBeInstanceOf(z.ZodPipe);
+  expect(schema).toBeInstanceOf(z.ZodPreprocess);
+  expect(schema._zod.def.type).toBe("pipe");
+});
+
+test("preprocess does not propagate values/propValues from inner schema", () => {
+  const inner = z.preprocess((v) => v, z.literal("test"));
+  expect(inner._zod.values).toBeUndefined();
+  expect(inner._zod.propValues).toBeUndefined();
+});
+
+test("preprocess as discriminator throws at construction (no propValues to inherit)", () => {
+  const schema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.preprocess((v: any) => String(v).toUpperCase(), z.literal("A")), a: z.string() }),
+    z.object({ kind: z.preprocess((v: any) => String(v).toUpperCase(), z.literal("B")), b: z.number() }),
+  ]);
+  expect(() => schema.parse({ kind: "a", a: "x" })).toThrow(/Invalid discriminated union option/);
+});
+
+test("preprocess as record key does not restrict accepted keys", () => {
+  const schema = z.record(
+    z.preprocess((v: any) => String(v).toLowerCase(), z.enum(["a", "b"])),
+    z.string()
+  );
+  expect(schema.safeParse({ A: "x", B: "y" })).toEqual({ success: true, data: { a: "x", b: "y" } });
+});

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

@@ -2896,6 +2896,28 @@ test("use output type for preprocess", () => {
   `);
 });
 
+test("strip output-side examples from input JSON schema for codec", () => {
+  const codec = z
+    .codec(z.string(), z.number(), { decode: (s) => Number(s), encode: (n) => String(n) })
+    .meta({ examples: [42] });
+
+  expect(z.toJSONSchema(codec, { io: "input" })).toMatchInlineSnapshot(`
+    {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "type": "string",
+    }
+  `);
+  expect(z.toJSONSchema(codec, { io: "output" })).toMatchInlineSnapshot(`
+    {
+      "$schema": "https://json-schema.org/draft/2020-12/schema",
+      "examples": [
+        42,
+      ],
+      "type": "number",
+    }
+  `);
+});
+
 // test("isTransforming", () => {
 //   const tx = z.core.isTransforming;
 //   expect(tx(z.string())).toEqual(false);

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/api.ts

@@ -1207,17 +1207,19 @@ export function _xor<const T extends readonly schemas.$ZodObject[]>(
 }
 
 // ZodDiscriminatedUnion
-export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
+export interface $ZodTypeDiscriminableInternals<Disc extends string = string>
+  extends schemas.$ZodTypeInternals<unknown, { [K in Disc]?: unknown }> {
   propValues: util.PropValues;
 }
 
-export interface $ZodTypeDiscriminable extends schemas.$ZodType {
-  _zod: $ZodTypeDiscriminableInternals;
+export interface $ZodTypeDiscriminable<Disc extends string = string> extends schemas.$ZodType {
+  _zod: $ZodTypeDiscriminableInternals<Disc>;
 }
+
 export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
 // @__NO_SIDE_EFFECTS__
 export function _discriminatedUnion<
-  Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]],
+  Types extends [$ZodTypeDiscriminable<Disc>, ...$ZodTypeDiscriminable<Disc>[]],
   Disc extends string,
 >(
   Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>,

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

@@ -525,7 +525,8 @@ export const catchProcessor: Processor<schemas.$ZodCatch> = (schema, ctx, json,
 
 export const pipeProcessor: Processor<schemas.$ZodPipe> = (schema, ctx, _json, params) => {
   const def = schema._zod.def as schemas.$ZodPipeDef;
-  const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
+  const inIsTransform = def.in._zod.traits.has("$ZodTransform");
+  const innerType = ctx.io === "input" ? (inIsTransform ? def.out : def.in) : def.out;
   process(innerType, ctx as any, params);
   const seen = ctx.seen.get(schema)!;
   seen.ref = innerType;

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;
       }
@@ -4119,6 +4118,37 @@ function handleCodecTxResult(left: ParsePayload, value: any, nextSchema: SomeTyp
   return nextSchema._zod.run({ value, issues: left.issues }, ctx);
 }
 
+/////////////////////////////////////////////////
+/////////////////////////////////////////////////
+//////////                             //////////
+//////////      $ZodPreprocess         //////////
+//////////                             //////////
+/////////////////////////////////////////////////
+/////////////////////////////////////////////////
+export interface $ZodPreprocessDef<B extends SomeType = $ZodType> extends $ZodPipeDef<$ZodTransform, B> {
+  in: $ZodTransform;
+  out: B;
+}
+
+export interface $ZodPreprocessInternals<B extends SomeType = $ZodType> extends $ZodPipeInternals<$ZodTransform, B> {
+  def: $ZodPreprocessDef<B>;
+  optin: B["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+}
+
+export interface $ZodPreprocess<B extends SomeType = $ZodType> extends $ZodPipe<$ZodTransform, B> {
+  _zod: $ZodPreprocessInternals<B>;
+}
+
+export const $ZodPreprocess: core.$constructor<$ZodPreprocess> = /*@__PURE__*/ core.$constructor(
+  "$ZodPreprocess",
+  (inst, def) => {
+    $ZodPipe.init(inst, def);
+    util.defineLazy(inst._zod, "optin", () => def.out._zod.optin);
+    util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+  }
+);
+
 ////////////////////////////////////////////
 ////////////////////////////////////////////
 //////////                        //////////

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

@@ -561,6 +561,7 @@ function isTransforming(
     return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
   }
   if (def.type === "pipe") {
+    if (_schema._zod.traits.has("$ZodCodec")) return true;
     return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
   }
 

package/src/v4/core/versions.ts

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

package/src/v4/mini/schemas.ts

@@ -1083,7 +1083,7 @@ export const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUn
 
 // @__NO_SIDE_EFFECTS__
 export function discriminatedUnion<
-  Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]],
+  Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]],
   Disc extends string,
 >(
   discriminator: Disc,

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

@@ -247,6 +247,11 @@ test("z.union([]) / z.xor([]) / z.discriminatedUnion(_, []) construct and reject
   }
 });
 
+test("z.discriminatedUnion rejects object options missing the discriminator at type level", () => {
+  // @ts-expect-error missing discriminator property
+  z.discriminatedUnion("type", [z.object({ value: z.string() })]);
+});
+
 test("z.intersection", () => {
   const a = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
   expect(z.parse(a, { a: "hello", b: 123 })).toEqual({ a: "hello", b: 123 });

package/v4/classic/schemas.cjs

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZodLiteral = exports.ZodEnum = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = exports.ZodIntersection = exports.ZodDiscriminatedUnion = exports.ZodXor = exports.ZodUnion = exports.ZodObject = exports.ZodArray = exports.ZodDate = exports.ZodVoid = exports.ZodNever = exports.ZodUnknown = exports.ZodAny = exports.ZodNull = exports.ZodUndefined = exports.ZodSymbol = exports.ZodBigIntFormat = exports.ZodBigInt = exports.ZodBoolean = exports.ZodNumberFormat = exports.ZodNumber = exports.ZodCustomStringFormat = exports.ZodJWT = exports.ZodE164 = exports.ZodBase64URL = exports.ZodBase64 = exports.ZodCIDRv6 = exports.ZodCIDRv4 = exports.ZodIPv6 = exports.ZodMAC = exports.ZodIPv4 = exports.ZodKSUID = exports.ZodXID = exports.ZodULID = exports.ZodCUID2 = exports.ZodCUID = exports.ZodNanoID = exports.ZodEmoji = exports.ZodURL = exports.ZodUUID = exports.ZodGUID = exports.ZodEmail = exports.ZodStringFormat = exports.ZodString = exports._ZodString = exports.ZodType = void 0;
-exports.stringbool = exports.meta = exports.describe = exports.ZodCustom = exports.ZodFunction = exports.ZodPromise = exports.ZodLazy = exports.ZodTemplateLiteral = exports.ZodReadonly = exports.ZodCodec = exports.ZodPipe = exports.ZodNaN = exports.ZodCatch = exports.ZodSuccess = exports.ZodNonOptional = exports.ZodPrefault = exports.ZodDefault = exports.ZodNullable = exports.ZodExactOptional = exports.ZodOptional = exports.ZodTransform = exports.ZodFile = void 0;
+exports.stringbool = exports.meta = exports.describe = exports.ZodCustom = exports.ZodFunction = exports.ZodPromise = exports.ZodLazy = exports.ZodTemplateLiteral = exports.ZodReadonly = exports.ZodPreprocess = exports.ZodCodec = exports.ZodPipe = exports.ZodNaN = exports.ZodCatch = exports.ZodSuccess = exports.ZodNonOptional = exports.ZodPrefault = exports.ZodDefault = exports.ZodNullable = exports.ZodExactOptional = exports.ZodOptional = exports.ZodTransform = exports.ZodFile = void 0;
 exports.string = string;
 exports.email = email;
 exports.guid = guid;
@@ -1372,6 +1372,10 @@ function invertCodec(codec) {
         reverseTransform: def.transform,
     });
 }
+exports.ZodPreprocess = core.$constructor("ZodPreprocess", (inst, def) => {
+    exports.ZodPipe.init(inst, def);
+    core.$ZodPreprocess.init(inst, def);
+});
 exports.ZodReadonly = core.$constructor("ZodReadonly", (inst, def) => {
     core.$ZodReadonly.init(inst, def);
     exports.ZodType.init(inst, def);
@@ -1497,5 +1501,9 @@ function json(params) {
 }
 // preprocess
 function preprocess(fn, schema) {
-    return pipe(transform(fn), schema);
+    return new exports.ZodPreprocess({
+        type: "pipe",
+        in: transform(fn),
+        out: schema,
+    });
 }

package/v4/classic/schemas.d.cts

@@ -511,7 +511,7 @@ export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[]
     def: core.$ZodDiscriminatedUnionDef<Options, Disc>;
 }
 export declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
 export interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodIntersectionInternals<A, B>>, core.$ZodIntersection<A, B> {
     "~standard": ZodStandardSchemaWithJSON<this>;
 }
@@ -674,6 +674,12 @@ export declare function codec<const A extends core.SomeType, B extends core.Some
     encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
 }): ZodCodec<A, B>;
 export declare function invertCodec<A extends core.SomeType, B extends core.SomeType>(codec: ZodCodec<A, B>): ZodCodec<B, A>;
+export interface ZodPreprocess<B extends core.SomeType = core.$ZodType> extends ZodPipe<core.$ZodTransform, B>, core.$ZodPreprocess<B> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    _zod: core.$ZodPreprocessInternals<B>;
+    def: core.$ZodPreprocessDef<B>;
+}
+export declare const ZodPreprocess: core.$constructor<ZodPreprocess>;
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodReadonlyInternals<T>>, core.$ZodReadonly<T> {
     "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
@@ -758,4 +764,4 @@ export interface ZodJSONSchema extends _ZodJSONSchema {
     _zod: ZodJSONSchemaInternals;
 }
 export declare function json(params?: string | core.$ZodCustomParams): ZodJSONSchema;
-export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;
+export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPreprocess<U>;

package/v4/classic/schemas.d.ts

@@ -511,7 +511,7 @@ export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[]
     def: core.$ZodDiscriminatedUnionDef<Options, Disc>;
 }
 export declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
 export interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodIntersectionInternals<A, B>>, core.$ZodIntersection<A, B> {
     "~standard": ZodStandardSchemaWithJSON<this>;
 }
@@ -674,6 +674,12 @@ export declare function codec<const A extends core.SomeType, B extends core.Some
     encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
 }): ZodCodec<A, B>;
 export declare function invertCodec<A extends core.SomeType, B extends core.SomeType>(codec: ZodCodec<A, B>): ZodCodec<B, A>;
+export interface ZodPreprocess<B extends core.SomeType = core.$ZodType> extends ZodPipe<core.$ZodTransform, B>, core.$ZodPreprocess<B> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
+    _zod: core.$ZodPreprocessInternals<B>;
+    def: core.$ZodPreprocessDef<B>;
+}
+export declare const ZodPreprocess: core.$constructor<ZodPreprocess>;
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodReadonlyInternals<T>>, core.$ZodReadonly<T> {
     "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
@@ -758,4 +764,4 @@ export interface ZodJSONSchema extends _ZodJSONSchema {
     _zod: ZodJSONSchemaInternals;
 }
 export declare function json(params?: string | core.$ZodCustomParams): ZodJSONSchema;
-export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;
+export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPreprocess<U>;

package/v4/classic/schemas.js

@@ -1255,6 +1255,10 @@ export function invertCodec(codec) {
         reverseTransform: def.transform,
     });
 }
+export const ZodPreprocess = /*@__PURE__*/ core.$constructor("ZodPreprocess", (inst, def) => {
+    ZodPipe.init(inst, def);
+    core.$ZodPreprocess.init(inst, def);
+});
 export const ZodReadonly = /*@__PURE__*/ core.$constructor("ZodReadonly", (inst, def) => {
     core.$ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
@@ -1381,5 +1385,9 @@ export function json(params) {
 }
 // preprocess
 export function preprocess(fn, schema) {
-    return pipe(transform(fn), schema);
+    return new ZodPreprocess({
+        type: "pipe",
+        in: transform(fn),
+        out: schema,
+    });
 }

package/v4/core/api.d.cts

@@ -225,14 +225,16 @@ export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
 export declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;
 export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
 export declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;
-export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
+export interface $ZodTypeDiscriminableInternals<Disc extends string = string> extends schemas.$ZodTypeInternals<unknown, {
+    [K in Disc]?: unknown;
+}> {
     propValues: util.PropValues;
 }
-export interface $ZodTypeDiscriminable extends schemas.$ZodType {
-    _zod: $ZodTypeDiscriminableInternals;
+export interface $ZodTypeDiscriminable<Disc extends string = string> extends schemas.$ZodType {
+    _zod: $ZodTypeDiscriminableInternals<Disc>;
 }
 export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
-export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
+export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable<Disc>, ...$ZodTypeDiscriminable<Disc>[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
 export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
 export declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;
 export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;

package/v4/core/api.d.ts

@@ -225,14 +225,16 @@ export type $ZodUnionParams = TypeParams<schemas.$ZodUnion, "options">;
 export declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;
 export type $ZodXorParams = TypeParams<schemas.$ZodXor, "options">;
 export declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;
-export interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {
+export interface $ZodTypeDiscriminableInternals<Disc extends string = string> extends schemas.$ZodTypeInternals<unknown, {
+    [K in Disc]?: unknown;
+}> {
     propValues: util.PropValues;
 }
-export interface $ZodTypeDiscriminable extends schemas.$ZodType {
-    _zod: $ZodTypeDiscriminableInternals;
+export interface $ZodTypeDiscriminable<Disc extends string = string> extends schemas.$ZodType {
+    _zod: $ZodTypeDiscriminableInternals<Disc>;
 }
 export type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, "options" | "discriminator">;
-export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
+export declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable<Disc>, ...$ZodTypeDiscriminable<Disc>[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;
 export type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, "left" | "right">;
 export declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;
 export type $ZodTupleParams = TypeParams<schemas.$ZodTuple, "items" | "rest">;

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

@@ -525,7 +525,8 @@ const catchProcessor = (schema, ctx, json, params) => {
 exports.catchProcessor = catchProcessor;
 const pipeProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
-    const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
+    const inIsTransform = def.in._zod.traits.has("$ZodTransform");
+    const innerType = ctx.io === "input" ? (inIsTransform ? def.out : def.in) : def.out;
     (0, to_json_schema_js_1.process)(innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = innerType;

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

@@ -487,7 +487,8 @@ export const catchProcessor = (schema, ctx, json, params) => {
 };
 export const pipeProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
-    const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
+    const inIsTransform = def.in._zod.traits.has("$ZodTransform");
+    const innerType = ctx.io === "input" ? (inIsTransform ? def.out : def.in) : def.out;
     process(innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = innerType;

package/v4/core/schemas.cjs

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$ZodTuple = exports.$ZodIntersection = exports.$ZodDiscriminatedUnion = exports.$ZodXor = exports.$ZodUnion = exports.$ZodObjectJIT = exports.$ZodObject = exports.$ZodArray = exports.$ZodDate = exports.$ZodVoid = exports.$ZodNever = exports.$ZodUnknown = exports.$ZodAny = exports.$ZodNull = exports.$ZodUndefined = exports.$ZodSymbol = exports.$ZodBigIntFormat = exports.$ZodBigInt = exports.$ZodBoolean = exports.$ZodNumberFormat = exports.$ZodNumber = exports.$ZodCustomStringFormat = exports.$ZodJWT = exports.$ZodE164 = exports.$ZodBase64URL = exports.$ZodBase64 = exports.$ZodCIDRv6 = exports.$ZodCIDRv4 = exports.$ZodMAC = exports.$ZodIPv6 = exports.$ZodIPv4 = exports.$ZodISODuration = exports.$ZodISOTime = exports.$ZodISODate = exports.$ZodISODateTime = exports.$ZodKSUID = exports.$ZodXID = exports.$ZodULID = exports.$ZodCUID2 = exports.$ZodCUID = exports.$ZodNanoID = exports.$ZodEmoji = exports.$ZodURL = exports.$ZodEmail = exports.$ZodUUID = exports.$ZodGUID = exports.$ZodStringFormat = exports.$ZodString = exports.clone = exports.$ZodType = void 0;
-exports.$ZodCustom = exports.$ZodLazy = exports.$ZodPromise = exports.$ZodFunction = exports.$ZodTemplateLiteral = exports.$ZodReadonly = exports.$ZodCodec = exports.$ZodPipe = exports.$ZodNaN = exports.$ZodCatch = exports.$ZodSuccess = exports.$ZodNonOptional = exports.$ZodPrefault = exports.$ZodDefault = exports.$ZodNullable = exports.$ZodExactOptional = exports.$ZodOptional = exports.$ZodTransform = exports.$ZodFile = exports.$ZodLiteral = exports.$ZodEnum = exports.$ZodSet = exports.$ZodMap = exports.$ZodRecord = void 0;
+exports.$ZodCustom = exports.$ZodLazy = exports.$ZodPromise = exports.$ZodFunction = exports.$ZodTemplateLiteral = exports.$ZodReadonly = exports.$ZodPreprocess = exports.$ZodCodec = exports.$ZodPipe = exports.$ZodNaN = exports.$ZodCatch = exports.$ZodSuccess = exports.$ZodNonOptional = exports.$ZodPrefault = exports.$ZodDefault = exports.$ZodNullable = exports.$ZodExactOptional = exports.$ZodOptional = exports.$ZodTransform = exports.$ZodFile = exports.$ZodLiteral = exports.$ZodEnum = exports.$ZodSet = exports.$ZodMap = exports.$ZodRecord = void 0;
 exports.isValidBase64 = isValidBase64;
 exports.isValidBase64URL = isValidBase64URL;
 exports.isValidJWT = isValidJWT;
@@ -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;
             }
@@ -2056,6 +2053,11 @@ function handleCodecTxResult(left, value, nextSchema, ctx) {
     }
     return nextSchema._zod.run({ value, issues: left.issues }, ctx);
 }
+exports.$ZodPreprocess = core.$constructor("$ZodPreprocess", (inst, def) => {
+    exports.$ZodPipe.init(inst, def);
+    util.defineLazy(inst._zod, "optin", () => def.out._zod.optin);
+    util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+});
 exports.$ZodReadonly = core.$constructor("$ZodReadonly", (inst, def) => {
     exports.$ZodType.init(inst, def);
     util.defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);

package/v4/core/schemas.d.cts

@@ -1030,6 +1030,19 @@ export interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $
     _zod: $ZodCodecInternals<A, B>;
 }
 export declare const $ZodCodec: core.$constructor<$ZodCodec>;
+export interface $ZodPreprocessDef<B extends SomeType = $ZodType> extends $ZodPipeDef<$ZodTransform, B> {
+    in: $ZodTransform;
+    out: B;
+}
+export interface $ZodPreprocessInternals<B extends SomeType = $ZodType> extends $ZodPipeInternals<$ZodTransform, B> {
+    def: $ZodPreprocessDef<B>;
+    optin: B["_zod"]["optin"];
+    optout: B["_zod"]["optout"];
+}
+export interface $ZodPreprocess<B extends SomeType = $ZodType> extends $ZodPipe<$ZodTransform, B> {
+    _zod: $ZodPreprocessInternals<B>;
+}
+export declare const $ZodPreprocess: core.$constructor<$ZodPreprocess>;
 export interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "readonly";
     innerType: T;

package/v4/core/schemas.d.ts

@@ -1030,6 +1030,19 @@ export interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $
     _zod: $ZodCodecInternals<A, B>;
 }
 export declare const $ZodCodec: core.$constructor<$ZodCodec>;
+export interface $ZodPreprocessDef<B extends SomeType = $ZodType> extends $ZodPipeDef<$ZodTransform, B> {
+    in: $ZodTransform;
+    out: B;
+}
+export interface $ZodPreprocessInternals<B extends SomeType = $ZodType> extends $ZodPipeInternals<$ZodTransform, B> {
+    def: $ZodPreprocessDef<B>;
+    optin: B["_zod"]["optin"];
+    optout: B["_zod"]["optout"];
+}
+export interface $ZodPreprocess<B extends SomeType = $ZodType> extends $ZodPipe<$ZodTransform, B> {
+    _zod: $ZodPreprocessInternals<B>;
+}
+export declare const $ZodPreprocess: core.$constructor<$ZodPreprocess>;
 export interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "readonly";
     innerType: T;

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;
             }
@@ -2025,6 +2022,11 @@ function handleCodecTxResult(left, value, nextSchema, ctx) {
     }
     return nextSchema._zod.run({ value, issues: left.issues }, ctx);
 }
+export const $ZodPreprocess = /*@__PURE__*/ core.$constructor("$ZodPreprocess", (inst, def) => {
+    $ZodPipe.init(inst, def);
+    util.defineLazy(inst._zod, "optin", () => def.out._zod.optin);
+    util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+});
 export const $ZodReadonly = /*@__PURE__*/ core.$constructor("$ZodReadonly", (inst, def) => {
     $ZodType.init(inst, def);
     util.defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);

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

@@ -407,6 +407,8 @@ function isTransforming(_schema, _ctx) {
         return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
     }
     if (def.type === "pipe") {
+        if (_schema._zod.traits.has("$ZodCodec"))
+            return true;
         return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
     }
     if (def.type === "object") {

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

@@ -400,6 +400,8 @@ function isTransforming(_schema, _ctx) {
         return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
     }
     if (def.type === "pipe") {
+        if (_schema._zod.traits.has("$ZodCodec"))
+            return true;
         return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
     }
     if (def.type === "object") {

package/v4/core/versions.cjs

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

package/v4/core/versions.js

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

package/v4/mini/schemas.d.cts

@@ -260,7 +260,7 @@ export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] =
     _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
 }
 export declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
 export interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodIntersectionInternals<A, B>> {
 }
 export declare const ZodMiniIntersection: core.$constructor<ZodMiniIntersection>;

package/v4/mini/schemas.d.ts

@@ -260,7 +260,7 @@ export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] =
     _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
 }
 export declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
 export interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodIntersectionInternals<A, B>> {
 }
 export declare const ZodMiniIntersection: core.$constructor<ZodMiniIntersection>;