zod 4.1.4 → 4.1.6-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.1.4",
+  "version": "4.1.6-beta.0",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",
@@ -126,7 +126,7 @@
   "scripts": {
     "clean": "git clean -xdf . -e node_modules",
     "build": "zshy --project tsconfig.build.json",
-    "postbuild": "pnpm biome check --write .",
+    "postbuild": "tsx ../../scripts/write-stub-package-jsons.ts && pnpm biome check --write .",
     "test:watch": "pnpm vitest",
     "test": "pnpm vitest run",
     "prepublishOnly": "tsx ../../scripts/check-versions.ts"

package/src/v4/classic/schemas.ts

@@ -89,7 +89,7 @@ export interface ZodType<
   nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
   nullable(): ZodNullable<this>;
   nullish(): ZodOptional<ZodNullable<this>>;
-  default(def: core.output<this>): ZodDefault<this>;
+  default(def: util.NoUndefined<core.output<this>>): ZodDefault<this>;
   default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this>;
   prefault(def: () => core.input<this>): ZodPrefault<this>;
   prefault(def: core.input<this>): ZodPrefault<this>;
@@ -1931,8 +1931,8 @@ export function codec<const A extends core.SomeType, B extends core.SomeType = c
   in_: A,
   out: B,
   params: {
-    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.input<B>;
-    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.output<A>;
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
   }
 ): ZodCodec<A, B> {
   return new ZodCodec({
@@ -2059,11 +2059,11 @@ export const ZodFunction: core.$constructor<ZodFunction> = /*@__PURE__*/ core.$c
 );
 
 export function _function(): ZodFunction;
-export function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>>(params: {
+export function _function<const In extends ReadonlyArray<core.$ZodType>>(params: {
   input: In;
 }): ZodFunction<ZodTuple<In, null>, core.$ZodFunctionOut>;
 export function _function<
-  const In extends Array<core.$ZodType> = Array<core.$ZodType>,
+  const In extends ReadonlyArray<core.$ZodType>,
   const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut,
 >(params: {
   input: In;

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

@@ -414,11 +414,11 @@ test("codec type enforcement - correct encode/decode signatures", () => {
     encode: (value: number) => String(value), // core.input<B> -> core.output<A>
   });
 
-  // These should compile without errors - correct types
-  expectTypeOf<(value: string, payload: z.core.ParsePayload<string>) => number>(
+  // These should compile without errors - correct types (async support)
+  expectTypeOf<(value: string, payload: z.core.ParsePayload<string>) => z.core.util.MaybeAsync<number>>(
     stringToNumberCodec.def.transform
   ).toBeFunction();
-  expectTypeOf<(value: number, payload: z.core.ParsePayload<number>) => string>(
+  expectTypeOf<(value: number, payload: z.core.ParsePayload<number>) => z.core.util.MaybeAsync<string>>(
     stringToNumberCodec.def.reverseTransform
   ).toBeFunction();
 
@@ -468,11 +468,11 @@ test("codec type enforcement - complex types", () => {
     }
   );
 
-  // Verify correct types are inferred
-  expectTypeOf<(input: UserInput, payload: z.core.ParsePayload<UserInput>) => User>(
+  // Verify correct types are inferred (async support)
+  expectTypeOf<(input: UserInput, payload: z.core.ParsePayload<UserInput>) => z.core.util.MaybeAsync<User>>(
     userCodec.def.transform
   ).toBeFunction();
-  expectTypeOf<(user: User, payload: z.core.ParsePayload<User>) => UserInput>(
+  expectTypeOf<(user: User, payload: z.core.ParsePayload<User>) => z.core.util.MaybeAsync<UserInput>>(
     userCodec.def.reverseTransform
   ).toBeFunction();
 
@@ -530,3 +530,33 @@ test("codex with overwrites", () => {
     }
   `);
 });
+
+test("async codec functionality", async () => {
+  // Test that async encode/decode functions work properly
+  const asyncCodec = z.codec(z.string(), z.number(), {
+    decode: async (str) => {
+      await new Promise((resolve) => setTimeout(resolve, 1)); // Simulate async work
+      return Number.parseFloat(str);
+    },
+    encode: async (num) => {
+      await new Promise((resolve) => setTimeout(resolve, 1)); // Simulate async work
+      return num.toString();
+    },
+  });
+
+  // Test async decode/encode
+  const decoded = await z.decodeAsync(asyncCodec, "42.5");
+  expect(decoded).toBe(42.5);
+
+  const encoded = await z.encodeAsync(asyncCodec, 42.5);
+  expect(encoded).toBe("42.5");
+
+  // Test that both sync and async work
+  const mixedCodec = z.codec(z.string(), z.number(), {
+    decode: async (str) => Number.parseFloat(str),
+    encode: (num) => num.toString(), // sync encode
+  });
+
+  const mixedResult = await z.decodeAsync(mixedCodec, "123");
+  expect(mixedResult).toBe(123);
+});

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

@@ -130,6 +130,46 @@ test("valid function run", () => {
   });
 });
 
+const args3 = [
+  z.object({
+    f1: z.number(),
+    f2: z.string().nullable(),
+    f3: z.array(z.boolean().optional()).optional(),
+  }),
+] as const;
+const returns3 = z.union([z.string(), z.number()]);
+
+const func3 = z.function({
+  input: args3,
+  output: returns3,
+});
+
+test("function inference 3", () => {
+  type func3 = (typeof func3)["_input"];
+
+  expectTypeOf<func3>().toEqualTypeOf<
+    (arg: {
+      f3?: (boolean | undefined)[] | undefined;
+      f1: number;
+      f2: string | null;
+    }) => string | number
+  >();
+});
+
+test("valid function run", () => {
+  const validFunc3Instance = func3.implement((_x) => {
+    _x.f2;
+    _x.f3![0];
+    return "adf" as any;
+  });
+
+  validFunc3Instance({
+    f1: 21,
+    f2: "asdf",
+    f3: [true, false],
+  });
+});
+
 test("input validation error", () => {
   const schema = z.function({
     input: z.tuple([z.string()]),

package/src/v4/core/schemas.ts

@@ -1862,6 +1862,7 @@ export const $ZodObject: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$con
 
     const proms: Promise<any>[] = [];
     const shape = value.shape;
+
     for (const key of value.keys) {
       const el = shape[key]!;
       const r = el._zod.run({ value: input[key], issues: [] }, ctx);
@@ -1907,7 +1908,7 @@ export const $ZodObjectJIT: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$
       }
 
       // A: preserve key order {
-      doc.write(`const newResult = {}`);
+      doc.write(`const newResult = {};`);
       for (const key of normalized.keys) {
         const id = ids[key];
         const k = util.esc(key);
@@ -1920,6 +1921,7 @@ export const $ZodObjectJIT: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$
           })));
         }
         
+        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -1927,6 +1929,7 @@ export const $ZodObjectJIT: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$
         } else {
           newResult[${k}] = ${id}.value;
         }
+        
       `);
       }
 
@@ -3590,9 +3593,9 @@ export interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType =
   in: A;
   out: B;
   /** Only defined inside $ZodCodec instances. */
-  transform?: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => core.input<B>;
+  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>>) => core.output<A>;
+  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>
@@ -3650,8 +3653,8 @@ function handlePipeResult(left: ParsePayload, next: $ZodType, ctx: ParseContextI
 ////////////////////////////////////////////
 ////////////////////////////////////////////
 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>>) => core.input<B>;
-  reverseTransform: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => core.output<A>;
+  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>

package/src/v4/core/versions.ts

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

package/src/v4/mini/schemas.ts

@@ -1460,8 +1460,8 @@ export function codec<const A extends SomeType, B extends core.SomeType = core.$
   in_: A,
   out: B,
   params: {
-    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.input<B>;
-    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.output<A>;
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
   }
 ): ZodMiniCodec<A, B> {
   return new ZodMiniCodec({

package/src/v4/mini/tests/codec.test.ts

@@ -409,11 +409,11 @@ test("codec type enforcement - correct encode/decode signatures", () => {
     encode: (value: number) => String(value), // core.input<B> -> core.output<A>
   });
 
-  // These should compile without errors - correct types
-  expectTypeOf<(value: string, payload: z.core.ParsePayload<string>) => number>(
+  // These should compile without errors - correct types (async support)
+  expectTypeOf<(value: string, payload: z.core.ParsePayload<string>) => z.core.util.MaybeAsync<number>>(
     stringToNumberCodec.def.transform
   ).toBeFunction();
-  expectTypeOf<(value: number, payload: z.core.ParsePayload<number>) => string>(
+  expectTypeOf<(value: number, payload: z.core.ParsePayload<number>) => z.core.util.MaybeAsync<string>>(
     stringToNumberCodec.def.reverseTransform
   ).toBeFunction();
 
@@ -450,6 +450,36 @@ test("codec type enforcement - correct encode/decode signatures", () => {
   });
 });
 
+test("async codec functionality", async () => {
+  // Test that async encode/decode functions work properly
+  const asyncCodec = z.codec(z.string(), z.number(), {
+    decode: async (str) => {
+      await new Promise((resolve) => setTimeout(resolve, 1)); // Simulate async work
+      return Number.parseFloat(str);
+    },
+    encode: async (num) => {
+      await new Promise((resolve) => setTimeout(resolve, 1)); // Simulate async work
+      return num.toString();
+    },
+  });
+
+  // Test async decode/encode
+  const decoded = await z.decodeAsync(asyncCodec, "42.5");
+  expect(decoded).toBe(42.5);
+
+  const encoded = await z.encodeAsync(asyncCodec, 42.5);
+  expect(encoded).toBe("42.5");
+
+  // Test that both sync and async work
+  const mixedCodec = z.codec(z.string(), z.number(), {
+    decode: async (str) => Number.parseFloat(str),
+    encode: (num) => num.toString(), // sync encode
+  });
+
+  const mixedResult = await z.decodeAsync(mixedCodec, "123");
+  expect(mixedResult).toBe(123);
+});
+
 test("codec type enforcement - complex types", () => {
   type User = { id: number; name: string };
   type UserInput = { id: string; name: string };
@@ -463,11 +493,11 @@ test("codec type enforcement - complex types", () => {
     }
   );
 
-  // Verify correct types are inferred
-  expectTypeOf<(input: UserInput, payload: z.core.ParsePayload<UserInput>) => User>(
+  // Verify correct types are inferred (async support)
+  expectTypeOf<(input: UserInput, payload: z.core.ParsePayload<UserInput>) => z.core.util.MaybeAsync<User>>(
     userCodec.def.transform
   ).toBeFunction();
-  expectTypeOf<(user: User, payload: z.core.ParsePayload<User>) => UserInput>(
+  expectTypeOf<(user: User, payload: z.core.ParsePayload<User>) => z.core.util.MaybeAsync<UserInput>>(
     userCodec.def.reverseTransform
   ).toBeFunction();
 

package/v4/classic/schemas.d.cts

@@ -36,7 +36,7 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
     nullable(): ZodNullable<this>;
     nullish(): ZodOptional<ZodNullable<this>>;
-    default(def: core.output<this>): ZodDefault<this>;
+    default(def: util.NoUndefined<core.output<this>>): ZodDefault<this>;
     default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this>;
     prefault(def: () => core.input<this>): ZodPrefault<this>;
     prefault(def: core.input<this>): ZodPrefault<this>;
@@ -591,8 +591,8 @@ export interface ZodCodec<A extends core.SomeType = core.$ZodType, B extends cor
 }
 export declare const ZodCodec: core.$constructor<ZodCodec>;
 export declare function codec<const A extends core.SomeType, B extends core.SomeType = core.$ZodType>(in_: A, out: B, params: {
-    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.input<B>;
-    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.output<A>;
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
 }): ZodCodec<A, B>;
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodReadonlyInternals<T>>, core.$ZodReadonly<T> {
     unwrap(): T;
@@ -624,10 +624,10 @@ export interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctio
 }
 export declare const ZodFunction: core.$constructor<ZodFunction>;
 export declare function _function(): ZodFunction;
-export declare function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>>(params: {
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>>(params: {
     input: In;
 }): ZodFunction<ZodTuple<In, null>, core.$ZodFunctionOut>;
-export declare function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
     input: In;
     output: Out;
 }): ZodFunction<ZodTuple<In, null>, Out>;

package/v4/classic/schemas.d.ts

@@ -36,7 +36,7 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
     nullable(): ZodNullable<this>;
     nullish(): ZodOptional<ZodNullable<this>>;
-    default(def: core.output<this>): ZodDefault<this>;
+    default(def: util.NoUndefined<core.output<this>>): ZodDefault<this>;
     default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this>;
     prefault(def: () => core.input<this>): ZodPrefault<this>;
     prefault(def: core.input<this>): ZodPrefault<this>;
@@ -591,8 +591,8 @@ export interface ZodCodec<A extends core.SomeType = core.$ZodType, B extends cor
 }
 export declare const ZodCodec: core.$constructor<ZodCodec>;
 export declare function codec<const A extends core.SomeType, B extends core.SomeType = core.$ZodType>(in_: A, out: B, params: {
-    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.input<B>;
-    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.output<A>;
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
 }): ZodCodec<A, B>;
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodReadonlyInternals<T>>, core.$ZodReadonly<T> {
     unwrap(): T;
@@ -624,10 +624,10 @@ export interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctio
 }
 export declare const ZodFunction: core.$constructor<ZodFunction>;
 export declare function _function(): ZodFunction;
-export declare function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>>(params: {
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>>(params: {
     input: In;
 }): ZodFunction<ZodTuple<In, null>, core.$ZodFunctionOut>;
-export declare function _function<const In extends Array<core.$ZodType> = Array<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
+export declare function _function<const In extends ReadonlyArray<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {
     input: In;
     output: Out;
 }): ZodFunction<ZodTuple<In, null>, Out>;

package/v4/core/schemas.cjs

@@ -864,7 +864,7 @@ exports.$ZodObjectJIT = core.$constructor("$ZodObjectJIT", (inst, def) => {
             ids[key] = `key_${counter++}`;
         }
         // A: preserve key order {
-        doc.write(`const newResult = {}`);
+        doc.write(`const newResult = {};`);
         for (const key of normalized.keys) {
             const id = ids[key];
             const k = util.esc(key);
@@ -877,6 +877,7 @@ exports.$ZodObjectJIT = core.$constructor("$ZodObjectJIT", (inst, def) => {
           })));
         }
         
+        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -884,6 +885,7 @@ exports.$ZodObjectJIT = core.$constructor("$ZodObjectJIT", (inst, def) => {
         } else {
           newResult[${k}] = ${id}.value;
         }
+        
       `);
         }
         doc.write(`payload.value = newResult;`);

package/v4/core/schemas.d.cts

@@ -945,9 +945,9 @@ export interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType =
     in: A;
     out: B;
     /** Only defined inside $ZodCodec instances. */
-    transform?: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => core.input<B>;
+    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>>) => core.output<A>;
+    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> extends $ZodTypeInternals<core.output<B>, core.input<A>> {
     def: $ZodPipeDef<A, B>;
@@ -962,8 +962,8 @@ export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $Z
 }
 export declare const $ZodPipe: core.$constructor<$ZodPipe>;
 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>>) => core.input<B>;
-    reverseTransform: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => core.output<A>;
+    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>;

package/v4/core/schemas.d.ts

@@ -945,9 +945,9 @@ export interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType =
     in: A;
     out: B;
     /** Only defined inside $ZodCodec instances. */
-    transform?: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => core.input<B>;
+    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>>) => core.output<A>;
+    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> extends $ZodTypeInternals<core.output<B>, core.input<A>> {
     def: $ZodPipeDef<A, B>;
@@ -962,8 +962,8 @@ export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $Z
 }
 export declare const $ZodPipe: core.$constructor<$ZodPipe>;
 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>>) => core.input<B>;
-    reverseTransform: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => core.output<A>;
+    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>;

package/v4/core/schemas.js

@@ -833,7 +833,7 @@ export const $ZodObjectJIT = /*@__PURE__*/ core.$constructor("$ZodObjectJIT", (i
             ids[key] = `key_${counter++}`;
         }
         // A: preserve key order {
-        doc.write(`const newResult = {}`);
+        doc.write(`const newResult = {};`);
         for (const key of normalized.keys) {
             const id = ids[key];
             const k = util.esc(key);
@@ -846,6 +846,7 @@ export const $ZodObjectJIT = /*@__PURE__*/ core.$constructor("$ZodObjectJIT", (i
           })));
         }
         
+        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -853,6 +854,7 @@ export const $ZodObjectJIT = /*@__PURE__*/ core.$constructor("$ZodObjectJIT", (i
         } else {
           newResult[${k}] = ${id}.value;
         }
+        
       `);
         }
         doc.write(`payload.value = newResult;`);

package/v4/core/versions.cjs

@@ -4,5 +4,5 @@ exports.version = void 0;
 exports.version = {
     major: 4,
     minor: 1,
-    patch: 4,
+    patch: 5,
 };

package/v4/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
     minor: 1,
-    patch: 4,
+    patch: 5,
 };

package/v4/mini/schemas.d.cts

@@ -326,8 +326,8 @@ export interface ZodMiniCodec<A extends SomeType = core.$ZodType, B extends Some
 }
 export declare const ZodMiniCodec: core.$constructor<ZodMiniCodec>;
 export declare function codec<const A extends SomeType, B extends core.SomeType = core.$ZodType>(in_: A, out: B, params: {
-    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.input<B>;
-    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.output<A>;
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
 }): ZodMiniCodec<A, B>;
 export interface ZodMiniReadonly<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodReadonlyInternals<T>> {
 }

package/v4/mini/schemas.d.ts

@@ -326,8 +326,8 @@ export interface ZodMiniCodec<A extends SomeType = core.$ZodType, B extends Some
 }
 export declare const ZodMiniCodec: core.$constructor<ZodMiniCodec>;
 export declare function codec<const A extends SomeType, B extends core.SomeType = core.$ZodType>(in_: A, out: B, params: {
-    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.input<B>;
-    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.output<A>;
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
 }): ZodMiniCodec<A, B>;
 export interface ZodMiniReadonly<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodReadonlyInternals<T>> {
 }