zod 4.0.9 → 4.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.0.9",
+  "version": "4.0.11",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
@@ -41,9 +41,9 @@
       "./v4/locales": "./src/v4/locales/index.ts",
       "./v4/locales/*": "./src/v4/locales/*"
     },
-    "sourceDialects": [
-      "@zod/source"
-    ]
+    "conditions": {
+      "@zod/source": "src"
+    }
   },
   "exports": {
     "./package.json": "./package.json",

package/src/v4/classic/checks.ts

@@ -27,4 +27,5 @@ export {
   _trim as trim,
   _toLowerCase as toLowerCase,
   _toUpperCase as toUpperCase,
+  type $RefinementCtx as RefinementCtx,
 } from "../core/index.js";

package/src/v4/classic/schemas.ts

@@ -13,10 +13,6 @@ import * as parse from "./parse.js";
 ///////////////////////////////////////////
 ///////////////////////////////////////////
 
-export interface RefinementCtx<T = unknown> extends core.ParsePayload<T> {
-  addIssue(arg: string | core.$ZodRawIssue | Partial<core.$ZodIssueCustom>): void;
-}
-
 export interface ZodType<
   out Output = unknown,
   out Input = unknown,
@@ -62,7 +58,7 @@ export interface ZodType<
   // refinements
   refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
   superRefine(
-    refinement: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => void | Promise<void>
+    refinement: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => void | Promise<void>
   ): this;
   overwrite(fn: (x: core.output<this>) => core.output<this>): this;
 
@@ -79,7 +75,7 @@ export interface ZodType<
   or<T extends core.SomeType>(option: T): ZodUnion<[this, T]>;
   and<T extends core.SomeType>(incoming: T): ZodIntersection<this, T>;
   transform<NewOut>(
-    transform: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>
+    transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>
   ): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>>;
   catch(def: core.output<this>): ZodCatch<this>;
   catch(def: (ctx: core.$ZodCatchCtx) => core.output<this>): ZodCatch<this>;
@@ -697,6 +693,10 @@ export function stringFormat<Format extends string>(
   return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params) as any;
 }
 
