zod 4.2.0-canary.20251016T223057 → 4.2.0-canary.20251017T221623

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.2.0-canary.20251016T223057",
+  "version": "4.2.0-canary.20251017T221623",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/schemas.ts

@@ -265,7 +265,6 @@ export const _ZodString: core.$constructor<_ZodString> = /*@__PURE__*/ core.$con
   inst.maxLength = bag.maximum ?? null;
 
   // validations
-  // if (inst.regex) throw new Error("regex already defined");
   inst.regex = (...args) => inst.check(checks.regex(...args));
   inst.includes = (...args) => inst.check(checks.includes(...args));
   inst.startsWith = (...args) => inst.check(checks.startsWith(...args));

package/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,

package/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 () => {

package/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", () => {

package/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;
 }

package/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>>();
-//   };
-// });

package/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,

package/v4/classic/schemas.cjs

@@ -208,7 +208,6 @@ exports._ZodString = core.$constructor("_ZodString", (inst, def) => {
     inst.minLength = bag.minimum ?? null;
     inst.maxLength = bag.maximum ?? null;
     // validations
-    // if (inst.regex) throw new Error("regex already defined");
     inst.regex = (...args) => inst.check(checks.regex(...args));
     inst.includes = (...args) => inst.check(checks.includes(...args));
     inst.startsWith = (...args) => inst.check(checks.startsWith(...args));

package/v4/classic/schemas.js

@@ -91,7 +91,6 @@ export const _ZodString = /*@__PURE__*/ core.$constructor("_ZodString", (inst, d
     inst.minLength = bag.minimum ?? null;
     inst.maxLength = bag.maximum ?? null;
     // validations
-    // if (inst.regex) throw new Error("regex already defined");
     inst.regex = (...args) => inst.check(checks.regex(...args));
     inst.includes = (...args) => inst.check(checks.includes(...args));
     inst.startsWith = (...args) => inst.check(checks.startsWith(...args));

package/v4/core/schemas.d.cts

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

package/v4/core/schemas.d.ts

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