fix(v4): resolve z.input past a preprocess transform

z.preprocess pipes a transform into a schema, so z.input handed back the bare
transform — which validates nothing and re-runs the preprocessor:

    const P = z.preprocess((v) => String(v), z.string().min(5));

    P.parse(12345);          // "12345" — transform, then min(5) enforced
    z.input(P).parse(null);  // "null"  — accepts anything, min(5) gone

A bare transform is not a real input side, so the schema it feeds is. That is
the resolution toJSONSchema already makes for this exact case, and the two now
agree on what the input side of a preprocess looks like.

A pipe's own checks travel with whichever side wins, so a refine on a
preprocess survives the projection. Codecs are untouched: they have two real
sides, and z.input still returns `in` by identity.

Author: colinhacks

packages/zod/src/v4/classic/in-out.ts

@@ -14,16 +14,26 @@ function withChecks(side: core.$ZodType, checks: core.$ZodTypeDef["checks"]): co
   return clone(side, mergeDefs(def, { checks: [...(def.checks ?? []), ...checks] }), { parent: true });
 }
 
-/** Returns a copy of the schema with every pipe replaced by its input side. A pipe's own checks are dropped, since they constrain the decoded value the input side never produces. */
+/** The out side, carrying the pipe's own checks: those run against the decoded value, which is what `out` produces. */
+function outSide(def: core.$ZodPipeDef): core.$ZodType {
+  return withChecks(def.out, def.checks);
+}
+
+/** The in side. `z.preprocess` pipes a transform into a schema, and a bare transform validates nothing, so the schema it feeds is the real input side — the resolution `toJSONSchema` already makes for this case. */
+function inSide(def: core.$ZodPipeDef): core.$ZodType {
+  return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
+}
+
+/** Returns a copy of the schema with every pipe replaced by its input side. A codec's checks are dropped: they constrain the decoded value the input side never produces. */
 export function input<T extends core.$ZodType>(schema: T): schemas.ZodType<core.input<T>, core.input<T>> {
   return visit(schema, {
-    pipe: (s) => s._zod.def.in,
+    pipe: (s) => inSide(s._zod.def),
   }) as schemas.ZodType<core.input<T>, core.input<T>>;
 }
 
 /** Returns a copy of the schema with every pipe replaced by its output side, carrying over the pipe's own checks. */
 export function output<T extends core.$ZodType>(schema: T): schemas.ZodType<core.output<T>, core.output<T>> {
   return visit(schema, {
-    pipe: (s) => withChecks(s._zod.def.out, s._zod.def.checks),
+    pipe: (s) => outSide(s._zod.def),
   }) as schemas.ZodType<core.output<T>, core.output<T>>;
 }

packages/zod/src/v4/classic/tests/in-out.test.ts

@@ -90,6 +90,27 @@ describe("z.input / z.output", () => {
     expect(() => z.input(z.object({ s: z.string().min(2) })).parse({ s: "a" })).toThrow();
   });
 
+  test("z.input resolves past a preprocess transform, which is not a real input side", () => {
+    const p = z.preprocess((v) => String(v), z.string().min(5));
+    const encoded = z.input(p);
+
+    expect(encoded.parse("abcde")).toBe("abcde");
+    // The bare transform used to come back here: it validated nothing and re-ran the preprocessor.
+    expect(() => encoded.parse(1)).toThrow();
+    expect(() => encoded.parse("abc")).toThrow();
+    // The same resolution the JSON Schema emitter already makes for this schema.
+    expect(z.toJSONSchema(p, { io: "input" })).toMatchObject({ type: "string", minLength: 5 });
+
+    // A check on the pipe itself travels with whichever side wins.
+    const checked = z.preprocess((v) => String(v), z.string()).refine((s) => s.startsWith("ok"));
+    expect(z.input(checked).parse("okay")).toBe("okay");
+    expect(() => z.input(checked).parse("nope")).toThrow();
+
+    // Control: a codec has two real sides, so its input side is still `in`, by identity.
+    const c = z.codec(z.string(), z.number(), { decode: Number, encode: String });
+    expect(z.input(c)).toBe(c._zod.def.in);
+  });
+
   test("runtime `z.input` agrees with type-level `z.input<T>`", () => {
     const c = z.codec(z.string(), z.bigint(), {
       decode: (s) => BigInt(s),

packages/zod/src/v4/mini/in-out.ts

@@ -14,16 +14,26 @@ function withChecks(side: core.$ZodType, checks: core.$ZodTypeDef["checks"]): co
   return clone(side, mergeDefs(def, { checks: [...(def.checks ?? []), ...checks] }), { parent: true });
 }
 
+/** See `classic/in-out.ts`. */
+function outSide(def: core.$ZodPipeDef): core.$ZodType {
+  return withChecks(def.out, def.checks);
+}
+
+/** See `classic/in-out.ts`. */
+function inSide(def: core.$ZodPipeDef): core.$ZodType {
+  return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
+}
+
 /** See `classic/in-out.ts`. */
 export function input<T extends core.$ZodType>(schema: T): schemas.ZodMiniType<core.input<T>, core.input<T>> {
   return visit(schema, {
-    pipe: (s) => s._zod.def.in,
+    pipe: (s) => inSide(s._zod.def),
   }) as schemas.ZodMiniType<core.input<T>, core.input<T>>;
 }
 
 /** See `classic/in-out.ts`. */
 export function output<T extends core.$ZodType>(schema: T): schemas.ZodMiniType<core.output<T>, core.output<T>> {
   return visit(schema, {
-    pipe: (s) => withChecks(s._zod.def.out, s._zod.def.checks),
+    pipe: (s) => outSide(s._zod.def),
   }) as schemas.ZodMiniType<core.output<T>, core.output<T>>;
 }

packages/zod/src/v4/mini/tests/codec.test.ts

@@ -558,3 +558,13 @@ test("z.output carries checks attached to a pipe", () => {
   // The input side drops it: the check constrains a value that side never produces.
   expect(z.input(c).parse("5")).toBe("5");
 });
+
+test("z.input resolves past a transform piped into a schema", () => {
+  const p = z.pipe(
+    z.transform((v: unknown) => String(v)),
+    z.string().check(z.minLength(5))
+  );
+
+  expect(z.input(p).parse("abcde")).toBe("abcde");
+  expect(() => z.input(p).parse(1)).toThrow();
+});