zod 4.2.0-canary.20250828T181323 → 4.2.0-canary.20250911T044505

package/locales/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

package/mini/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.2.0-canary.20250828T181323",
+  "version": "4.2.0-canary.20250911T044505",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",
@@ -18,7 +18,8 @@
     "**/*.cjs",
     "**/*.d.ts",
     "**/*.d.mts",
-    "**/*.d.cts"
+    "**/*.d.cts",
+    "**/package.json"
   ],
   "keywords": [
     "typescript",
@@ -126,7 +127,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({

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/string.test.ts

@@ -919,6 +919,7 @@ test("CIDR v6 validation", () => {
   expect(cidrV6.safeParse("2001:db8::/abc").success).toBe(false); // Invalid prefix format
   expect(cidrV6.safeParse("not a cidr").success).toBe(false); // Invalid format
   expect(cidrV6.safeParse("192.168.0.0/24").success).toBe(false); // IPv4 CIDR in v6 validation
+  expect(cidrV6.safeParse("2001:0db8:85a3::/64/whatever-after").success).toBe(false);
 });
 
 test("E.164 validation", () => {

package/src/v4/core/schemas.ts

@@ -830,9 +830,10 @@ export const $ZodCIDRv6: core.$constructor<$ZodCIDRv6> = /*@__PURE__*/ core.$con
     $ZodStringFormat.init(inst, def);
 
     inst._zod.check = (payload) => {
-      const [address, prefix] = payload.value.split("/");
+      const segments = payload.value.split("/");
+      const [address, prefix] = segments;
       try {
-        if (!prefix) throw new Error();
+        if (segments.length !== 2) throw new Error();
         const prefixNum = Number(prefix);
         if (`${prefixNum}` !== prefix) throw new Error();
         if (prefixNum < 0 || prefixNum > 128) throw new Error();
@@ -1862,6 +1863,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 +1909,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 +1922,7 @@ export const $ZodObjectJIT: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$
           })));
         }
         
+        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -1927,6 +1930,7 @@ export const $ZodObjectJIT: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$
         } else {
           newResult[${k}] = ${id}.value;
         }
+        
       `);
       }
 
@@ -3590,9 +3594,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 +3654,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: 6 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/v3/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

package/v4/classic/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

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;

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;

package/v4/core/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

package/v4/core/schemas.cjs

@@ -364,9 +364,10 @@ exports.$ZodCIDRv6 = core.$constructor("$ZodCIDRv6", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.cidrv6); // not used for validation
     exports.$ZodStringFormat.init(inst, def);
     inst._zod.check = (payload) => {
-        const [address, prefix] = payload.value.split("/");
+        const segments = payload.value.split("/");
+        const [address, prefix] = segments;
         try {
-            if (!prefix)
+            if (segments.length !== 2)
                 throw new Error();
             const prefixNum = Number(prefix);
             if (`${prefixNum}` !== prefix)
@@ -864,7 +865,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 +878,7 @@ exports.$ZodObjectJIT = core.$constructor("$ZodObjectJIT", (inst, def) => {
           })));
         }
         
+        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -884,6 +886,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

@@ -333,9 +333,10 @@ export const $ZodCIDRv6 = /*@__PURE__*/ core.$constructor("$ZodCIDRv6", (inst, d
     def.pattern ?? (def.pattern = regexes.cidrv6); // not used for validation
     $ZodStringFormat.init(inst, def);
     inst._zod.check = (payload) => {
-        const [address, prefix] = payload.value.split("/");
+        const segments = payload.value.split("/");
+        const [address, prefix] = segments;
         try {
-            if (!prefix)
+            if (segments.length !== 2)
                 throw new Error();
             const prefixNum = Number(prefix);
             if (`${prefixNum}` !== prefix)
@@ -833,7 +834,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 +847,7 @@ export const $ZodObjectJIT = /*@__PURE__*/ core.$constructor("$ZodObjectJIT", (i
           })));
         }
         
+        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -853,6 +855,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: 6,
 };

package/v4/core/versions.js

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

package/v4/locales/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

package/v4/mini/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

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>> {
 }

package/v4/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

package/v4-mini/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}