zod 4.0.10 → 4.0.11

package/src/v4/core/schemas.ts

@@ -319,6 +319,7 @@ export const $ZodString: core.$constructor<$ZodString> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "string",
       code: "invalid_type",
+
       input: payload.value,
       inst,
     });
@@ -1041,6 +1042,7 @@ export const $ZodNumber: core.$constructor<$ZodNumber> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "number",
       code: "invalid_type",
+
       input,
       inst,
       ...(received ? { received } : {}),
@@ -1111,6 +1113,7 @@ export const $ZodBoolean: core.$constructor<$ZodBoolean> = /*@__PURE__*/ core.$c
       payload.issues.push({
         expected: "boolean",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -1163,6 +1166,7 @@ export const $ZodBigInt: core.$constructor<$ZodBigInt> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "bigint",
       code: "invalid_type",
+
       input: payload.value,
       inst,
     });
@@ -1222,6 +1226,7 @@ export const $ZodSymbol: core.$constructor<$ZodSymbol> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "symbol",
       code: "invalid_type",
+
       input,
       inst,
     });
@@ -1266,6 +1271,7 @@ export const $ZodUndefined: core.$constructor<$ZodUndefined> = /*@__PURE__*/ cor
       payload.issues.push({
         expected: "undefined",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -1308,6 +1314,7 @@ export const $ZodNull: core.$constructor<$ZodNull> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "null",
       code: "invalid_type",
+
       input,
       inst,
     });
@@ -1399,6 +1406,7 @@ export const $ZodNever: core.$constructor<$ZodNever> = /*@__PURE__*/ core.$const
     payload.issues.push({
       expected: "never",
       code: "invalid_type",
+
       input: payload.value,
       inst,
     });
@@ -1436,6 +1444,7 @@ export const $ZodVoid: core.$constructor<$ZodVoid> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "void",
       code: "invalid_type",
+
       input,
       inst,
     });
@@ -1486,6 +1495,7 @@ export const $ZodDate: core.$constructor<$ZodDate> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "date",
       code: "invalid_type",
+
       input,
       ...(isDate ? { received: "Invalid Date" } : {}),
       inst,
