Update inferred z.promise() type

Author: colinhacks

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

@@ -749,7 +749,7 @@ test("z.json", () => {
 test("z.promise", async () => {
   const a = z.promise(z.string());
   type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
+  expectTypeOf<a>().toEqualTypeOf<Promise<string>>();
 
   expect(await z.safeParseAsync(a, Promise.resolve("hello"))).toMatchObject({
     success: true,

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

@@ -10,7 +10,7 @@ const promSchema = z.promise(
 
 test("promise inference", () => {
   type promSchemaType = z.infer<typeof promSchema>;
-  expectTypeOf<promSchemaType>().toEqualTypeOf<{ name: string; age: number }>();
+  expectTypeOf<promSchemaType>().toEqualTypeOf<Promise<{ name: string; age: number }>>();
 });
 
 test("promise parsing success", async () => {

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

@@ -47,7 +47,7 @@ test("flat inference", () => {
   expectTypeOf<typeof readonlyNumberRecord._output>().toEqualTypeOf<Readonly<Record<string, number>>>();
   expectTypeOf<typeof readonlyObject._output>().toEqualTypeOf<{ readonly a: string; readonly 1: number }>();
   expectTypeOf<typeof readonlyEnum._output>().toEqualTypeOf<Readonly<testEnum>>();
-  expectTypeOf<typeof readonlyPromise._output>().toEqualTypeOf<string>();
+  expectTypeOf<typeof readonlyPromise._output>().toEqualTypeOf<Promise<string>>();
 });
 
 // test("deep inference", () => {

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

@@ -4103,7 +4103,7 @@ export interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeD
 }
 
 export interface $ZodPromiseInternals<T extends SomeType = $ZodType>
-  extends $ZodTypeInternals<core.output<T>, util.MaybeAsync<core.input<T>>> {
+  extends $ZodTypeInternals<Promise<core.output<T>>, util.MaybeAsync<core.input<T>>> {
   def: $ZodPromiseDef<T>;
   isst: never;
 }

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

@@ -1,43 +1,5 @@
 import { expect, test } from "vitest";
-// import * as z from "zod/v4/core";
 
 test("z.function", () => {
   expect(true).toEqual(true);
 });
-
-// test("z.function", () => {
-//   const a = z.function({
-//     args: z.tuple([z.string()]),
-//     returns: z.string(),
-//   });
-
-//   const myFunc = a.implement((name: string | number) => `Hello, ${name}!`);
-
-//   expect(myFunc("world")).toEqual("Hello, world!");
-//   expect(() => myFunc(123 as any)).toThrow();
-
-//   // this won't run
-//   () => {
-//     // @ts-expect-error
-//     const r = myFunc(123);
-//     expectTypeOf(r).toEqualTypeOf<string>();
-//   };
-// });
-
-// test("z.function async", async () => {
-//   const b = z.function({
-//     args: z.tuple([z.string()]).$check(async (_) => {}),
-//     returns: z.string().$check(async (_) => {}),
-//   });
-//   const myFuncAsync = b.implementAsync(async (name) => `Hello, ${name}!`);
-
-//   expect(await myFuncAsync("world")).toEqual("Hello, world!");
-//   expect(myFuncAsync(123 as any)).rejects.toThrow();
-
-//   // this won't run
-//   () => {
-//     // @ts-expect-error
-//     const r = myFuncAsync(123);
-//     expectTypeOf(r).toEqualTypeOf<Promise<string>>();
-//   };
-// });

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

@@ -789,7 +789,7 @@ test("z.stringbool", () => {
 test("z.promise", async () => {
   const a = z.promise(z.string());
   type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
+  expectTypeOf<a>().toEqualTypeOf<Promise<string>>();
 
   expect(await z.safeParseAsync(a, Promise.resolve("hello"))).toMatchObject({
     success: true,