+export function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hostname"> {
+  return core._stringFormat(ZodCustomStringFormat, "hostname", core.regexes.hostname, _params) as any;
+}
+
 // ZodNumber
 export interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals>
   extends _ZodType<Internals> {
@@ -1572,7 +1572,7 @@ export const ZodTransform: core.$constructor<ZodTransform> = /*@__PURE__*/ core.
     ZodType.init(inst, def);
 
     inst._zod.parse = (payload, _ctx) => {
-      (payload as RefinementCtx).addIssue = (issue) => {
+      (payload as core.$RefinementCtx).addIssue = (issue) => {
         if (typeof issue === "string") {
           payload.issues.push(util.issue(issue, payload.value, def));
         } else {
@@ -1955,26 +1955,10 @@ export function refine<T>(
 }
 
 // superRefine
-export function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T> {
-  const ch = check<T>((payload) => {
-    (payload as RefinementCtx).addIssue = (issue) => {
-      if (typeof issue === "string") {
-        payload.issues.push(util.issue(issue, payload.value, ch._zod.def));
-      } else {
-        // for Zod 3 backwards compatibility
-        const _issue: any = issue;
-        if (_issue.fatal) _issue.continue = false;
-        _issue.code ??= "custom";
-        _issue.input ??= payload.value;
-        _issue.inst ??= ch;
-        _issue.continue ??= !ch._zod.def.abort;
-        payload.issues.push(util.issue(_issue));
-      }
-    };
-
-    return fn(payload.value, payload as RefinementCtx<T>);
-  });
-  return ch;
+export function superRefine<T>(
+  fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>
+): core.$ZodCheck<T> {
+  return core._superRefine(fn);
 }
 
 type ZodInstanceOfParams = core.Params<
@@ -2040,7 +2024,7 @@ export function json(params?: string | core.$ZodCustomParams): ZodJSONSchema {
 
 // /** @deprecated Use `z.pipe()` and `z.transform()` instead. */
 export function preprocess<A, U extends core.SomeType, B = unknown>(
-  fn: (arg: B, ctx: RefinementCtx) => A,
+  fn: (arg: B, ctx: core.$RefinementCtx) => A,
   schema: U
 ): ZodPipe<ZodTransform<A, B>, U> {
   return pipe(transform(fn as any), schema as any) as any;

package/src/v4/classic/tests/datetime.test.ts

@@ -62,6 +62,12 @@ test("datetime parsing with offset", () => {
   expect(() => datetimeOffset.parse("2020-10-14T17:42:29+03")).toThrow();
   expect(() => datetimeOffset.parse("tuna")).toThrow();
   expect(() => datetimeOffset.parse("2022-10-13T09:52:31.Z")).toThrow();
+
+  // Invalid offset tests
+  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+24:00")).toThrow(); // out of range hours
+  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+00:60")).toThrow(); // out of range minutes
+  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+1:30")).toThrow(); // single digit hours
+  expect(() => datetimeOffset.parse("2020-10-14T17:42:29+00:")).toThrow(); // incomplete offset
 });
 
 test("datetime parsing with offset and precision 0", () => {

package/src/v4/classic/tests/discriminated-unions.test.ts

@@ -157,6 +157,7 @@ test("invalid discriminator value", () => {
         "code": "invalid_union",
         "errors": [],
         "note": "No matching discriminator",
+        "discriminator": "type",
         "path": [
           "type"
         ],

package/src/v4/classic/tests/file.test.ts

@@ -1,7 +1,6 @@
-// @ts-ignore
 import { File as WebFile } from "@web-std/file";
 
-import { afterEach, beforeEach, expect, test } from "vitest";
+import { afterEach, beforeEach, expect, expectTypeOf, test } from "vitest";
 
 import * as z from "zod/v4";
 
@@ -27,6 +26,10 @@ test("passing validations", () => {
   expect(() => mimeCheck.parse(new File([""], "test.txt", { type: "text/csv" }))).toThrow();
 });
 
+test("types", () => {
+  expectTypeOf(z.file().parse(new File([], "test.txt"))).toEqualTypeOf(new File([], "test.txt"));
+});
+
 test("failing validations", () => {
   expect(minCheck.safeParse(new File(["1234"], "test.txt"))).toMatchInlineSnapshot(`
     {

package/src/v4/classic/tests/number.test.ts

@@ -114,6 +114,29 @@ test(".nonnegative() validation", () => {
   expect(() => schema.parse(-1)).toThrow();
 });
 
+test("multipleOf", () => {
+  const numbers = {
+    number3: 5.123,
+    number6: 5.123456,
+    number7: 5.1234567,
+    number8: 5.12345678,
+  };
+
+  const schemas = {
+    schema6: z.number().multipleOf(0.000001),
+    schema7: z.number().multipleOf(0.0000001),
+  };
+
+  expect(() => schemas.schema6.parse(numbers.number3)).not.toThrow();
+  expect(() => schemas.schema6.parse(numbers.number6)).not.toThrow();
+  expect(() => schemas.schema6.parse(numbers.number7)).toThrow();
+  expect(() => schemas.schema6.parse(numbers.number8)).toThrow();
+  expect(() => schemas.schema7.parse(numbers.number3)).not.toThrow();
+  expect(() => schemas.schema7.parse(numbers.number6)).not.toThrow();
+  expect(() => schemas.schema7.parse(numbers.number7)).not.toThrow();
+  expect(() => schemas.schema7.parse(numbers.number8)).toThrow();
+});
+
 test(".multipleOf() with positive divisor", () => {
   const schema = z.number().multipleOf(5);
   expect(schema.parse(15)).toEqual(15);

package/src/v4/classic/tests/recursive-types.test.ts

@@ -260,6 +260,45 @@ test("mutual recursion with meta", () => {
   expectTypeOf<B>().toEqualTypeOf<_B>();
 });
 
+test("intersection with recursive types", () => {
+  const A = z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("CONTAINER"),
+    }),
+    z.object({
+      type: z.literal("SCREEN"),
+      config: z.object({ x: z.number(), y: z.number() }),
+    }),
+  ]);
+  // type A = z.infer<typeof A>;
+
+  const B = z.object({
+    get children() {
+      return z.array(C).optional();
+    },
+  });
+  // type B = z.infer<typeof B>;
+
+  const C = z.intersection(A, B);
+  type C = z.infer<typeof C>;
+
+  type _C = (
+    | {
+        type: "CONTAINER";
+      }
+    | {
+        type: "SCREEN";
+        config: {
+          x: number;
+          y: number;
+        };
+      }
+  ) & {
+    children?: _C[] | undefined;
+  };
+  expectTypeOf<C>().toEqualTypeOf<_C>();
+});
+
 test("object utilities with recursive types", () => {
   const NodeBase = z.object({
     id: z.string(),

package/src/v4/classic/tests/string.test.ts

@@ -956,3 +956,41 @@ test("E.164 validation", () => {
   expect(validE164Numbers.every((number) => e164Number.safeParse(number).success)).toBe(true);
   expect(invalidE164Numbers.every((number) => e164Number.safeParse(number).success === false)).toBe(true);
 });
+
+test("hostname", () => {
+  const hostname = z.hostname();
+
+  // Valid hostnames
+  hostname.parse("localhost");
+  hostname.parse("example.com");
+  hostname.parse("sub.example.com");
+  hostname.parse("a-b-c.example.com");
+  hostname.parse("123.example.com");
+  hostname.parse("example-123.com");
+  hostname.parse("example-123.1234");
+  hostname.parse("developer.mozilla.org");
+  hostname.parse("hello.world.example.com");
+  hostname.parse("www.google.com");
+  hostname.parse("192.168.1.1");
+  hostname.parse("xn--d1acj3b.com");
+  hostname.parse("xn--d1acj3b.org");
+  hostname.parse("xn--d1acj3b");
+
+  // Invalid hostnames
+  expect(() => hostname.parse("")).toThrow();
+  expect(() => hostname.parse("example..com")).toThrow();
+  expect(() => hostname.parse("example-.com")).toThrow();
+  expect(() => hostname.parse("-example.com")).toThrow();
+  expect(() => hostname.parse("example.com-")).toThrow();
+  expect(() => hostname.parse("example_com")).toThrow();
+  expect(() => hostname.parse("example.com:8080")).toThrow();
+  expect(() => hostname.parse("http://example.com")).toThrow();
+  expect(() => hostname.parse("ht!tp://invalid.com")).toThrow();
+
+  expect(() => hostname.parse("xn--d1acj3b..com")).toThrow();
+  expect(() => hostname.parse("ex@mple.com")).toThrow();
+  expect(() => hostname.parse("[2001:db8::zzzz]")).toThrow();
+  expect(() => hostname.parse("exa mple.com")).toThrow();
+  expect(() => hostname.parse("-example.com")).toThrow();
+  expect(() => hostname.parse("example..com")).toThrow();
+});

package/src/v4/classic/tests/tuple.test.ts

@@ -28,9 +28,9 @@ test("successful validation", () => {
   expect(r2.error!).toMatchInlineSnapshot(`
     [ZodError: [
       {
-        "origin": "array",
         "code": "too_big",
         "maximum": 2,
+        "origin": "array",
         "path": [],
         "message": "Too big: expected array to have <2 items"
       }
@@ -80,9 +80,9 @@ test("async validation", async () => {
   expect(r2.error!).toMatchInlineSnapshot(`
     [ZodError: [
       {
-        "origin": "array",
         "code": "too_big",
         "maximum": 2,
+        "origin": "array",
         "path": [],
         "message": "Too big: expected array to have <2 items"
       }

package/src/v4/core/api.ts

@@ -1449,13 +1449,6 @@ export function _custom<O = unknown, I = O>(
   return schema as any;
 }
 
-// export function _refine<T>(
-//   Class: util.SchemaClass<schemas.$ZodCustom>,
-//   fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>,
-//   _params: string | $ZodCustomParams = {}
-// ): checks.$ZodCheck<T> {
-//   return _custom(Class, fn, _params);
-// }
 // same as _custom but defaults to abort:false
 export function _refine<O = unknown, I = O>(
   Class: util.SchemaClass<schemas.$ZodCustom>,
@@ -1472,6 +1465,56 @@ export function _refine<O = unknown, I = O>(
   return schema as any;
 }
 
+export type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any
+  ? RawIssue<T>
+  : never;
+type RawIssue<T extends errors.$ZodIssueBase> = T extends any
+  ? util.Flatten<
+      util.MakePartial<T, "message" | "path"> & {
+        /** The schema or check that originated this issue. */
+        readonly inst?: schemas.$ZodType | checks.$ZodCheck;
+        /** If `true`, Zod will continue executing checks/refinements after this issue. */
+        readonly continue?: boolean | undefined;
+      } & Record<string, unknown>
+    >
+  : never;
+
+export interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {
+  addIssue(arg: string | $ZodSuperRefineIssue): void;
+}
+
+export function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T> {
+  const ch = _check<T>((payload) => {
+    (payload as $RefinementCtx).addIssue = (issue) => {
+      if (typeof issue === "string") {
+        payload.issues.push(util.issue(issue, payload.value, ch._zod.def));
+      } else {
+        // for Zod 3 backwards compatibility
+        const _issue: any = issue;
+        if (_issue.fatal) _issue.continue = false;
+        _issue.code ??= "custom";
+        _issue.input ??= payload.value;
+        _issue.inst ??= ch;
+        _issue.continue ??= !ch._zod.def.abort;
+        payload.issues.push(util.issue(_issue));
+      }
+    };
+
+    return fn(payload.value, payload as $RefinementCtx<T>);
+  });
+  return ch;
+}
+
+export function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O> {
+  const ch = new checks.$ZodCheck({
+    check: "custom",
+    ...util.normalizeParams(params),
+  });
+
+  ch._zod.check = fn;
+  return ch;
+}
+
 // export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">
 
 /////////    STRINGBOOL   /////////
@@ -1533,6 +1576,7 @@ export function _stringbool(
           values: [...truthySet, ...falsySet],
           input: payload.value,
           inst: tx,
+          continue: false,
         });
         return {} as never;
       }

package/src/v4/core/checks.ts

@@ -297,6 +297,7 @@ export const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat> = /
             expected: origin,
             format: def.format,
             code: "invalid_type",
+            continue: false,
             input,
             inst,
           });
@@ -1152,6 +1153,7 @@ export const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType> = /*@__PURE
         values: def.mime,
         input: payload.value.type,
         inst,
+        continue: !def.abort,
       });
     };
   }

package/src/v4/core/errors.ts

@@ -12,7 +12,6 @@ export interface $ZodIssueBase {
   readonly input?: unknown;
   readonly path: PropertyKey[];
   readonly message: string;
-  // [k: string]: unknown;
 }
 
 ////////////////////////////////
@@ -21,7 +20,7 @@ export interface $ZodIssueBase {
 export interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_type";
   readonly expected: $ZodType["_zod"]["def"]["type"];
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
@@ -30,7 +29,7 @@ export interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {
   readonly maximum: number | bigint;
   readonly inclusive?: boolean;
   readonly exact?: boolean;
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
@@ -41,39 +40,40 @@ export interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {
   readonly inclusive?: boolean;
   /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
   readonly exact?: boolean;
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {
   readonly code: "invalid_format";
   readonly format: $ZodStringFormats | (string & {});
   readonly pattern?: string;
-  readonly input: string;
+  readonly input?: string;
 }
 
 export interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {
   readonly code: "not_multiple_of";
   readonly divisor: number;
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {
   readonly code: "unrecognized_keys";
   readonly keys: string[];
-  readonly input: Record<string, unknown>;
+  readonly input?: Record<string, unknown>;
 }
 
 export interface $ZodIssueInvalidUnion extends $ZodIssueBase {
   readonly code: "invalid_union";
   readonly errors: $ZodIssue[][];
-  readonly input: unknown;
+  readonly input?: unknown;
+  readonly discriminator?: string | undefined;
 }
 
 export interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_key";
   readonly origin: "map" | "record";
   readonly issues: $ZodIssue[];
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {
@@ -81,19 +81,19 @@ export interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase
   readonly origin: "map" | "set";
   readonly key: unknown;
   readonly issues: $ZodIssue[];
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {
   readonly code: "invalid_value";
   readonly values: util.Primitive[];
-  readonly input: Input;
+  readonly input?: Input;
 }
 
 export interface $ZodIssueCustom extends $ZodIssueBase {
   readonly code: "custom";
   readonly params?: Record<string, any> | undefined;
-  readonly input: unknown;
+  readonly input?: unknown;
 }
 
 ////////////////////////////////////////////
@@ -156,17 +156,21 @@ export type $ZodIssue =
 
 export type $ZodIssueCode = $ZodIssue["code"];
 
-export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
-type RawIssue<T extends $ZodIssueBase> = util.Flatten<
-  util.MakePartial<T, "message" | "path"> & {
-    /** The input data */
-    readonly input?: unknown;
-    /** The schema or check that originated this issue. */
-    readonly inst?: $ZodType | $ZodCheck;
-    /** If `true`, Zod will continue executing validation despite this issue. */
-    readonly continue?: boolean | undefined;
-  } & Record<string, any>
->;
+export type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any
+  ? util.Flatten<
+      util.MakePartial<T, "message" | "path"> & {
+        /** The input data */
+        readonly input: unknown;
+        /** The schema or check that originated this issue. */
+        readonly inst?: $ZodType | $ZodCheck;
+        /** If `true`, Zod will continue executing checks/refinements after this issue. */
+        readonly continue?: boolean | undefined;
+      } & Record<string, unknown>
+    >
+  : never;
+
+export type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;
 
 export interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {
   // biome-ignore lint:

package/src/v4/core/regexes.ts

@@ -44,6 +44,7 @@ export const rfc5322Email =
 
 /** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */
 export const unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
+export const idnEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
 
 export const browserEmail: RegExp =
   /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
@@ -69,9 +70,10 @@ export const base64: RegExp = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==
 export const base64url: RegExp = /^[A-Za-z0-9_-]*$/;
 
 // based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
-// export const hostname: RegExp =
-//   /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)+([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/;
-export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
+// export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
+export const hostname: RegExp =
+  /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+
 export const domain: RegExp = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 
 // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
@@ -109,7 +111,8 @@ export function datetime(args: {
   const time = timeSource({ precision: args.precision });
   const opts = ["Z"];
   if (args.local) opts.push("");
-  if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
+  // if (args.offset) opts.push(`([+-]\\d{2}:\\d{2})`);
+  if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
   const timeRegex = `${time}(?:${opts.join("|")})`;
 
   return new RegExp(`^${dateSource}T(?:${timeRegex})$`);