@@ -1535,6 +1545,7 @@ export const $ZodArray: core.$constructor<$ZodArray> = /*@__PURE__*/ core.$const
       payload.issues.push({
         expected: "array",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -1801,6 +1812,7 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -1854,6 +1866,7 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
     if (unrecognized.length) {
       payload.issues.push({
         code: "unrecognized_keys",
+
         keys: unrecognized,
         input,
         inst,
@@ -1918,6 +1931,7 @@ function handleUnionResults(results: ParsePayload[], final: ParsePayload, inst:
 
   final.issues.push({
     code: "invalid_union",
+
     input: final.value,
     inst,
     errors: results.map((result) => result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
@@ -1952,7 +1966,13 @@ export const $ZodUnion: core.$constructor<$ZodUnion> = /*@__PURE__*/ core.$const
     return undefined;
   });
 
+  const single = def.options.length === 1;
+  const first = def.options[0]._zod.run;
+
   inst._zod.parse = (payload, ctx) => {
+    if (single) {
+      return first(payload, ctx);
+    }
     let async = false;
 
     const results: util.MaybeAsync<ParsePayload>[] = [];
@@ -2048,6 +2068,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       if (!util.isObject(input)) {
         payload.issues.push({
           code: "invalid_type",
+
           expected: "object",
           input,
           inst,
@@ -2067,6 +2088,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       // no matching discriminator
       payload.issues.push({
         code: "invalid_union",
+
         errors: [],
         note: "No matching discriminator",
         discriminator: def.discriminator,
@@ -2095,11 +2117,14 @@ export interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right ext
 }
 
 export interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType>
-  extends $ZodTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>> {
+  extends _$ZodTypeInternals {
+  // $ZodTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>>
   def: $ZodIntersectionDef<A, B>;
   isst: never;
   optin: A["_zod"]["optin"] | B["_zod"]["optin"];
   optout: A["_zod"]["optout"] | B["_zod"]["optout"];
+  output: core.output<A> & core.output<B>;
+  input: core.input<A> & core.input<B>;
 }
 
 export interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
@@ -2294,10 +2319,11 @@ export const $ZodTuple: core.$constructor<$ZodTuple> = /*@__PURE__*/ core.$const
       const tooSmall = input.length < optStart - 1;
       if (tooBig || tooSmall) {
         payload.issues.push({
+          ...(tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length }),
+
           input,
           inst,
           origin: "array" as const,
-          ...(tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length }),
         });
         return payload;
       }
@@ -2432,6 +2458,7 @@ export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$con
       payload.issues.push({
         expected: "record",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -2475,6 +2502,7 @@ export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$con
       if (unrecognized && unrecognized.length > 0) {
         payload.issues.push({
           code: "unrecognized_keys",
+
           input,
           inst,
           keys: unrecognized,
@@ -2492,8 +2520,9 @@ export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$con
 
         if (keyResult.issues.length) {
           payload.issues.push({
-            origin: "record",
             code: "invalid_key",
+
+            origin: "record",
             issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
             input: key,
             path: [key],
@@ -2564,6 +2593,7 @@ export const $ZodMap: core.$constructor<$ZodMap> = /*@__PURE__*/ core.$construct
       payload.issues.push({
         expected: "map",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -2607,8 +2637,9 @@ function handleMapResult(
       final.issues.push(...util.prefixIssues(key as PropertyKey, keyResult.issues));
     } else {
       final.issues.push({
-        origin: "map",
         code: "invalid_key",
+
+        origin: "map",
         input,
         inst,
         issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
@@ -2622,6 +2653,7 @@ function handleMapResult(
       final.issues.push({
         origin: "map",
         code: "invalid_element",
+
         input,
         inst,
         key: key,
@@ -2746,6 +2778,7 @@ export const $ZodEnum: core.$constructor<$ZodEnum> = /*@__PURE__*/ core.$constru
     }
     payload.issues.push({
       code: "invalid_value",
+
       values,
       input,
       inst,
@@ -2801,6 +2834,7 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
       }
       payload.issues.push({
         code: "invalid_value",
+
         values: def.values,
         input,
         inst,
@@ -2895,6 +2929,7 @@ export const $ZodFile: core.$constructor<$ZodFile> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "file",
       code: "invalid_type",
+
       input,
       inst,
     });
@@ -3203,6 +3238,7 @@ function handleNonOptionalResult(payload: ParsePayload, inst: $ZodNonOptional) {
   if (!payload.issues.length && payload.value === undefined) {
     payload.issues.push({
       code: "invalid_type",
+
       expected: "nonoptional",
       input: payload.value,
       inst,
@@ -3623,6 +3659,7 @@ export const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral> = /*@__
         payload.issues.push({
           input: payload.value,
           inst,
+
           code: "invalid_format",
           format: def.format ?? "template_literal",
           pattern: inst._zod.pattern.source,

package/src/v4/core/util.ts

@@ -123,6 +123,7 @@ export type Identity<T> = T;
 export type Flatten<T> = Identity<{ [k in keyof T]: T[k] }>;
 export type Mapped<T> = { [k in keyof T]: T[k] };
 export type Prettify<T> = {
+  // @ts-ignore
   [K in keyof T]: T[K];
 } & {};
 
@@ -241,7 +242,15 @@ export function cleanRegex(source: string): string {
 
 export function floatSafeRemainder(val: number, step: number): number {
   const valDecCount = (val.toString().split(".")[1] || "").length;
-  const stepDecCount = (step.toString().split(".")[1] || "").length;
+  const stepString = step.toString();
+  let stepDecCount = (stepString.split(".")[1] || "").length;
+  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
+    const match = stepString.match(/\d?e-(\d?)/);
+    if (match?.[1]) {
+      stepDecCount = Number.parseInt(match[1]);
+    }
+  }
+
   const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
   const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
@@ -717,6 +726,7 @@ export function required(
 
 export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
 
+// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
 export function aborted(x: schemas.ParsePayload, startIndex = 0): boolean {
   for (let i = startIndex; i < x.issues.length; i++) {
     if (x.issues[i]?.continue !== true) {

package/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 0,
-  patch: 10 as number,
+  patch: 11 as number,
 } as const;

package/src/v4/locales/index.ts

@@ -39,3 +39,4 @@ export { default as ur } from "./ur.js";
 export { default as vi } from "./vi.js";
 export { default as zhCN } from "./zh-CN.js";
 export { default as zhTW } from "./zh-TW.js";
+export { default as yo } from "./yo.js";

package/src/v4/locales/yo.ts

@@ -0,0 +1,131 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "àmi", verb: "ní" },
+    file: { unit: "bytes", verb: "ní" },
+    array: { unit: "nkan", verb: "ní" },
+    set: { unit: "nkan", verb: "ní" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const parsedType = (data: any): string => {
+    const t = typeof data;
+
+    switch (t) {
+      case "number": {
+        return Number.isNaN(data) ? "NaN" : "nọ́mbà";
+      }
+      case "object": {
+        if (Array.isArray(data)) {
+          return "akopọ";
+        }
+        if (data === null) {
+          return "null";
+        }
+        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+          return data.constructor.name;
+        }
+      }
+    }
+    return t;
+  };
+
+  const Nouns: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "ẹ̀rọ ìbáwọlé",
+    email: "àdírẹ́sì ìmẹ́lì",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "àkókò ISO",
+    date: "ọjọ́ ISO",
+    time: "àkókò ISO",
+    duration: "àkókò tó pé ISO",
+    ipv4: "àdírẹ́sì IPv4",
+    ipv6: "àdírẹ́sì IPv6",
+    cidrv4: "àgbègbè IPv4",
+    cidrv6: "àgbègbè IPv6",
+    base64: "ọ̀rọ̀ tí a kọ́ ní base64",
+    base64url: "ọ̀rọ̀ base64url",
+    json_string: "ọ̀rọ̀ JSON",
+    e164: "nọ́mbà E.164",
+    jwt: "JWT",
+    template_literal: "ẹ̀rọ ìbáwọlé",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type":
+        return `Ìbáwọlé aṣìṣe: a ní láti fi ${issue.expected}, àmọ̀ a rí ${parsedType(issue.input)}`;
+
+      case "invalid_value":
+        if (issue.values.length === 1) return `Ìbáwọlé aṣìṣe: a ní láti fi ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Àṣàyàn aṣìṣe: yan ọ̀kan lára ${util.joinValues(issue.values, "|")}`;
+
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Tó pọ̀ jù: a ní láti jẹ́ pé ${issue.origin ?? "iye"} ${sizing.verb} ${adj}${issue.maximum} ${sizing.unit}`;
+        return `Tó pọ̀ jù: a ní láti jẹ́ ${adj}${issue.maximum}`;
+      }
+
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Kéré ju: a ní láti jẹ́ pé ${issue.origin} ${sizing.verb} ${adj}${issue.minimum} ${sizing.unit}`;
+        return `Kéré ju: a ní láti jẹ́ ${adj}${issue.minimum}`;
+      }
+
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bẹ̀rẹ̀ pẹ̀lú "${_issue.prefix}"`;
+        if (_issue.format === "ends_with") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ parí pẹ̀lú "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ ní "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bá àpẹẹrẹ mu ${_issue.pattern}`;
+        return `Aṣìṣe: ${Nouns[_issue.format] ?? issue.format}`;
+      }
+
+      case "not_multiple_of":
+        return `Nọ́mbà aṣìṣe: gbọ́dọ̀ jẹ́ èyà pípín ti ${issue.divisor}`;
+
+      case "unrecognized_keys":
+        return `Bọtìnì àìmọ̀: ${util.joinValues(issue.keys, ", ")}`;
+
+      case "invalid_key":
+        return `Bọtìnì aṣìṣe nínú ${issue.origin}`;
+
+      case "invalid_union":
+        return "Ìbáwọlé aṣìṣe";
+
+      case "invalid_element":
+        return `Iye aṣìṣe nínú ${issue.origin}`;
+
+      default:
+        return "Ìbáwọlé aṣìṣe";
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

package/src/v4/mini/schemas.ts

@@ -436,6 +436,10 @@ export function stringFormat<Format extends string>(
   return core._stringFormat(ZodMiniCustomStringFormat, format, fnOrRegex, _params) as any;
 }
 
+export function hostname(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hostname"> {
+  return core._stringFormat(ZodMiniCustomStringFormat, "hostname", core.regexes.hostname, _params) as any;
+}
+
 // ZodMiniNumber
 interface _ZodMiniNumber<T extends core.$ZodNumberInternals<unknown> = core.$ZodNumberInternals<unknown>>
   extends _ZodMiniType<T>,
@@ -1520,6 +1524,13 @@ export function refine<T>(
   return core._refine(ZodMiniCustom, fn, _params);
 }
 
+// superRefine
+export function superRefine<T>(
+  fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>
+): core.$ZodCheck<T> {
+  return core._superRefine(fn);
+}
+
 // instanceof
 abstract class Class {
   constructor(..._args: any[]) {}

package/v3/locales/en.cjs

@@ -109,3 +109,4 @@ const errorMap = (issue, _ctx) => {
     return { message };
 };
 exports.default = errorMap;
+module.exports = exports.default;

package/v3/locales/en.d.cts

@@ -1,3 +1,3 @@
 import { type ZodErrorMap } from "../ZodError.cjs";
 declare const errorMap: ZodErrorMap;
-export default errorMap;
+export = errorMap;

package/v4/classic/checks.d.cts

@@ -1 +1 @@
-export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, } from "../core/index.cjs";
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, type $RefinementCtx as RefinementCtx, } from "../core/index.cjs";

package/v4/classic/checks.d.ts

@@ -1 +1 @@
-export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, } from "../core/index.js";
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, type $RefinementCtx as RefinementCtx, } from "../core/index.js";

package/v4/classic/schemas.cjs

@@ -49,6 +49,7 @@ exports.base64url = base64url;
 exports.e164 = e164;
 exports.jwt = jwt;
 exports.stringFormat = stringFormat;
+exports.hostname = hostname;
 exports.number = number;
 exports.int = int;
 exports.float32 = float32;
@@ -416,6 +417,9 @@ exports.ZodCustomStringFormat = core.$constructor("ZodCustomStringFormat", (inst
 function stringFormat(format, fnOrRegex, _params = {}) {
     return core._stringFormat(exports.ZodCustomStringFormat, format, fnOrRegex, _params);
 }
+function hostname(_params) {
+    return core._stringFormat(exports.ZodCustomStringFormat, "hostname", core.regexes.hostname, _params);
+}
 exports.ZodNumber = core.$constructor("ZodNumber", (inst, def) => {
     core.$ZodNumber.init(inst, def);
     exports.ZodType.init(inst, def);
@@ -1056,26 +1060,7 @@ function refine(fn, _params = {}) {
 }
 // superRefine
 function superRefine(fn) {
-    const ch = check((payload) => {
-        payload.addIssue = (issue) => {
-            if (typeof issue === "string") {
-                payload.issues.push(index_js_1.util.issue(issue, payload.value, ch._zod.def));
-            }
-            else {
-                // for Zod 3 backwards compatibility
-                const _issue = issue;
-                if (_issue.fatal)
-                    _issue.continue = false;
-                _issue.code ?? (_issue.code = "custom");
-                _issue.input ?? (_issue.input = payload.value);
-                _issue.inst ?? (_issue.inst = ch);
-                _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
-                payload.issues.push(index_js_1.util.issue(_issue));
-            }
-        };
-        return fn(payload.value, payload);
-    });
-    return ch;
+    return core._superRefine(fn);
 }
 function _instanceof(cls, params = {
     error: `Input not instance of ${cls.name}`,

package/v4/classic/schemas.d.cts

@@ -1,9 +1,6 @@
 import * as core from "../core/index.cjs";
 import { util } from "../core/index.cjs";
 import * as parse from "./parse.cjs";
-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, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
     def: Internals["def"];
     type: Internals["def"]["type"];
@@ -25,7 +22,7 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;
     spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<parse.ZodSafeParseResult<core.output<this>>>;
     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>): this;
+    superRefine(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;
     optional(): ZodOptional<this>;
     nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
@@ -38,7 +35,7 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     array(): ZodArray<this>;
     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>): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>>;
+    transform<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>;
     pipe<T extends core.$ZodType<any, core.output<this>>>(target: T | core.$ZodType<any, core.output<this>>): ZodPipe<this, T>;
@@ -257,6 +254,7 @@ export interface ZodCustomStringFormat<Format extends string = string> extends Z
 }
 export declare const ZodCustomStringFormat: core.$constructor<ZodCustomStringFormat>;
 export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<Format>;
+export declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hostname">;
 export interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals> extends _ZodType<Internals> {
     gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
     /** Identical to .min() */
@@ -596,7 +594,7 @@ export declare const ZodCustom: core.$constructor<ZodCustom>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
-export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
+export declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
 export { _instanceof as instanceof };
@@ -618,4 +616,4 @@ export interface ZodJSONSchema extends _ZodJSONSchema {
     _zod: ZodJSONSchemaInternals;
 }
 export declare function json(params?: string | core.$ZodCustomParams): ZodJSONSchema;
-export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;
+export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;

package/v4/classic/schemas.d.ts

@@ -1,9 +1,6 @@
 import * as core from "../core/index.js";
 import { util } from "../core/index.js";
 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, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
     def: Internals["def"];
     type: Internals["def"]["type"];
@@ -25,7 +22,7 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;
     spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<parse.ZodSafeParseResult<core.output<this>>>;
     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>): this;
+    superRefine(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;
     optional(): ZodOptional<this>;
     nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
@@ -38,7 +35,7 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     array(): ZodArray<this>;
     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>): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>>;
+    transform<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>;
     pipe<T extends core.$ZodType<any, core.output<this>>>(target: T | core.$ZodType<any, core.output<this>>): ZodPipe<this, T>;
@@ -257,6 +254,7 @@ export interface ZodCustomStringFormat<Format extends string = string> extends Z
 }
 export declare const ZodCustomStringFormat: core.$constructor<ZodCustomStringFormat>;
 export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<Format>;
+export declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<"hostname">;
 export interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals> extends _ZodType<Internals> {
     gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
     /** Identical to .min() */
@@ -596,7 +594,7 @@ export declare const ZodCustom: core.$constructor<ZodCustom>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
-export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
+export declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
 export { _instanceof as instanceof };
@@ -618,4 +616,4 @@ export interface ZodJSONSchema extends _ZodJSONSchema {
     _zod: ZodJSONSchemaInternals;
 }
 export declare function json(params?: string | core.$ZodCustomParams): ZodJSONSchema;
-export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;
+export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;