fullstacked 0.12.1-1359 → 0.12.1-1364

package/fullstacked_modules/zod/src/v4/core/schemas.ts

@@ -3,7 +3,7 @@ import * as checks from "./checks.js";
 import * as core from "./core.js";
 import { Doc } from "./doc.js";
 import type * as errors from "./errors.js";
-import { safeParse, safeParseAsync } from "./parse.js";
+import { parse, parseAsync, safeParse, safeParseAsync } from "./parse.js";
 import * as regexes from "./regexes.js";
 import type { StandardSchemaV1 } from "./standard-schema.js";
 import * as util from "./util.js";
@@ -25,11 +25,15 @@ export interface ParseContext<T extends errors.$ZodIssueBase = never> {
 /** @internal */
 export interface ParseContextInternal<T extends errors.$ZodIssueBase = never> extends ParseContext<T> {
   readonly async?: boolean | undefined;
+  readonly direction?: "forward" | "backward";
+  readonly skipChecks?: boolean;
 }
 
 export interface ParsePayload<T = unknown> {
   value: T;
   issues: errors.$ZodRawIssue[];
+  /** A may to mark a whole payload as aborted. Used in codecs/pipes. */
+  aborted?: boolean;
 }
 
 export type CheckFn<T> = (input: ParsePayload<T>) => util.MaybeAsync<void>;
@@ -76,6 +80,7 @@ export interface $ZodTypeDef {
     | "template_literal"
     | "promise"
     | "lazy"
+    | "function"
     | "custom";
   error?: errors.$ZodErrorMap<never> | undefined;
   checks?: checks.$ZodCheck<never>[];
@@ -121,6 +126,9 @@ export interface _$ZodTypeInternals {
    */
   values?: util.PrimitiveSet | undefined;
 
+  /** Default value bubbled up from  */
+  // default?: unknown | undefined;
+
   /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
   propValues?: util.PropValues | undefined;
 
@@ -165,9 +173,7 @@ export interface $ZodType<
   "~standard": $ZodStandardSchema<this>;
 }
 export interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals>
-  extends $ZodType<T["output"], T["input"], T> {
-  // _zod: T;
-}
+  extends $ZodType<T["output"], T["input"], T> {}
 
 export const $ZodType: core.$constructor<$ZodType> = /*@__PURE__*/ core.$constructor("$ZodType", (inst, def) => {
   inst ??= {} as any;
@@ -182,7 +188,6 @@ export const $ZodType: core.$constructor<$ZodType> = /*@__PURE__*/ core.$constru
   if (inst._zod.traits.has("$ZodCheck")) {
     checks.unshift(inst as any);
   }
-  //
 
   for (const ch of checks) {
     for (const fn of ch._zod.onattach) {
@@ -241,9 +246,52 @@ export const $ZodType: core.$constructor<$ZodType> = /*@__PURE__*/ core.$constru
       return payload;
     };
 
+    // const handleChecksResult = (
+    //   checkResult: ParsePayload,
+    //   originalResult: ParsePayload,
+    //   ctx: ParseContextInternal
+    // ): util.MaybeAsync<ParsePayload> => {
+    //   // if the checks mutated the value && there are no issues, re-parse the result
+    //   if (checkResult.value !== originalResult.value && !checkResult.issues.length)
+    //     return inst._zod.parse(checkResult, ctx);
+    //   return originalResult;
+    // };
+    const handleCanaryResult = (canary: ParsePayload, payload: ParsePayload, ctx: ParseContextInternal) => {
+      // abort if the canary is aborted
+      if (util.aborted(canary)) {
+        canary.aborted = true;
+        return canary;
+      }
+
+      // run checks first, then
+      const checkResult = runChecks(payload, checks, ctx);
+      if (checkResult instanceof Promise) {
+        if (ctx.async === false) throw new core.$ZodAsyncError();
+        return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));
+      }
+      return inst._zod.parse(checkResult, ctx);
+    };
+
     inst._zod.run = (payload, ctx) => {
-      const result = inst._zod.parse(payload, ctx);
+      if (ctx.skipChecks) {
+        return inst._zod.parse(payload, ctx);
+      }
+      if (ctx.direction === "backward") {
+        // run canary
+        // initial pass (no checks)
+        const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
+
+        if (canary instanceof Promise) {
+          return canary.then((canary) => {
+            return handleCanaryResult(canary, payload, ctx);
+          });
+        }
+
+        return handleCanaryResult(canary, payload, ctx);
+      }
 
+      // forward
+      const result = inst._zod.parse(payload, ctx);
       if (result instanceof Promise) {
         if (ctx.async === false) throw new core.$ZodAsyncError();
         return result.then((result) => runChecks(result, checks, ctx));
@@ -316,6 +364,7 @@ export const $ZodString: core.$constructor<$ZodString> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "string",
       code: "invalid_type",
+
       input: payload.value,
       inst,
     });
@@ -414,6 +463,7 @@ export const $ZodEmail: core.$constructor<$ZodEmail> = /*@__PURE__*/ core.$const
 export interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
   hostname?: RegExp | undefined;
   protocol?: RegExp | undefined;
+  normalize?: boolean | undefined;
 }
 export interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
   def: $ZodURLDef;
@@ -427,9 +477,10 @@ export const $ZodURL: core.$constructor<$ZodURL> = /*@__PURE__*/ core.$construct
   $ZodStringFormat.init(inst, def);
   inst._zod.check = (payload) => {
     try {
-      const orig = payload.value;
-      const url = new URL(orig);
-      const href = url.href;
+      // Trim whitespace from input
+      const trimmed = payload.value.trim();
+      // @ts-ignore
+      const url = new URL(trimmed);
 
       if (def.hostname) {
         def.hostname.lastIndex = 0;
@@ -461,11 +512,13 @@ export const $ZodURL: core.$constructor<$ZodURL> = /*@__PURE__*/ core.$construct
         }
       }
 
-      // payload.value = url.href;
-      if (!orig.endsWith("/") && href.endsWith("/")) {
-        payload.value = href.slice(0, -1);
+      // Set the output value based on normalize flag
+      if (def.normalize) {
+        // Use normalized URL
+        payload.value = url.href;
       } else {
-        payload.value = href;
+        // Preserve the original input (trimmed)
+        payload.value = trimmed;
       }
 
       return;
@@ -719,6 +772,7 @@ export const $ZodIPv6: core.$constructor<$ZodIPv6> = /*@__PURE__*/ core.$constru
 
   inst._zod.check = (payload) => {
     try {
+      // @ts-ignore
       new URL(`http://[${payload.value}]`);
       // return;
     } catch {
@@ -776,12 +830,15 @@ export const $ZodCIDRv6: core.$constructor<$ZodCIDRv6> = /*@__PURE__*/ core.$con
     $ZodStringFormat.init(inst, def);
 
     inst._zod.check = (payload) => {
-      const [address, prefix] = payload.value.split("/");
+      const parts = payload.value.split("/");
       try {
+        if (parts.length !== 2) throw new Error();
+        const [address, prefix] = parts;
         if (!prefix) throw new Error();
         const prefixNum = Number(prefix);
         if (`${prefixNum}` !== prefix) throw new Error();
         if (prefixNum < 0 || prefixNum > 128) throw new Error();
+        // @ts-ignore
         new URL(`http://[${address}]`);
       } catch {
         payload.issues.push({
@@ -801,6 +858,7 @@ export function isValidBase64(data: string): boolean {
   if (data === "") return true;
   if (data.length % 4 !== 0) return false;
   try {
+    // @ts-ignore
     atob(data);
     return true;
   } catch {
@@ -900,6 +958,7 @@ export function isValidJWT(token: string, algorithm: util.JWTAlgorithm | null =
     if (tokensParts.length !== 3) return false;
     const [header] = tokensParts;
     if (!header) return false;
+    // @ts-ignore
     const parsedHeader = JSON.parse(atob(header));
     if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
     if (!parsedHeader.alg) return false;
@@ -1030,6 +1089,7 @@ export const $ZodNumber: core.$constructor<$ZodNumber> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "number",
       code: "invalid_type",
+
       input,
       inst,
       ...(received ? { received } : {}),
@@ -1100,6 +1160,7 @@ export const $ZodBoolean: core.$constructor<$ZodBoolean> = /*@__PURE__*/ core.$c
       payload.issues.push({
         expected: "boolean",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -1152,6 +1213,7 @@ export const $ZodBigInt: core.$constructor<$ZodBigInt> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "bigint",
       code: "invalid_type",
+
       input: payload.value,
       inst,
     });
@@ -1211,6 +1273,7 @@ export const $ZodSymbol: core.$constructor<$ZodSymbol> = /*@__PURE__*/ core.$con
     payload.issues.push({
       expected: "symbol",
       code: "invalid_type",
+
       input,
       inst,
     });
@@ -1255,6 +1318,7 @@ export const $ZodUndefined: core.$constructor<$ZodUndefined> = /*@__PURE__*/ cor
       payload.issues.push({
         expected: "undefined",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -1297,6 +1361,7 @@ export const $ZodNull: core.$constructor<$ZodNull> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "null",
       code: "invalid_type",
+
       input,
       inst,
     });
@@ -1388,6 +1453,7 @@ export const $ZodNever: core.$constructor<$ZodNever> = /*@__PURE__*/ core.$const
     payload.issues.push({
       expected: "never",
       code: "invalid_type",
+
       input: payload.value,
       inst,
     });
@@ -1425,6 +1491,7 @@ export const $ZodVoid: core.$constructor<$ZodVoid> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "void",
       code: "invalid_type",
+
       input,
       inst,
     });
@@ -1475,6 +1542,7 @@ export const $ZodDate: core.$constructor<$ZodDate> = /*@__PURE__*/ core.$constru
     payload.issues.push({
       expected: "date",
       code: "invalid_type",
+
       input,
       ...(isDate ? { received: "Invalid Date" } : {}),
       inst,
@@ -1524,6 +1592,7 @@ export const $ZodArray: core.$constructor<$ZodArray> = /*@__PURE__*/ core.$const
       payload.issues.push({
         expected: "array",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -1582,6 +1651,36 @@ export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<st
         } & Extra
       >;
 
+// experimental
+// export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = keyof (T &
+//   Extra) extends never
+//   ? Record<string, never>
+//   : string extends keyof T
+//     ? util.Prettify<
+//         {
+//           [k: string]: util.IsAny<T[string]["_zod"]["output"]> extends true ? unknown : T[string]["_zod"]["output"];
+//         } & $InferObjectOutputNoIndex<util.OmitIndexSignature<T>, Extra>
+//       >
+//     : util.Prettify<$InferObjectOutputNoIndex<T, Extra>>;
+
+// export type $InferObjectOutputNoIndex<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = {
+//   [k in keyof T as string extends k
+//     ? never
+//     : k extends string
+//       ? T[k] extends OptionalOutSchema
+//         ? never
+//         : k
+//       : never]: T[k]["_zod"]["output"];
+// } & {
+//   [k in keyof T as string extends k
+//     ? never
+//     : k extends string
+//       ? T[k] extends OptionalOutSchema
+//         ? k
+//         : never
+//       : never]?: T[k]["_zod"]["output"];
+// } & Extra;
+
 export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T
   ? util.IsAny<T[keyof T]> extends true
     ? Record<string, unknown>
@@ -1596,33 +1695,16 @@ export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<str
         } & Extra
       >;
 
-function handleObjectResult(result: ParsePayload, final: ParsePayload, key: PropertyKey) {
-  // if(isOptional)
+function handlePropertyResult(result: ParsePayload, final: ParsePayload, key: PropertyKey, input: any) {
   if (result.issues.length) {
     final.issues.push(...util.prefixIssues(key, result.issues));
   }
 
-  (final.value as any)[key] = result.value;
-}
-
-function handleOptionalObjectResult(result: ParsePayload, final: ParsePayload, key: PropertyKey, input: any) {
-  if (result.issues.length) {
-    // validation failed against value schema
-    if (input[key] === undefined) {
-      // if input was undefined, ignore the error
-      if (key in input) {
-        (final.value as any)[key] = undefined;
-      } else {
-        (final.value as any)[key] = result.value;
-      }
-    } else {
-      final.issues.push(...util.prefixIssues(key, result.issues));
+  if (result.value === undefined) {
+    if (key in input) {
+      (final.value as any)[key] = undefined;
     }
-  } else if (result.value === undefined) {
-    // validation returned `undefined`
-    if (key in input) (final.value as any)[key] = undefined;
   } else {
-    // non-undefined value
     (final.value as any)[key] = result.value;
   }
 }
@@ -1657,7 +1739,7 @@ export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $Zod
 
 export interface $ZodObjectInternals<
   /** @ts-ignore Cast variance */
-  out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>,
+  out Shape extends $ZodShape = $ZodShape,
   out Config extends $ZodObjectConfig = $ZodObjectConfig,
 > extends _$ZodTypeInternals {
   def: $ZodObjectDef<Shape>;
@@ -1666,6 +1748,8 @@ export interface $ZodObjectInternals<
   propValues: util.PropValues;
   output: $InferObjectOutput<Shape, Config["out"]>;
   input: $InferObjectInput<Shape, Config["in"]>;
+  optin?: "optional" | undefined;
+  optout?: "optional" | undefined;
 }
 export type $ZodLooseShape = Record<string, any>;
 
@@ -1677,27 +1761,87 @@ export interface $ZodObject<
   "~standard": $ZodStandardSchema<this>;
 }
 
+function normalizeDef(def: $ZodObjectDef) {
+  const keys = Object.keys(def.shape);
+  for (const k of keys) {
+    if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
+      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+    }
+  }
+  const okeys = util.optionalKeys(def.shape);
+
+  return {
+    ...def,
+    keys,
+    keySet: new Set(keys),
+    numKeys: keys.length,
+    optionalKeys: new Set(okeys),
+  };
+}
+
+function handleCatchall(
+  proms: Promise<any>[],
+  input: any,
+  payload: ParsePayload,
+  ctx: ParseContext,
+  def: ReturnType<typeof normalizeDef>,
+  inst: $ZodObject
+) {
+  const unrecognized: string[] = [];
+  // iterate over input keys
+  const keySet = def.keySet;
+  const _catchall = def.catchall!._zod;
+  const t = _catchall.def.type;
+  for (const key of Object.keys(input)) {
+    if (keySet.has(key)) continue;
+    if (t === "never") {
+      unrecognized.push(key);
+      continue;
+    }
+    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+
+    if (r instanceof Promise) {
+      proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+    } else {
+      handlePropertyResult(r, payload, key, input);
+    }
+  }
+
+  if (unrecognized.length) {
+    payload.issues.push({
+      code: "unrecognized_keys",
+      keys: unrecognized,
+      input,
+      inst,
+    });
+  }
+
+  if (!proms.length) return payload;
+  return Promise.all(proms).then(() => {
+    return payload;
+  });
+}
+
 export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$constructor("$ZodObject", (inst, def) => {
   // requires cast because technically $ZodObject doesn't extend
   $ZodType.init(inst, def);
+  // const sh = def.shape;
+  const desc = Object.getOwnPropertyDescriptor(def, "shape");
+  if (!desc?.get) {
+    const sh = def.shape;
+    Object.defineProperty(def, "shape", {
+      get: () => {
+        const newSh = { ...sh };
+        Object.defineProperty(def, "shape", {
+          value: newSh,
+        });
 
-  const _normalized = util.cached(() => {
-    const keys = Object.keys(def.shape);
-    for (const k of keys) {
-      if (!(def.shape[k] instanceof $ZodType)) {
-        throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
-      }
-    }
-    const okeys = util.optionalKeys(def.shape);
-
-    return {
-      shape: def.shape,
-      keys,
-      keySet: new Set(keys),
-      numKeys: keys.length,
-      optionalKeys: new Set(okeys),
-    };
-  });
+        return newSh;
+      },
+    });
+  }
+
+  const _normalized = util.cached(() => normalizeDef(def));
 
   util.defineLazy(inst._zod, "propValues", () => {
     const shape = def.shape;
@@ -1712,76 +1856,7 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
     return propValues;
   });
 
-  const generateFastpass = (shape: any) => {
-    const doc = new Doc(["shape", "payload", "ctx"]);
-    const normalized = _normalized.value;
-
-    const parseStr = (key: string) => {
-      const k = util.esc(key);
-      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
-    };
-
-    doc.write(`const input = payload.value;`);
-
-    const ids: any = Object.create(null);
-    let counter = 0;
-    for (const key of normalized.keys) {
-      ids[key] = `key_${counter++}`;
-    }
-
-    // A: preserve key order {
-    doc.write(`const newResult = {}`);
-    for (const key of normalized.keys) {
-      if (normalized.optionalKeys.has(key)) {
-        const id = ids[key];
-        doc.write(`const ${id} = ${parseStr(key)};`);
-        const k = util.esc(key);
-        doc.write(`
-        if (${id}.issues.length) {
-          if (input[${k}] === undefined) {
-            if (${k} in input) {
-              newResult[${k}] = undefined;
-            }
-          } else {
-            payload.issues = payload.issues.concat(
-              ${id}.issues.map((iss) => ({
-                ...iss,
-                path: iss.path ? [${k}, ...iss.path] : [${k}],
-              }))
-            );
-          }
-        } else if (${id}.value === undefined) {
-          if (${k} in input) newResult[${k}] = undefined;
-        } else {
-          newResult[${k}] = ${id}.value;
-        }
-        `);
-      } else {
-        const id = ids[key];
-        //  const id = ids[key];
-        doc.write(`const ${id} = ${parseStr(key)};`);
-        doc.write(`
-          if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
-            ...iss,
-            path: iss.path ? [${util.esc(key)}, ...iss.path] : [${util.esc(key)}]
-          })));`);
-        doc.write(`newResult[${util.esc(key)}] = ${id}.value`);
-      }
-    }
-
-    doc.write(`payload.value = newResult;`);
-    doc.write(`return payload;`);
-    const fn = doc.compile();
-    return (payload: any, ctx: any) => fn(shape, payload, ctx);
-  };
-
-  let fastpass!: ReturnType<typeof generateFastpass>;
-
   const isObject = util.isObject;
-  const jit = !core.globalConfig.jitless;
-  const allowsEval = util.allowsEval;
-
-  const fastEnabled = jit && allowsEval.value; // && !def.catchall;
   const catchall = def.catchall;
 
   let value!: typeof _normalized.value;
@@ -1799,88 +1874,124 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
       return payload;
     }
 
-    const proms: Promise<any>[] = [];
+    payload.value = {};
 
-    if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
-      // always synchronous
-      if (!fastpass) fastpass = generateFastpass(def.shape);
-      payload = fastpass(payload, ctx);
-    } else {
-      payload.value = {};
+    const proms: Promise<any>[] = [];
+    const shape = value.shape;
 
-      const shape = value.shape;
-      for (const key of value.keys) {
-        const el = shape[key]!;
-
-        // do not add omitted optional keys
-        // if (!(key in input)) {
-        //   if (optionalKeys.has(key)) continue;
-        //   payload.issues.push({
-        //     code: "invalid_type",
-        //     path: [key],
-        //     expected: "nonoptional",
-        //     note: `Missing required key: "${key}"`,
-        //     input,
-        //     inst,
-        //   });
-        // }
-
-        const r = el._zod.run({ value: input[key], issues: [] }, ctx);
-        const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
-
-        if (r instanceof Promise) {
-          proms.push(
-            r.then((r) =>
-              isOptional ? handleOptionalObjectResult(r, payload, key, input) : handleObjectResult(r, payload, key)
-            )
-          );
-        } else if (isOptional) {
-          handleOptionalObjectResult(r, payload, key, input);
-        } else {
-          handleObjectResult(r, payload, key);
-        }
+    for (const key of value.keys) {
+      const el = shape[key]!;
+      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+      if (r instanceof Promise) {
+        proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+      } else {
+        handlePropertyResult(r, payload, key, input);
       }
     }
 
     if (!catchall) {
-      // return payload;
       return proms.length ? Promise.all(proms).then(() => payload) : payload;
     }
-    const unrecognized: string[] = [];
-    // iterate over input keys
-    const keySet = value.keySet;
-    const _catchall = catchall._zod;
-    const t = _catchall.def.type;
-    for (const key of Object.keys(input)) {
-      if (keySet.has(key)) continue;
-      if (t === "never") {
-        unrecognized.push(key);
-        continue;
+
+    return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
+  };
+});
+
+export const $ZodObjectJIT: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$constructor(
+  "$ZodObjectJIT",
+  (inst, def) => {
+    // requires cast because technically $ZodObject doesn't extend
+    $ZodObject.init(inst, def);
+
+    const superParse = inst._zod.parse;
+    const _normalized = util.cached(() => normalizeDef(def));
+
+    const generateFastpass = (shape: any) => {
+      const doc = new Doc(["shape", "payload", "ctx"]);
+      const normalized = _normalized.value;
+
+      const parseStr = (key: string) => {
+        const k = util.esc(key);
+        return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+      };
+
+      doc.write(`const input = payload.value;`);
+
+      const ids: any = Object.create(null);
+      let counter = 0;
+      for (const key of normalized.keys) {
+        ids[key] = `key_${counter++}`;
       }
-      const r = _catchall.run({ value: input[key], issues: [] }, ctx);
 
-      if (r instanceof Promise) {
-        proms.push(r.then((r) => handleObjectResult(r, payload, key)));
-      } else {
-        handleObjectResult(r, payload, key);
+      // A: preserve key order {
+      doc.write(`const newResult = {};`);
+      for (const key of normalized.keys) {
+        const id = ids[key];
+        const k = util.esc(key);
+        doc.write(`const ${id} = ${parseStr(key)};`);
+        doc.write(`
+        if (${id}.issues.length) {
+          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${k}, ...iss.path] : [${k}]
+          })));
+        }
+        
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
       }
-    }
 
-    if (unrecognized.length) {
-      payload.issues.push({
-        code: "unrecognized_keys",
-        keys: unrecognized,
-        input,
-        inst,
-      });
-    }
+      doc.write(`payload.value = newResult;`);
+      doc.write(`return payload;`);
+      const fn = doc.compile();
+      return (payload: any, ctx: any) => fn(shape, payload, ctx);
+    };
 
-    if (!proms.length) return payload;
-    return Promise.all(proms).then(() => {
-      return payload;
-    });
-  };
-});
+    let fastpass!: ReturnType<typeof generateFastpass>;
+
+    const isObject = util.isObject;
+    const jit = !core.globalConfig.jitless;
+    const allowsEval = util.allowsEval;
+
+    const fastEnabled = jit && allowsEval.value; // && !def.catchall;
+    const catchall = def.catchall;
+
+    let value!: typeof _normalized.value;
+
+    inst._zod.parse = (payload, ctx) => {
+      value ??= _normalized.value;
+      const input = payload.value;
+      if (!isObject(input)) {
+        payload.issues.push({
+          expected: "object",
+          code: "invalid_type",
+          input,
+          inst,
+        });
+        return payload;
+      }
+
+      if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
+        // always synchronous
+        if (!fastpass) fastpass = generateFastpass(def.shape);
+        payload = fastpass(payload, ctx);
+
+        if (!catchall) return payload;
+        return handleCatchall([], input, payload, ctx, value, inst);
+      }
+
+      return superParse(payload, ctx);
+    };
+  }
+);
 
 /////////////////////////////////////////
 /////////////////////////////////////////
@@ -1925,8 +2036,15 @@ function handleUnionResults(results: ParsePayload[], final: ParsePayload, inst:
     }
   }
 
+  const nonaborted = results.filter((r) => !util.aborted(r));
+  if (nonaborted.length === 1) {
+    final.value = nonaborted[0].value;
+    return nonaborted[0];
+  }
+
   final.issues.push({
     code: "invalid_union",
+
     input: final.value,
     inst,
     errors: results.map((result) => result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
@@ -1961,7 +2079,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>[] = [];
@@ -1997,20 +2121,27 @@ export const $ZodUnion: core.$constructor<$ZodUnion> = /*@__PURE__*/ core.$const
 //////////////////////////////////////////////////////
 //////////////////////////////////////////////////////
 
-export interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]>
-  extends $ZodUnionDef<Options> {
-  discriminator: string;
+export interface $ZodDiscriminatedUnionDef<
+  Options extends readonly SomeType[] = readonly $ZodType[],
+  Disc extends string = string,
+> extends $ZodUnionDef<Options> {
+  discriminator: Disc;
   unionFallback?: boolean;
 }
 
-export interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[]>
-  extends $ZodUnionInternals<Options> {
-  def: $ZodDiscriminatedUnionDef<Options>;
+export interface $ZodDiscriminatedUnionInternals<
+  Options extends readonly SomeType[] = readonly $ZodType[],
+  Disc extends string = string,
+> extends $ZodUnionInternals<Options> {
+  def: $ZodDiscriminatedUnionDef<Options, Disc>;
   propValues: util.PropValues;
 }
 
-export interface $ZodDiscriminatedUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
-  _zod: $ZodDiscriminatedUnionInternals<T>;
+export interface $ZodDiscriminatedUnion<
+  Options extends readonly SomeType[] = readonly $ZodType[],
+  Disc extends string = string,
+> extends $ZodType {
+  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
 }
 
 export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
@@ -2039,7 +2170,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       const opts = def.options as $ZodTypeDiscriminable[];
       const map: Map<util.Primitive, $ZodType> = new Map();
       for (const o of opts) {
-        const values = o._zod.propValues[def.discriminator];
+        const values = o._zod.propValues?.[def.discriminator];
         if (!values || values.size === 0)
           throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
         for (const v of values) {
@@ -2057,6 +2188,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       if (!util.isObject(input)) {
         payload.issues.push({
           code: "invalid_type",
+
           expected: "object",
           input,
           inst,
@@ -2076,8 +2208,10 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       // no matching discriminator
       payload.issues.push({
         code: "invalid_union",
+
         errors: [],
         note: "No matching discriminator",
+        discriminator: def.discriminator,
         input,
         path: [def.discriminator],
         inst,
@@ -2103,11 +2237,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 {
@@ -2265,9 +2402,12 @@ type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonl
 export interface $ZodTupleInternals<
   T extends util.TupleItems = readonly $ZodType[],
   Rest extends SomeType | null = $ZodType | null,
-> extends $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>> {
+> extends _$ZodTypeInternals {
   def: $ZodTupleDef<T, Rest>;
   isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<unknown[]> | errors.$ZodIssueTooSmall<unknown[]>;
+  // $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>>
+  output: $InferTupleOutputType<T, Rest>;
+  input: $InferTupleInputType<T, Rest>;
 }
 
 export interface $ZodTuple<
@@ -2302,10 +2442,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;
       }
@@ -2440,6 +2581,7 @@ export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$con
       payload.issues.push({
         expected: "record",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -2483,6 +2625,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,
@@ -2500,8 +2643,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],
@@ -2572,6 +2716,7 @@ export const $ZodMap: core.$constructor<$ZodMap> = /*@__PURE__*/ core.$construct
       payload.issues.push({
         expected: "map",
         code: "invalid_type",
+
         input,
         inst,
       });
@@ -2615,8 +2760,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())),
@@ -2630,6 +2776,7 @@ function handleMapResult(
       final.issues.push({
         origin: "map",
         code: "invalid_element",
+
         input,
         inst,
         key: key,
@@ -2737,8 +2884,8 @@ export const $ZodEnum: core.$constructor<$ZodEnum> = /*@__PURE__*/ core.$constru
   $ZodType.init(inst, def);
 
   const values = util.getEnumValues(def.entries);
-
-  inst._zod.values = new Set<util.Primitive>(values);
+  const valuesSet = new Set<util.Primitive>(values);
+  inst._zod.values = valuesSet;
 
   inst._zod.pattern = new RegExp(
     `^(${values
@@ -2749,11 +2896,12 @@ export const $ZodEnum: core.$constructor<$ZodEnum> = /*@__PURE__*/ core.$constru
 
   inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
-    if (inst._zod.values.has(input)) {
+    if (valuesSet.has(input)) {
       return payload;
     }
     payload.issues.push({
       code: "invalid_value",
+
       values,
       input,
       inst,
@@ -2790,12 +2938,15 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
   "$ZodLiteral",
   (inst, def) => {
     $ZodType.init(inst, def);
+    if (def.values.length === 0) {
+      throw new Error("Cannot create literal schema with no valid values");
+    }
 
     inst._zod.values = new Set<util.Literal>(def.values);
     inst._zod.pattern = new RegExp(
       `^(${def.values
 
-        .map((o) => (typeof o === "string" ? util.escapeRegex(o) : o ? o.toString() : String(o)))
+        .map((o) => (typeof o === "string" ? util.escapeRegex(o) : o ? util.escapeRegex(o.toString()) : String(o)))
         .join("|")})$`
     );
 
@@ -2806,6 +2957,7 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
       }
       payload.issues.push({
         code: "invalid_value",
+
         values: def.values,
         input,
         inst,
@@ -2865,8 +3017,11 @@ export const $ZodLiteral: core.$constructor<$ZodLiteral> = /*@__PURE__*/ core.$c
 //////////////////////////////////////////
 
 // provide a fallback in case the File interface isn't provided in the environment
-declare global {
-  interface File {}
+type _File = typeof globalThis extends { File: infer F extends new (...args: any[]) => any } ? InstanceType<F> : {};
+/** Do not reference this directly. */
+export interface File extends _File {
+  readonly type: string;
+  readonly size: number;
 }
 
 export interface $ZodFileDef extends $ZodTypeDef {
@@ -2892,10 +3047,12 @@ export const $ZodFile: core.$constructor<$ZodFile> = /*@__PURE__*/ core.$constru
 
   inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
+    // @ts-ignore
     if (input instanceof File) return payload;
     payload.issues.push({
       expected: "file",
       code: "invalid_type",
+
       input,
       inst,
     });
@@ -2927,9 +3084,13 @@ export const $ZodTransform: core.$constructor<$ZodTransform> = /*@__PURE__*/ cor
   "$ZodTransform",
   (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.parse = (payload, _ctx) => {
+    inst._zod.parse = (payload, ctx) => {
+      if (ctx.direction === "backward") {
+        throw new core.$ZodEncodeError(inst.constructor.name);
+      }
+
       const _out = def.transform(payload.value, payload);
-      if (_ctx.async) {
+      if (ctx.async) {
         const output = _out instanceof Promise ? _out : Promise.resolve(_out);
         return output.then((output) => {
           payload.value = output;
@@ -2973,6 +3134,13 @@ export interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
   _zod: $ZodOptionalInternals<T>;
 }
 
+function handleOptionalResult(result: ParsePayload, input: unknown) {
+  if (result.issues.length && input === undefined) {
+    return { issues: [], value: undefined };
+  }
+  return result;
+}
+
 export const $ZodOptional: core.$constructor<$ZodOptional> = /*@__PURE__*/ core.$constructor(
   "$ZodOptional",
   (inst, def) => {
@@ -2990,7 +3158,9 @@ export const $ZodOptional: core.$constructor<$ZodOptional> = /*@__PURE__*/ core.
 
     inst._zod.parse = (payload, ctx) => {
       if (def.innerType._zod.optin === "optional") {
-        return def.innerType._zod.run(payload, ctx);
+        const result = def.innerType._zod.run(payload, ctx);
+        if (result instanceof Promise) return result.then((r) => handleOptionalResult(r, payload.value));
+        return handleOptionalResult(result, payload.value);
       }
       if (payload.value === undefined) {
         return payload;
@@ -3043,6 +3213,7 @@ export const $ZodNullable: core.$constructor<$ZodNullable> = /*@__PURE__*/ core.
     });
 
     inst._zod.parse = (payload, ctx) => {
+      // Forward direction (decode): allow null to pass through
       if (payload.value === null) return payload;
       return def.innerType._zod.run(payload, ctx);
     };
@@ -3087,13 +3258,19 @@ export const $ZodDefault: core.$constructor<$ZodDefault> = /*@__PURE__*/ core.$c
     util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
 
     inst._zod.parse = (payload, ctx) => {
+      if (ctx.direction === "backward") {
+        return def.innerType._zod.run(payload, ctx);
+      }
+
+      // Forward direction (decode): apply defaults for undefined input
       if (payload.value === undefined) {
         payload.value = def.defaultValue;
         /**
-         * $ZodDefault always returns the default value immediately.
+         * $ZodDefault returns the default value immediately in forward direction.
          * It doesn't pass the default value into the validator ("prefault"). There's no reason to pass the default value through validation. The validity of the default is enforced by TypeScript statically. Otherwise, it's the responsibility of the user to ensure the default is valid. In the case of pipes with divergent in/out types, you can specify the default on the `in` schema of your ZodPipe to set a "prefault" for the pipe.   */
         return payload;
       }
+      // Forward direction: continue with default handling
       const result = def.innerType._zod.run(payload, ctx);
       if (result instanceof Promise) {
         return result.then((result) => handleDefaultResult(result, def));
@@ -3147,6 +3324,11 @@ export const $ZodPrefault: core.$constructor<$ZodPrefault> = /*@__PURE__*/ core.
     util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
 
     inst._zod.parse = (payload, ctx) => {
+      if (ctx.direction === "backward") {
+        return def.innerType._zod.run(payload, ctx);
+      }
+
+      // Forward direction (decode): apply prefault for undefined input
       if (payload.value === undefined) {
         payload.value = def.defaultValue;
       }
@@ -3281,6 +3463,10 @@ export const $ZodSuccess: core.$constructor<$ZodSuccess> = /*@__PURE__*/ core.$c
     $ZodType.init(inst, def);
 
     inst._zod.parse = (payload, ctx) => {
+      if (ctx.direction === "backward") {
+        throw new core.$ZodEncodeError("ZodSuccess");
+      }
+
       const result = def.innerType._zod.run(payload, ctx);
       if (result instanceof Promise) {
         return result.then((result) => {
@@ -3314,11 +3500,8 @@ export interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef
 }
 
 export interface $ZodCatchInternals<T extends SomeType = $ZodType>
-  extends $ZodTypeInternals<core.output<T>, core.input<T> | util.Whatever> {
+  extends $ZodTypeInternals<core.output<T>, core.input<T>> {
   def: $ZodCatchDef<T>;
-  // qin: T["_zod"]["qin"];
-  // qout: T["_zod"]["qout"];
-
   optin: T["_zod"]["optin"];
   optout: T["_zod"]["optout"];
   isst: never;
@@ -3331,11 +3514,16 @@ export interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
 
 export const $ZodCatch: core.$constructor<$ZodCatch> = /*@__PURE__*/ core.$constructor("$ZodCatch", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.optin = "optional";
+  util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
   util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
   util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
 
   inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+
+    // Forward direction (decode): apply catch logic
     const result = def.innerType._zod.run(payload, ctx);
     if (result instanceof Promise) {
       return result.then((result) => {
@@ -3364,6 +3552,7 @@ export const $ZodCatch: core.$constructor<$ZodCatch> = /*@__PURE__*/ core.$const
         },
         input: payload.value,
       });
+
       payload.issues = [];
     }
 
@@ -3419,6 +3608,10 @@ export interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType =
   type: "pipe";
   in: A;
   out: B;
+  /** Only defined inside $ZodCodec instances. */
+  transform?: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;
+  /** Only defined inside $ZodCodec instances. */
+  reverseTransform?: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;
 }
 
 export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType>
@@ -3428,6 +3621,7 @@ export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends Some
   values: A["_zod"]["values"];
   optin: A["_zod"]["optin"];
   optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
 }
 
 export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
@@ -3439,21 +3633,117 @@ export const $ZodPipe: core.$constructor<$ZodPipe> = /*@__PURE__*/ core.$constru
   util.defineLazy(inst._zod, "values", () => def.in._zod.values);
   util.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
   util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+  util.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
 
   inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      const right = def.out._zod.run(payload, ctx);
+      if (right instanceof Promise) {
+        return right.then((right) => handlePipeResult(right, def.in, ctx));
+      }
+      return handlePipeResult(right, def.in, ctx);
+    }
+
     const left = def.in._zod.run(payload, ctx);
     if (left instanceof Promise) {
-      return left.then((left) => handlePipeResult(left, def, ctx));
+      return left.then((left) => handlePipeResult(left, def.out, ctx));
+    }
+    return handlePipeResult(left, def.out, ctx);
+  };
+});
+
+function handlePipeResult(left: ParsePayload, next: $ZodType, ctx: ParseContextInternal) {
+  if (left.issues.length) {
+    // prevent further checks
+    left.aborted = true;
+    return left;
+  }
+  return next._zod.run({ value: left.value, issues: left.issues }, ctx);
+}
+
+////////////////////////////////////////////
+////////////////////////////////////////////
+//////////                        //////////
+//////////      $ZodCodec         //////////
+//////////                        //////////
+////////////////////////////////////////////
+////////////////////////////////////////////
+export interface $ZodCodecDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodPipeDef<A, B> {
+  transform: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;
+  reverseTransform: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;
+}
+
+export interface $ZodCodecInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType>
+  extends $ZodTypeInternals<core.output<B>, core.input<A>> {
+  def: $ZodCodecDef<A, B>;
+  isst: never;
+  values: A["_zod"]["values"];
+  optin: A["_zod"]["optin"];
+  optout: B["_zod"]["optout"];
+  propValues: A["_zod"]["propValues"];
+}
+
+export interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
+  _zod: $ZodCodecInternals<A, B>;
+}
+
+export const $ZodCodec: core.$constructor<$ZodCodec> = /*@__PURE__*/ core.$constructor("$ZodCodec", (inst, def) => {
+  $ZodType.init(inst, def);
+  util.defineLazy(inst._zod, "values", () => def.in._zod.values);
+  util.defineLazy(inst._zod, "optin", () => def.in._zod.optin);
+  util.defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+  util.defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
+
+  inst._zod.parse = (payload, ctx) => {
+    const direction = ctx.direction || "forward";
+    if (direction === "forward") {
+      const left = def.in._zod.run(payload, ctx);
+      if (left instanceof Promise) {
+        return left.then((left) => handleCodecAResult(left, def, ctx));
+      }
+      return handleCodecAResult(left, def, ctx);
+    } else {
+      const right = def.out._zod.run(payload, ctx);
+      if (right instanceof Promise) {
+        return right.then((right) => handleCodecAResult(right, def, ctx));
+      }
+      return handleCodecAResult(right, def, ctx);
     }
-    return handlePipeResult(left, def, ctx);
   };
 });
 
-function handlePipeResult(left: ParsePayload, def: $ZodPipeDef, ctx: ParseContext) {
-  if (util.aborted(left)) {
+function handleCodecAResult(result: ParsePayload, def: $ZodCodecDef, ctx: ParseContextInternal) {
+  if (result.issues.length) {
+    // prevent further checks
+    result.aborted = true;
+    return result;
+  }
+
+  const direction = ctx.direction || "forward";
+
+  if (direction === "forward") {
+    const transformed = def.transform(result.value, result);
+    if (transformed instanceof Promise) {
+      return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));
+    }
+    return handleCodecTxResult(result, transformed, def.out, ctx);
+  } else {
+    const transformed = def.reverseTransform(result.value, result);
+    if (transformed instanceof Promise) {
+      return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));
+    }
+    return handleCodecTxResult(result, transformed, def.in, ctx);
+  }
+}
+
+function handleCodecTxResult(left: ParsePayload, value: any, nextSchema: SomeType, ctx: ParseContextInternal) {
+  // Check if transform added any issues
+  if (left.issues.length) {
+    left.aborted = true;
     return left;
   }
-  return def.out._zod.run({ value: left.value, issues: left.issues }, ctx);
+
+  return nextSchema._zod.run({ value, issues: left.issues }, ctx);
 }
 
 ////////////////////////////////////////////
@@ -3493,6 +3783,9 @@ export const $ZodReadonly: core.$constructor<$ZodReadonly> = /*@__PURE__*/ core.
     util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
 
     inst._zod.parse = (payload, ctx) => {
+      if (ctx.direction === "backward") {
+        return def.innerType._zod.run(payload, ctx);
+      }
       const result = def.innerType._zod.run(payload, ctx);
       if (result instanceof Promise) {
         return result.then(handleReadonlyResult);
@@ -3518,6 +3811,7 @@ function handleReadonlyResult(payload: ParsePayload): ParsePayload {
 export interface $ZodTemplateLiteralDef extends $ZodTypeDef {
   type: "template_literal";
   parts: $ZodTemplateLiteralPart[];
+  format?: string | undefined;
 }
 export interface $ZodTemplateLiteralInternals<Template extends string = string>
   extends $ZodTypeInternals<Template, Template> {
@@ -3585,7 +3879,8 @@ export const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral> = /*@__
     $ZodType.init(inst, def);
     const regexParts: string[] = [];
     for (const part of def.parts) {
-      if (part instanceof $ZodType) {
+      if (typeof part === "object" && part !== null) {
+        // is Zod schema
         if (!part._zod.pattern) {
           // if (!source)
           throw new Error(`Invalid template literal part, no pattern found: ${[...(part as any)._zod.traits].shift()}`);
@@ -3623,8 +3918,9 @@ export const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral> = /*@__
         payload.issues.push({
           input: payload.value,
           inst,
+
           code: "invalid_format",
-          format: "template_literal",
+          format: def.format ?? "template_literal",
           pattern: inst._zod.pattern.source,
         });
         return payload;
@@ -3635,6 +3931,174 @@ export const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral> = /*@__
   }
 );
 
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////     $ZodFunction     //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+export type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
+export type $ZodFunctionIn = $ZodFunctionArgs;
+export type $ZodFunctionOut = $ZodType;
+
+export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>
+) => core.input<Returns>;
+
+export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>
+) => util.MaybeAsync<core.input<Returns>>;
+
+export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>
+) => core.output<Returns>;
+
+export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (
+  ...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>
+) => util.MaybeAsync<core.output<Returns>>;
+
+export interface $ZodFunctionDef<
+  In extends $ZodFunctionIn = $ZodFunctionIn,
+  Out extends $ZodFunctionOut = $ZodFunctionOut,
+> extends $ZodTypeDef {
+  type: "function";
+  input: In;
+  output: Out;
+}
+
+export interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut>
+  extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
+  def: $ZodFunctionDef<Args, Returns>;
+  isst: errors.$ZodIssueInvalidType;
+}
+
+export interface $ZodFunction<
+  Args extends $ZodFunctionIn = $ZodFunctionIn,
+  Returns extends $ZodFunctionOut = $ZodFunctionOut,
+> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
+  /** @deprecated */
+  _def: $ZodFunctionDef<Args, Returns>;
+  _input: $InferInnerFunctionType<Args, Returns>;
+  _output: $InferOuterFunctionType<Args, Returns>;
+
+  implement<F extends $InferInnerFunctionType<Args, Returns>>(
+    func: F
+  ): // allow for return type inference
+  (
+    ...args: Parameters<this["_output"]>
+  ) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
+
+  implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(
+    func: F
+  ): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
+
+  input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(
+    args: Items,
+    rest?: Rest
+  ): $ZodFunction<$ZodTuple<Items, Rest>, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
+  input(...args: any[]): $ZodFunction<any, Returns>;
+
+  output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
+}
+
+export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends $ZodType> {
+  input?: I;
+  output?: O;
+}
+
+export const $ZodFunction: core.$constructor<$ZodFunction> = /*@__PURE__*/ core.$constructor(
+  "$ZodFunction",
+  (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._def = def;
+    inst._zod.def = def;
+
+    inst.implement = (func) => {
+      if (typeof func !== "function") {
+        throw new Error("implement() must be called with a function");
+      }
+      return function (this: any, ...args: never[]) {
+        const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
+        const result = Reflect.apply(func, this, parsedArgs as never[]);
+        if (inst._def.output) {
+          return parse(inst._def.output, result);
+        }
+        return result as any;
+      };
+    };
+
+    inst.implementAsync = (func) => {
+      if (typeof func !== "function") {
+        throw new Error("implementAsync() must be called with a function");
+      }
+      return async function (this: any, ...args: never[]) {
+        const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;
+        const result = await Reflect.apply(func, this, parsedArgs as never[]);
+        if (inst._def.output) {
+          return await parseAsync(inst._def.output, result);
+        }
+        return result;
+      } as any;
+    };
+
+    inst._zod.parse = (payload, _ctx) => {
+      if (typeof payload.value !== "function") {
+        payload.issues.push({
+          code: "invalid_type",
+          expected: "function",
+          input: payload.value,
+          inst,
+        });
+        return payload;
+      }
+
+      // Check if output is a promise type to determine if we should use async implementation
+      const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise";
+
+      if (hasPromiseOutput) {
+        payload.value = inst.implementAsync(payload.value);
+      } else {
+        payload.value = inst.implement(payload.value);
+      }
+      return payload;
+    };
+
+    inst.input = (...args: any[]): $ZodFunction<any, any> => {
+      const F: any = inst.constructor;
+      if (Array.isArray(args[0])) {
+        return new F({
+          type: "function",
+          input: new $ZodTuple({
+            type: "tuple",
+            items: args[0],
+            rest: args[1],
+          }),
+          output: inst._def.output,
+        });
+      }
+
+      return new F({
+        type: "function",
+        input: args[0],
+        output: inst._def.output,
+      });
+    };
+
+    inst.output = (output) => {
+      const F: any = inst.constructor;
+      return new F({
+        type: "function",
+        input: inst._def.input,
+        output,
+      });
+    };
+
+    return inst;
+  }
+);
+
 /////////////////////////////////////////
 /////////////////////////////////////////
 //////////                     //////////
@@ -3700,11 +4164,18 @@ export interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
 export const $ZodLazy: core.$constructor<$ZodLazy> = /*@__PURE__*/ core.$constructor("$ZodLazy", (inst, def) => {
   $ZodType.init(inst, def);
 
+  // let _innerType!: any;
+  // util.defineLazy(def, "getter", () => {
+  //   if (!_innerType) {
+  //     _innerType = def.getter();
+  //   }
+  //   return () => _innerType;
+  // });
   util.defineLazy(inst._zod, "innerType", () => def.getter() as $ZodType);
   util.defineLazy(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
   util.defineLazy(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
-  util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin);
-  util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout);
+  util.defineLazy(inst._zod, "optin", () => inst._zod.innerType._zod.optin ?? undefined);
+  util.defineLazy(inst._zod, "optout", () => inst._zod.innerType._zod.optout ?? undefined);
   inst._zod.parse = (payload, ctx) => {
     const inner = inst._zod.innerType;
     return inner._zod.run(payload, ctx);
@@ -3800,6 +4271,7 @@ export type $ZodTypes =
   | $ZodSet
   | $ZodLiteral
   | $ZodEnum
+  | $ZodFunction
   | $ZodPromise
   | $ZodLazy
   | $ZodOptional
@@ -3839,4 +4311,7 @@ export type $ZodStringFormatTypes =
   | $ZodBase64
   | $ZodBase64URL
   | $ZodE164
-  | $ZodJWT;
+  | $ZodJWT
+  | $ZodCustomStringFormat<"hex">
+  | $ZodCustomStringFormat<util.HashFormat>
+  | $ZodCustomStringFormat<"hostname">;