zod 4.1.0-canary.20250821T014902 → 4.1.0-canary.20250823T064644

package/src/v4/core/api.ts

@@ -1476,7 +1476,7 @@ type RawIssue<T extends errors.$ZodIssueBase> = T extends any
       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. */
+        /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
         readonly continue?: boolean | undefined;
       } & Record<string, unknown>
     >
@@ -1498,7 +1498,7 @@ export function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void
         _issue.code ??= "custom";
         _issue.input ??= payload.value;
         _issue.inst ??= ch;
-        _issue.continue ??= !ch._zod.def.abort;
+        _issue.continue ??= !ch._zod.def.abort; // abort is always undefined, so this is always true...
         payload.issues.push(util.issue(_issue));
       }
     };
@@ -1536,16 +1536,12 @@ export interface $ZodStringBoolParams extends TypeParams {
 
 export function _stringbool(
   Classes: {
-    Pipe?: typeof schemas.$ZodPipe;
+    Codec?: typeof schemas.$ZodCodec;
     Boolean?: typeof schemas.$ZodBoolean;
-    Transform?: typeof schemas.$ZodTransform;
     String?: typeof schemas.$ZodString;
   },
   _params?: string | $ZodStringBoolParams
-): schemas.$ZodPipe<
-  schemas.$ZodPipe<schemas.$ZodString, schemas.$ZodTransform<boolean, string>>,
-  schemas.$ZodBoolean<boolean>
-> {
+): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean> {
   const params = util.normalizeParams(_params);
 
   let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
@@ -1558,15 +1554,19 @@ export function _stringbool(
   const truthySet = new Set(truthyArray);
   const falsySet = new Set(falsyArray);
 
-  const _Pipe = Classes.Pipe ?? schemas.$ZodPipe;
+  const _Codec = Classes.Codec ?? schemas.$ZodCodec;
   const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean;
   const _String = Classes.String ?? schemas.$ZodString;
-  const _Transform = Classes.Transform ?? schemas.$ZodTransform;
 
-  const tx = new _Transform({
-    type: "transform",
-    transform: (input, payload: schemas.ParsePayload<unknown>) => {
-      let data: string = input as string;
+  const stringSchema = new _String({ type: "string", error: params.error });
+  const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
+
+  const codec = new _Codec({
+    type: "pipe",
+    in: stringSchema as any,
+    out: booleanSchema as any,
+    transform: ((input: string, payload: schemas.ParsePayload<string>) => {
+      let data: string = input;
       if (params.case !== "sensitive") data = data.toLowerCase();
       if (truthySet.has(data)) {
         return true;
@@ -1578,33 +1578,23 @@ export function _stringbool(
           expected: "stringbool",
           values: [...truthySet, ...falsySet],
           input: payload.value,
-          inst: tx,
+          inst: codec,
           continue: false,
         });
         return {} as never;
       }
-    },
-    error: params.error,
-  });
-  // params.error;
-
-  const innerPipe = new _Pipe({
-    type: "pipe",
-    in: new _String({ type: "string", error: params.error }),
-    out: tx,
+    }) as any,
+    reverseTransform: ((input: boolean, _payload: schemas.ParsePayload<boolean>) => {
+      if (input === true) {
+        return truthyArray[0] || "true";
+      } else {
+        return falsyArray[0] || "false";
+      }
+    }) as any,
     error: params.error,
-  });
+  }) as any;
 
-  const outerPipe = new _Pipe({
-    type: "pipe",
-    in: innerPipe,
-    out: new _Boolean({
-      type: "boolean",
-      error: params.error,
-    }),
-    error: params.error,
-  });
-  return outerPipe as any;
+  return codec;
 }
 
 export function _stringFormat<Format extends string>(

package/src/v4/core/core.ts

@@ -78,6 +78,13 @@ export class $ZodAsyncError extends Error {
   }
 }
 
+export class $ZodEncodeError extends Error {
+  constructor(name: string) {
+    super(`Encountered unidirectional transform during encode: ${name}`);
+    this.name = "ZodEncodeError";
+  }
+}
+
 ////////////////////////////  TYPE HELPERS  ///////////////////////////////////
 
 // export type input<T extends schemas.$ZodType> = T["_zod"]["input"];
@@ -87,32 +94,6 @@ export class $ZodAsyncError extends Error {
 export type input<T> = T extends { _zod: { input: any } } ? T["_zod"]["input"] : unknown;
 export type output<T> = T extends { _zod: { output: any } } ? T["_zod"]["output"] : unknown;
 
-// Mk2
-// export type input<T> = T extends { _zod: { "~input": any } }
-//   ? T["_zod"]["~input"]
-//   : T extends { _zod: { input: any } }
-//     ? T["_zod"]["input"]
-//     : never;
-// export type output<T> = T extends { _zod: { "~output": any } }
-//   ? T["_zod"]["~output"]
-//   : T extends { _zod: { output: any } }
-//     ? T["_zod"]["output"]
-//     : never;
-// Mk 3
-// export type input<T extends schemas.$ZodType> = T["_zod"]["input"];
-// export type output<T extends schemas.$ZodType> = T["_zod"]["output"];
-// Mk 4
-// export type input<T extends schemas.$ZodType> = T[] extends { _zod: { "~input": any } }
-//   ? T["_zod"]["~input"]
-//   : T extends { _zod: { input: any } }
-//     ? T["_zod"]["input"]
-//     : never;
-// export type output<T extends schemas.$ZodType> = T extends { _zod: { "~output": any } }
-//   ? T["_zod"]["~output"]
-//   : T extends { _zod: { output: any } }
-//     ? T["_zod"]["output"]
-//     : never;
-
 export type { output as infer };
 
 //////////////////////////////   CONFIG   ///////////////////////////////////////

package/src/v4/core/index.ts

@@ -9,7 +9,6 @@ export * as regexes from "./regexes.js";
 export * as locales from "../locales/index.js";
 export * from "./registries.js";
 export * from "./doc.js";
-export * from "./function.js";
 export * from "./api.js";
 export * from "./to-json-schema.js";
 export * as JSONSchema from "./json-schema.js";

package/src/v4/core/json-schema.ts

@@ -104,6 +104,7 @@ export type JSONSchema = {
   deprecated?: boolean;
   readOnly?: boolean;
   writeOnly?: boolean;
+  nullable?: boolean;
   examples?: unknown[];
   format?: string;
   contentMediaType?: string;

package/src/v4/core/parse.ts

@@ -92,3 +92,104 @@ export const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync = (_Err)
 };
 
 export const safeParseAsync: $SafeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);
+
+// Codec functions
+export type $Encode = <T extends schemas.$ZodType>(
+  schema: T,
+  value: core.output<T>,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => core.input<T>;
+
+export const _encode: (_Err: $ZodErrorClass) => $Encode = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" as const }) : { direction: "backward" as const };
+  return _parse(_Err)(schema, value, ctx as any) as any;
+};
+
+export const encode: $Encode = /* @__PURE__*/ _encode(errors.$ZodRealError);
+
+export type $Decode = <T extends schemas.$ZodType>(
+  schema: T,
+  value: core.input<T>,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => core.output<T>;
+
+export const _decode: (_Err: $ZodErrorClass) => $Decode = (_Err) => (schema, value, _ctx) => {
+  return _parse(_Err)(schema, value, _ctx);
+};
+
+export const decode: $Decode = /* @__PURE__*/ _decode(errors.$ZodRealError);
+
+export type $EncodeAsync = <T extends schemas.$ZodType>(
+  schema: T,
+  value: core.output<T>,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => Promise<core.input<T>>;
+
+export const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" as const }) : { direction: "backward" as const };
+  return _parseAsync(_Err)(schema, value, ctx as any) as any;
+};
+
+export const encodeAsync: $EncodeAsync = /* @__PURE__*/ _encodeAsync(errors.$ZodRealError);
+
+export type $DecodeAsync = <T extends schemas.$ZodType>(
+  schema: T,
+  value: core.input<T>,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => Promise<core.output<T>>;
+
+export const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync = (_Err) => async (schema, value, _ctx) => {
+  return _parseAsync(_Err)(schema, value, _ctx);
+};
+
+export const decodeAsync: $DecodeAsync = /* @__PURE__*/ _decodeAsync(errors.$ZodRealError);
+
+export type $SafeEncode = <T extends schemas.$ZodType>(
+  schema: T,
+  value: core.output<T>,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => util.SafeParseResult<core.input<T>>;
+
+export const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" as const }) : { direction: "backward" as const };
+  return _safeParse(_Err)(schema, value, ctx as any) as any;
+};
+
+export const safeEncode: $SafeEncode = /* @__PURE__*/ _safeEncode(errors.$ZodRealError);
+
+export type $SafeDecode = <T extends schemas.$ZodType>(
+  schema: T,
+  value: core.input<T>,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => util.SafeParseResult<core.output<T>>;
+
+export const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode = (_Err) => (schema, value, _ctx) => {
+  return _safeParse(_Err)(schema, value, _ctx);
+};
+
+export const safeDecode: $SafeDecode = /* @__PURE__*/ _safeDecode(errors.$ZodRealError);
+
+export type $SafeEncodeAsync = <T extends schemas.$ZodType>(
+  schema: T,
+  value: core.output<T>,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => Promise<util.SafeParseResult<core.input<T>>>;
+
+export const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" as const }) : { direction: "backward" as const };
+  return _safeParseAsync(_Err)(schema, value, ctx as any) as any;
+};
+
+export const safeEncodeAsync: $SafeEncodeAsync = /* @__PURE__*/ _safeEncodeAsync(errors.$ZodRealError);
+
+export type $SafeDecodeAsync = <T extends schemas.$ZodType>(
+  schema: T,
+  value: core.input<T>,
+  _ctx?: schemas.ParseContext<errors.$ZodIssue>
+) => Promise<util.SafeParseResult<core.output<T>>>;
+
+export const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
+  return _safeParseAsync(_Err)(schema, value, _ctx);
+};
+
+export const safeDecodeAsync: $SafeDecodeAsync = /* @__PURE__*/ _safeDecodeAsync(errors.$ZodRealError);

package/src/v4/core/regexes.ts

@@ -21,7 +21,7 @@ export const guid: RegExp = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9
  * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
 export const uuid = (version?: number | undefined): RegExp => {
   if (!version)
-    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
+    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
   return new RegExp(
     `^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`
   );
@@ -136,3 +136,42 @@ export { _undefined as undefined };
 export const lowercase: RegExp = /^[^A-Z]*$/;
 // regex for string with no lowercase letters
 export const uppercase: RegExp = /^[^a-z]*$/;
+
+// regex for hexadecimal strings (any length)
+export const hex: RegExp = /^[0-9a-fA-F]*$/;
+
+// Hash regexes for different algorithms and encodings
+// Helper function to create base64 regex with exact length and padding
+function fixedBase64(bodyLength: number, padding: "" | "=" | "=="): RegExp {
+  return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
+}
+
+// Helper function to create base64url regex with exact length (no padding)
+function fixedBase64url(length: number): RegExp {
+  return new RegExp(`^[A-Za-z0-9-_]{${length}}$`);
+}
+
+// MD5 (16 bytes): base64 = 24 chars total (22 + "==")
+export const md5_hex: RegExp = /^[0-9a-fA-F]{32}$/;
+export const md5_base64: RegExp = /*@__PURE__*/ fixedBase64(22, "==");
+export const md5_base64url: RegExp = /*@__PURE__*/ fixedBase64url(22);
+
+// SHA1 (20 bytes): base64 = 28 chars total (27 + "=")
+export const sha1_hex: RegExp = /^[0-9a-fA-F]{40}$/;
+export const sha1_base64: RegExp = /*@__PURE__*/ fixedBase64(27, "=");
+export const sha1_base64url: RegExp = /*@__PURE__*/ fixedBase64url(27);
+
+// SHA256 (32 bytes): base64 = 44 chars total (43 + "=")
+export const sha256_hex: RegExp = /^[0-9a-fA-F]{64}$/;
+export const sha256_base64: RegExp = /*@__PURE__*/ fixedBase64(43, "=");
+export const sha256_base64url: RegExp = /*@__PURE__*/ fixedBase64url(43);
+
+// SHA384 (48 bytes): base64 = 64 chars total (no padding)
+export const sha384_hex: RegExp = /^[0-9a-fA-F]{96}$/;
+export const sha384_base64: RegExp = /*@__PURE__*/ fixedBase64(64, "");
+export const sha384_base64url: RegExp = /*@__PURE__*/ fixedBase64url(64);
+
+// SHA512 (64 bytes): base64 = 88 chars total (86 + "==")
+export const sha512_hex: RegExp = /^[0-9a-fA-F]{128}$/;
+export const sha512_base64: RegExp = /*@__PURE__*/ fixedBase64(86, "==");
+export const sha512_base64url: RegExp = /*@__PURE__*/ fixedBase64url(86);