Fix generic assignability issue. 3.25.54

Author: colinhacks

packages/zod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.25.53",
+  "version": "3.25.54",
   "type": "module",
   "author": "Colin McDonnell <[email protected]>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",

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

@@ -72,7 +72,7 @@ export interface ZodType<
   nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
   nullable(): ZodNullable<this>;
   nullish(): ZodOptional<ZodNullable<this>>;
-  default(def: util.NoUndefined<core.output<this>>): ZodDefault<this>;
+  default(def: core.output<this>): ZodDefault<this>;
   default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this>;
   prefault(def: () => core.input<this>): ZodPrefault<this>;
   prefault(def: core.input<this>): ZodPrefault<this>;

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

@@ -192,3 +192,19 @@ test("assignability with narrowing", () => {
 
   type RefinedUnionSchema<T extends z.ZodUnion> = T;
 });
+
+test("generic assignability in objects", () => {
+  interface SortItem<T extends string> {
+    key: T;
+    order: string;
+  }
+
+  const createSortItemSchema = <T extends z.ZodType<string>>(sortKeySchema: T) =>
+    z.object({
+      key: sortKeySchema,
+      order: z.string(),
+    });
+
+  <T extends z.ZodType<string>>(sortKeySchema: T, defaultSortBy: SortItem<z.output<T>>[] = []) =>
+    createSortItemSchema(sortKeySchema).array().default(defaultSortBy);
+});

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

@@ -1527,45 +1527,15 @@ export const $ZodArray: core.$constructor<$ZodArray> = /*@__PURE__*/ core.$const
 type OptionalOutSchema = { _zod: { optout: "optional" } };
 type OptionalInSchema = { _zod: { optin: "optional" } };
 
-export type $InferObjectOutputFallback<
-  T extends $ZodLooseShape,
-  Extra extends Record<string, unknown>,
-> = string extends keyof T
-  ? object
-  : keyof (T & Extra) extends never
-    ? Record<string, never>
-    : util.Prettify<
-        {
-          // this is a simplified fallback type
-          // there is no support for key optionality
-          -readonly [k in keyof T]: core.output<T[k]>;
-        } & Extra
-      >;
-
-export type $InferObjectInputFallback<
-  T extends $ZodLooseShape,
-  Extra extends Record<string, unknown>,
-> = string extends keyof T
-  ? object
-  : keyof (T & Extra) extends never
-    ? Record<string, never>
-    : util.Prettify<
-        {
-          // this is a simplified fallback type
-          // there is no support for key optionality
-          -readonly [k in keyof T]: core.input<T[k]>;
-        } & Extra
-      >;
-
 export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T
   ? object
   : keyof (T & Extra) extends never
     ? Record<string, never>
     : util.Prettify<
         {
-          -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: core.output<T[k]>;
+          -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"];
         } & {
-          -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: core.output<T[k]>;
+          -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"];
         } & Extra
       >;
 
@@ -1575,9 +1545,9 @@ export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<str
     ? Record<string, never>
     : util.Prettify<
         {
-          -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: core.input<T[k]>;
+          -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"];
         } & {
-          -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: core.input<T[k]>;
+          -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"];
         } & Extra
       >;
 
@@ -1874,6 +1844,7 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
 //////////                    ///////////
 /////////////////////////////////////////
 /////////////////////////////////////////
+// use generic to distribute union types
 export type $InferUnionOutput<T extends SomeType> = T extends any ? core.output<T> : never;
 export type $InferUnionInput<T extends SomeType> = T extends any ? core.input<T> : never;
 export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {

play.ts

@@ -1,3 +1,15 @@
 import { z } from "zod/v4";
 
-z;
+export interface SortItem<T extends string> {
+  key: T;
+  order: string;
+}
+
+export const createSortItemSchema = <T extends z.ZodType<string>>(sortKeySchema: T) =>
+  z.object({
+    key: sortKeySchema,
+    order: z.string(),
+  });
+
+const error = <T extends z.ZodType<string>>(sortKeySchema: T, defaultSortBy: SortItem<z.output<T>>[] = []) =>
+  createSortItemSchema(sortKeySchema).array().default(defaultSortBy);