Fix classic pipe compatibility for branded outputs

Author: colinhacks

packages/zod/src/v4/classic/schemas.ts

@@ -179,6 +179,10 @@ export interface ZodType<
   pipe<T extends core.$ZodType<any, core.output<this>>>(
     target: T | core.$ZodType<any, core.output<this>>
   ): ZodPipe<this, T>;
+  pipe<const T extends core.SomeType>(
+    target: T,
+    ...rest: core.output<this> extends core.input<T> ? [] : ["Incompatible pipe target"]
+  ): ZodPipe<this, T>;
   readonly(): ZodReadonly<this>;
 
   /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
@@ -326,7 +330,7 @@ export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$construct
       return _catch(this, params);
     },
     pipe(target) {
-      return pipe(this, target);
+      return pipe(this, target as core.$ZodType);
     },
     readonly() {
       return readonly(this);

packages/zod/src/v4/classic/tests/pipe.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { expect, expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
 
@@ -15,6 +15,37 @@ test("string to number pipe async", async () => {
   expect(await schema.parseAsync("1234")).toEqual(1234);
 });
 
+test("pipe contextually types transforms", () => {
+  const schema = z.string().pipe(z.transform((val) => val.toUpperCase()));
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<string>();
+
+  // @ts-expect-error incompatible pipe targets are still rejected
+  z.string().pipe(z.number());
+});
+
+test("pipe branded output to unbranded input", () => {
+  const zodBrand = z.string().brand<"myBrand">();
+  const inputSchema = z.object({
+    a: z.number(),
+    c: zodBrand,
+  });
+  const validateSchema = z.object({
+    a: z.number(),
+    c: zodBrand,
+  });
+
+  const testSchemaPipeline = inputSchema.transform((input) => input).pipe(validateSchema);
+  const testSchemaPipeline2 = inputSchema.pipe(validateSchema);
+  const testSchemaPipeline3 = inputSchema.pipe(inputSchema);
+
+  expectTypeOf<z.output<typeof testSchemaPipeline>>().toEqualTypeOf<{
+    a: number;
+    c: string & z.core.$brand<"myBrand">;
+  }>();
+  expectTypeOf<z.output<typeof testSchemaPipeline2>>().toEqualTypeOf<z.output<typeof validateSchema>>();
+  expectTypeOf<z.output<typeof testSchemaPipeline3>>().toEqualTypeOf<z.output<typeof inputSchema>>();
+});
+
 test("string with default fallback", () => {
   const stringWithDefault = z
     .pipe(