zod 4.6.0 → 4.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.6.0",
+  "version": "4.6.1",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/tests/discriminated-unions.test.ts

@@ -740,6 +740,26 @@ test("encode with codec discriminator", () => {
   expect(encoded).toEqual({ type: 1, value: "hello" });
 });
 
+test("nested encoding does not select a sibling from forward discriminator values", async () => {
+  const tag = (value: "a" | "b") =>
+    z.codec(z.literal(value).default(value), z.undefined(), {
+      decode: () => undefined,
+      encode: () => value,
+    });
+  const inner = z.discriminatedUnion("type", [
+    z.object({ type: tag("a"), value: z.literal("a") }),
+    z.object({ type: tag("b"), value: z.literal("b") }),
+  ]);
+  const outer = z.discriminatedUnion("type", [inner, z.object({ type: z.undefined(), value: z.string() })]);
+  for (const value of ["a", "b"] as const) {
+    const input = { type: undefined, value };
+    const expected = { type: value, value };
+    expect(z.encode(inner, input)).toEqual(expected);
+    expect(z.encode(outer, input)).toEqual(expected);
+    expect(await z.encodeAsync(outer, input)).toEqual(expected);
+  }
+});
+
 test("getDiscriminatedOption", () => {
   const fruit = z.object({ type: z.literal("fruit"), seeds: z.boolean() });
   const veg = z.object({ type: z.literal("vegetable"), leafy: z.boolean() });
@@ -811,9 +831,14 @@ test.each(["__proto__", "constructor", "toString", "hasOwnProperty", "valueOf"])
   }
 );
 
-// An omittable discriminator reads back as undefined at the lookup, exactly as TypeScript sees it: `{ k?: "a" } | { k?: "c" }` does not narrow on `k === undefined`.
 test("an omittable discriminator claims undefined", () => {
-  const omittable = [z.exactOptional(z.literal("a")), z.optional(z.literal("a")), z.literal("a").default("a")];
+  const omittable = [
+    z.exactOptional(z.literal("a")),
+    z.optional(z.literal("a")),
+    z.literal("a").default("a"),
+    z.literal("a").prefault("a"),
+    z.literal("a").catch("a"),
+  ];
   for (const k of omittable) {
     expect(z.object({ k })._zod.propValues.k).toEqual(new Set(["a", undefined]));
   }
@@ -827,10 +852,91 @@ test("an omittable discriminator claims undefined", () => {
   expect(z.union(options).safeParse({ x: "s" }).success).toEqual(true);
   expect(z.discriminatedUnion("k", options).safeParse({ k: "b", y: 1 }).success).toEqual(true);
 
-  // two options omit the key: both claim undefined, so they are not discriminable on it
+  // ambiguous absence does not prevent explicit tags from routing
   for (const k of omittable) {
-    expect(() =>
-      z.discriminatedUnion("k", [z.object({ k }), z.object({ k: z.exactOptional(z.literal("c")) })]).parse({})
-    ).toThrow(/Duplicate discriminator value "undefined"/);
+    const schema = z.discriminatedUnion("k", [z.object({ k }), z.object({ k: z.exactOptional(z.literal("c")) })]);
+    expect(schema.parse({ k: "a" })).toEqual({ k: "a" });
+    expect(schema.parse({ k: "c" })).toEqual({ k: "c" });
+    expect(schema.safeParse({}).success).toBe(false);
+  }
+});
+
+test("defaulted discriminators preserve tagged parsing without guessing a member", async () => {
+  const a = z.object({ type: z.literal("a").default("a"), x: z.number().positive() });
+  const b = z.object({ type: z.literal("b").default("b"), y: z.string() });
+  const c = z.object({ type: z.literal("c").default("c"), z: z.boolean() });
+  for (const options of [
+    [a, b, c],
+    [c, b, a],
+  ] as const) {
+    const schema = z.discriminatedUnion("type", options);
+    for (const input of [a.parse({ x: 1 }), b.parse({ y: "s" }), c.parse({ z: true })]) {
+      expect(schema.parse(input)).toEqual(input);
+      expect((await schema.safeParseAsync(input)).success).toBe(true);
+    }
+    for (const input of [{ x: 1, y: "s", z: true }, { type: undefined }, { type: "other" }, { type: "a", x: -1 }]) {
+      expect(schema.safeParse(input).success).toBe(false);
+      expect((await schema.safeParseAsync(input)).success).toBe(false);
+    }
+    const result = schema.safeParse({});
+    expect(result.error?.issues[0]).toMatchObject({
+      code: "invalid_union",
+      path: ["type"],
+      options: options.map((o) => o.shape.type.unwrap().value),
+    });
+    expect(z.getDiscriminatedOption(schema, "a")).toBe(a);
+  }
+  const unique = z.discriminatedUnion("type", [a, b.safeExtend({ type: b.shape.type.unwrap() })]);
+  expect(unique.parse({ x: 1 })).toEqual({ type: "a", x: 1 });
+});
+
+test("undefined collisions are value-based and discriminator lookup rejects ambiguity", () => {
+  const a = z.object({ type: z.literal("a").optional() });
+  const absent = z.object({ type: z.undefined() });
+  for (const options of [
+    [a, absent],
+    [absent, a],
+    [absent, absent, a],
+  ] as const) {
+    const schema = z.discriminatedUnion("type", options);
+    expect(schema.parse({ type: "a" })).toEqual({ type: "a" });
+    expect(schema.safeParse({}).success).toBe(false);
+    expect(() => z.getDiscriminatedOption(schema, undefined)).toThrow('Ambiguous discriminator value "undefined"');
+  }
+  const unique = z.discriminatedUnion("type", [absent, z.object({ type: z.literal("a") })]);
+  expect(unique.parse({ type: undefined })).toEqual({ type: undefined });
+  expect(z.getDiscriminatedOption(unique, undefined)).toBe(absent);
+});
+
+test("non-undefined discriminator collisions remain schema errors", () => {
+  for (const tag of [z.literal("a").default("a"), z.literal(["a", "b"]), z.literal("a").nullable()]) {
+    const schema = z.discriminatedUnion("type", [z.object({ type: tag }), z.object({ type: tag })]);
+    expect(() => schema.safeParse({ type: "a" })).toThrow(/Duplicate discriminator value/);
+    expect(() => z.encode(schema, { type: "a" })).toThrow(/Duplicate discriminator value/);
+    expect(() => z.getDiscriminatedOption(schema, "a")).toThrow(/Duplicate discriminator value/);
+  }
+  const nullable = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("a").nullable() }),
+    z.object({ type: z.literal("b").nullable() }),
+  ]);
+  expect(() => nullable.safeParse({ type: "a" })).toThrow('Duplicate discriminator value "null"');
+});
+
+test("nested defaulted unions only advertise routable discriminator values", () => {
+  const a = z.object({ type: z.literal("a").default("a"), group: z.literal("inner") });
+  const b = z.object({ type: z.literal("b").default("b"), group: z.literal("inner") });
+  const inner = z.discriminatedUnion("type", [a, b]);
+  const c = z.object({ type: z.literal("c").default("c"), group: z.literal("outer") });
+  expect(inner._zod.propValues.type).toEqual(new Set(["a", "b"]));
+  for (const schema of [
+    z.discriminatedUnion("type", [z.lazy(() => inner), c]),
+    z.discriminatedUnion("group", [inner, c]),
+  ]) {
+    expect(schema.parse({ type: "a", group: "inner" })).toEqual({ type: "a", group: "inner" });
+    expect(schema.parse({ group: "outer" })).toEqual({ type: "c", group: "outer" });
+    expect(schema.safeParse({ group: "inner" }).success).toBe(false);
   }
+  const fallback = z.discriminatedUnion("type", [a, b], { unionFallback: true });
+  expect(fallback._zod.propValues.type.has(undefined)).toBe(true);
+  expect(fallback.parse({ group: "inner" })).toEqual({ type: "a", group: "inner" });
 });

package/src/v4/classic/tests/recursive-types.test.ts

@@ -1,6 +1,51 @@
 import { expect, expectTypeOf, test } from "vitest";
 import { z } from "zod/v4";
 
+test("recursive object schema type aliases", () => {
+  type ObjectField = z.ZodObject<{ [k: string]: ObjectField }>;
+  type MixedField = z.ZodString | z.ZodObject<{ [k: string]: MixedField }>;
+  expectTypeOf<ObjectField>().toExtend<z.ZodType>();
+  expectTypeOf<MixedField>().toExtend<z.ZodType>();
+
+  type ObjectValue = { [k: string]: ObjectValue };
+  type MixedValue = string | { [k: string]: MixedValue };
+  expectTypeOf<z.input<ObjectField>>().toEqualTypeOf<ObjectValue>();
+  expectTypeOf<z.output<ObjectField>>().toEqualTypeOf<ObjectValue>();
+  expectTypeOf<z.input<MixedField>>().toEqualTypeOf<MixedValue>();
+  expectTypeOf<z.output<MixedField>>().toEqualTypeOf<MixedValue>();
+
+  const schema: MixedField = z.object({ name: z.string(), nested: z.object({ name: z.string() }) });
+  expect(schema.parse({ name: "a", nested: { name: "b", extra: true } })).toEqual({
+    name: "a",
+    nested: { name: "b" },
+  });
+  expect(schema.safeParse({ name: "a", nested: { name: 123 } }).success).toBe(false);
+
+  type CoreField = z.core.$ZodString<string> | z.core.$ZodObject<{ [k: string]: CoreField }>;
+  expectTypeOf<z.input<CoreField>>().toEqualTypeOf<MixedValue>();
+  expectTypeOf<z.output<CoreField>>().toEqualTypeOf<MixedValue>();
+});
+
+test("recursive object aliases preserve distinct input and output", () => {
+  type Field = z.ZodPipe<z.ZodString, z.ZodTransform<number, string>> | z.ZodObject<{ [k: string]: Field }>;
+  type Input = string | { [k: string]: Input };
+  type Output = number | { [k: string]: Output };
+  expectTypeOf<z.input<Field>>().toEqualTypeOf<Input>();
+  expectTypeOf<z.output<Field>>().toEqualTypeOf<Output>();
+  const schema: Field = z.object({ nested: z.object({ length: z.string().transform((s) => s.length) }) });
+  expect(schema.parse({ nested: { length: "abc" } })).toEqual({ nested: { length: 3 } });
+  expect(schema.safeParse({ nested: { length: 3 } }).success).toBe(false);
+});
+
+test("indexed object inference preserves string keys", () => {
+  type Indexed = z.ZodObject<Record<string, z.ZodString>>;
+  type Recursive = z.ZodObject<Record<string, Recursive>>;
+  expectTypeOf<keyof z.input<Indexed>>().toEqualTypeOf<string>();
+  expectTypeOf<keyof z.output<Indexed>>().toEqualTypeOf<string>();
+  expectTypeOf<keyof z.input<Recursive>>().toEqualTypeOf<string>();
+  expectTypeOf<keyof z.output<Recursive>>().toEqualTypeOf<string>();
+});
+
 test("recursion with z.lazy", () => {
   const data = {
     name: "I",

package/src/v4/core/compile.ts

@@ -1869,7 +1869,7 @@ function generateDiscriminatedUnionCheck(
       throw new ZodCompileUnsupportedError("discriminated union option without static discriminator values");
     }
 
-    // Two options claiming one value are not discriminable, and the branch chain below would silently give it to the first. Declining to compile hands that back to the interpreter, whose own map build reports it.
+    // let the interpreter handle collisions instead of compiling first-match dispatch
     for (const value of values) {
       if (claimed.has(value)) {
         throw new ZodCompileUnsupportedError(`duplicate discriminator value ${String(value)}`);

package/src/v4/core/schemas.ts

@@ -1893,7 +1893,7 @@ type OptionalInSchema = { _zod: { optin: "optional" | "defaulted" } };
 export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T
   ? util.IsAny<T[keyof T]> extends true
     ? Record<string, unknown>
-    : Record<string, core.output<T[keyof T]>>
+    : { [k in string]: core.output<T[keyof T]> }
   : keyof (T & Extra) extends never
     ? Record<string, never>
     : util.Prettify<
@@ -1937,7 +1937,7 @@ export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<st
 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>
-    : Record<string, core.input<T[keyof T]>>
+    : { [k in string]: core.input<T[keyof T]> }
   : keyof (T & Extra) extends never
     ? Record<string, never>
     : util.Prettify<
@@ -2600,7 +2600,7 @@ export interface $ZodDiscriminatedUnionInternals<
   def: $ZodDiscriminatedUnionDef<Options, Disc>;
   propValues: util.PropValues;
   bag: util.LoosePartial<{
-    optionsMap: Map<util.Primitive, $ZodType>;
+    optionsMap: Map<util.Primitive, $ZodType | null>;
   }>;
 }
 
@@ -2624,7 +2624,7 @@ export type $DiscriminatedOption<Options extends readonly SomeType[], Disc exten
     : never;
 }[number];
 
-/** Returns the option of `union` whose discriminator claims `value`. */
+/** Returns the option whose discriminator claims `value`, or throws if ambiguous. */
 export function getDiscriminatedOption<
   Options extends readonly SomeType[],
   Disc extends string,
@@ -2633,15 +2633,31 @@ export function getDiscriminatedOption<
   const internals = union._zod;
   let map = internals.bag.optionsMap;
   if (!map) {
-    map = new Map();
-    const { options, discriminator } = internals.def;
-    for (const option of options as unknown as readonly $ZodType[]) {
-      // First declaration wins, matching the order the parse path resolves a duplicate in.
-      for (const v of option._zod.propValues?.[discriminator] ?? []) if (!map.has(v)) map.set(v, option);
-    }
+    map = discriminatorMap(internals.def);
     internals.bag.optionsMap = map;
   }
-  return map.get(value as util.Primitive) as any;
+  const option = map.get(value as util.Primitive);
+  if (option === null) throw new Error(`Ambiguous discriminator value "${String(value)}"`);
+  return option as any;
+}
+
+function discriminatorMap(def: $ZodDiscriminatedUnionDef<readonly SomeType[]>): Map<util.Primitive, $ZodType | null> {
+  const map = new Map<util.Primitive, $ZodType | null>();
+  for (const option of def.options as readonly $ZodType[]) {
+    const values = option._zod.propValues?.[def.discriminator];
+    if (!values || values.size === 0)
+      throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+    for (const value of values) {
+      if (map.has(value)) {
+        if (value !== undefined) throw new Error(`Duplicate discriminator value "${String(value)}"`);
+        // keep the collision marked so a later member cannot reclaim it
+        map.set(value, null);
+      } else {
+        map.set(value, option);
+      }
+    }
+  }
+  return map;
 }
 
 export interface $ZodDiscriminatedUnion<
@@ -2661,10 +2677,12 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
     const _super = inst._zod.parse;
     util.defineLazyInternal(inst, "propValues", (zod) => {
       const propValues: util.PropValues = {};
+      let undefinedCount = 0;
       for (const option of zod.def.options) {
         const pv = option._zod.propValues;
         if (!pv || Object.keys(pv).length === 0)
           throw new Error(`Invalid discriminated union option at index "${zod.def.options.indexOf(option)}"`);
+        if (pv[zod.def.discriminator]?.has(undefined)) undefinedCount++;
         for (const [k, v] of Object.entries(pv!)) {
           if (!Object.prototype.hasOwnProperty.call(propValues, k)) {
             util.assignProp(propValues, k, new Set());
@@ -2674,6 +2692,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
           }
         }
       }
+      if (!zod.def.unionFallback && undefinedCount > 1) propValues[zod.def.discriminator]?.delete(undefined);
       return propValues;
     });
 
@@ -2685,22 +2704,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       }
     });
 
-    const disc = util.cached(() => {
-      const opts = def.options;
-      const map: Map<util.Primitive, $ZodType> = new Map();
-      for (const o of opts) {
-        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) {
-          if (map.has(v)) {
-            throw new Error(`Duplicate discriminator value "${String(v)}"`);
-          }
-          map.set(v, o);
-        }
-      }
-      return map;
-    });
+    const disc = util.cached(() => discriminatorMap(def));
 
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
@@ -2715,8 +2719,10 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
         return payload;
       }
 
-      const opt = disc.value.get(input?.[def.discriminator] as any);
-      if (opt) {
+      const value = input?.[def.discriminator];
+      const opt = disc.value.get(value as util.Primitive);
+      // forward metadata cannot choose an encoder for an absent tag
+      if (opt && (value !== undefined || ctx.direction !== "backward")) {
         return opt._zod.run(payload, ctx) as any;
       }
 
@@ -2733,7 +2739,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
         errors: [],
         note: "No matching discriminator",
         discriminator: def.discriminator,
-        options: Array.from(disc.value.keys()),
+        options: Array.from(disc.value.keys()).filter((value) => disc.value.get(value) !== null),
         input,
         path: [def.discriminator],
         inst,

package/src/v4/core/tests/locales/tg.test.ts

@@ -0,0 +1,85 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+test("locales - tg", () => {
+  z.config(z.locales.tg());
+
+  const invalidType = z.number().safeParse("a");
+  expect(invalidType.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType.error!.issues[0].message).toBe("Вуруди нодуруст: рақам интизор мерафт, сатр гирифта шуд");
+
+  const invalidType2 = z.string().safeParse(1);
+  expect(invalidType2.error!.issues[0].code).toBe("invalid_type");
+  expect(invalidType2.error!.issues[0].message).toBe("Вуруди нодуруст: сатр интизор мерафт, рақам гирифта шуд");
+
+  const invalidValue = z.enum(["a", "b"]).safeParse(1);
+  expect(invalidValue.error!.issues[0].code).toBe("invalid_value");
+  expect(invalidValue.error!.issues[0].message).toBe('Интихоби нодуруст: яке аз "a"|"b" интизор мерафт');
+
+  const tooBig = z.number().max(10).safeParse(15);
+  expect(tooBig.error!.issues[0].code).toBe("too_big");
+  expect(tooBig.error!.issues[0].message).toBe("Хеле калон: number бояд <=10 бошад");
+
+  const tooSmall = z.number().min(10).safeParse(5);
+  expect(tooSmall.error!.issues[0].code).toBe("too_small");
+  expect(tooSmall.error!.issues[0].message).toBe("Хеле хурд: number бояд >=10 бошад");
+
+  // singular units after numerals in Tajik
+  const tooShort = z.string().min(5).safeParse("hi");
+  expect(tooShort.error!.issues[0].message).toBe("Хеле хурд: string бояд >=5 аломат дошта бошад");
+
+  const tooFewItems = z.array(z.number()).min(2).safeParse([1]);
+  expect(tooFewItems.error!.issues[0].message).toBe("Хеле хурд: array бояд >=2 унсур дошта бошад");
+
+  const invalidEmail = z.string().email().safeParse("nope");
+  expect(invalidEmail.error!.issues[0].code).toBe("invalid_format");
+  expect(invalidEmail.error!.issues[0].message).toBe("суроғаи email-и нодуруст");
+
+  const invalidStart = z.string().startsWith("ab").safeParse("xy");
+  expect(invalidStart.error!.issues[0].message).toBe('Сатри нодуруст: бояд бо "ab" оғоз шавад');
+
+  const invalidRegex = z.string().regex(/abcd/).safeParse("xy");
+  expect(invalidRegex.error!.issues[0].message).toContain("мувофиқат кунад");
+
+  const notMultipleOf = z.number().multipleOf(5).safeParse(7);
+  expect(notMultipleOf.error!.issues[0].message).toBe("Рақами нодуруст: бояд ба 5 бе бақия тақсим шавад");
+
+  const oneUnknownKey = z.strictObject({ a: z.string() }).safeParse({ a: "x", b: 1 });
+  expect(oneUnknownKey.error!.issues[0].message).toBe('Калиди номаълум: "b"');
+
+  const twoUnknownKeys = z.strictObject({ a: z.string() }).safeParse({ a: "x", b: 1, c: 2 });
+  expect(twoUnknownKeys.error!.issues[0].message).toBe('Калидҳои номаълум: "b", "c"');
+
+  const cases: [z.ZodType, unknown, string][] = [
+    [z.literal("a"), "b", 'Вуруди нодуруст: "a" интизор мерафт'],
+    [z.boolean(), null, "Вуруди нодуруст: boolean интизор мерафт, null гирифта шуд"],
+    [z.number(), Number.NaN, "Вуруди нодуруст: рақам интизор мерафт, NaN гирифта шуд"],
+    [z.number().lt(10), 10, "Хеле калон: number бояд <10 бошад"],
+    [z.number().gt(10), 10, "Хеле хурд: number бояд >10 бошад"],
+    [z.string().max(1), "ab", "Хеле калон: string бояд <=1 аломат дошта бошад"],
+    [z.set(z.string()).min(1), new Set(), "Хеле хурд: set бояд >=1 унсур дошта бошад"],
+    [z.map(z.string(), z.number()).min(1), new Map(), "Хеле хурд: map бояд >=1 сабт дошта бошад"],
+    [z.file().min(1), new File([], "empty"), "Хеле хурд: file бояд >=1 байт дошта бошад"],
+    [z.string().endsWith("ab"), "xy", 'Сатри нодуруст: бояд бо "ab" анҷом ёбад'],
+    [z.string().includes("ab"), "xy", 'Сатри нодуруст: бояд "ab"-ро дар бар гирад'],
+    [z.stringFormat("custom", () => false), "xy", "custom-и нодуруст"],
+    [z.union([z.string(), z.number()]), null, "Вуруди нодуруст"],
+    [
+      z.discriminatedUnion("kind", [z.object({ kind: z.literal("a") }), z.object({ kind: z.literal("b") })]),
+      { kind: "c" },
+      "Қимати нодурусти дискриминатор: 'a' | 'b' интизор мерафт",
+    ],
+    [z.record(z.string().min(2), z.number()), { a: 1 }, "Калиди нодуруст дар record"],
+    [z.map(z.string(), z.number()), new Map([[{}, 1]]), "Калиди нодуруст дар map"],
+    [z.map(z.object({}), z.number()), new Map([[{}, "a"]]), "Қимати нодуруст дар map"],
+    [z.custom(() => false), "a", "Вуруди нодуруст"],
+  ];
+  for (const [schema, input, message] of cases) {
+    expect(schema.safeParse(input).error!.issues[0].message).toBe(message);
+  }
+
+  expect(z.object({ name: z.string().min(1), age: z.number().min(0) }).parse({ name: "Ali", age: 30 })).toEqual({
+    name: "Ali",
+    age: 30,
+  });
+});

package/src/v4/core/versions.ts

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

package/src/v4/locales/index.ts

@@ -49,6 +49,7 @@ export { default as sk } from "./sk.js";
 export { default as sl } from "./sl.js";
 export { default as sv } from "./sv.js";
 export { default as ta } from "./ta.js";
+export { default as tg } from "./tg.js";
 export { default as th } from "./th.js";
 export { default as tk } from "./tk.js";
 export { default as tr } from "./tr.js";

package/src/v4/locales/tg.ts

@@ -0,0 +1,134 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  // singular units after numerals in Tajik
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "аломат", verb: "дошта бошад" },
+    file: { unit: "байт", verb: "дошта бошад" },
+    array: { unit: "унсур", verb: "дошта бошад" },
+    set: { unit: "унсур", verb: "дошта бошад" },
+    map: { unit: "сабт", verb: "дошта бошад" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "вуруд",
+    email: "суроғаи email",
+    url: "URL",
+    emoji: "эмоҷи",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "санаву вақти ISO",
+    date: "санаи ISO",
+    time: "вақти ISO",
+    duration: "давомнокии ISO",
+    ipv4: "суроғаи IPv4",
+    ipv6: "суроғаи IPv6",
+    mac: "суроғаи MAC",
+    cidrv4: "маҳдудаи IPv4",
+    cidrv6: "маҳдудаи IPv6",
+    base64: "сатри дар формати base64",
+    base64url: "сатри дар формати base64url",
+    json_string: "сатри JSON",
+    e164: "рақами E.164",
+    credit_card: "рақами корти кредитӣ",
+    iban: "IBAN",
+    jwt: "JWT",
+    template_literal: "вуруд",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    number: "рақам",
+    string: "сатр",
+    array: "массив",
+    object: "объект",
+    date: "сана",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        return `Вуруди нодуруст: ${expected} интизор мерафт, ${received} гирифта шуд`;
+      }
+
+      case "invalid_value":
+        if (issue.values.length === 1)
+          return `Вуруди нодуруст: ${util.stringifyPrimitive(issue.values[0])} интизор мерафт`;
+        return `Интихоби нодуруст: яке аз ${util.joinValues(issue.values, "|")} интизор мерафт`;
+
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Хеле калон: ${issue.origin ?? "қимат"} бояд ${adj}${issue.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
+        return `Хеле калон: ${issue.origin ?? "қимат"} бояд ${adj}${issue.maximum.toString()} бошад`;
+      }
+
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Хеле хурд: ${issue.origin} бояд ${adj}${issue.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
+        return `Хеле хурд: ${issue.origin} бояд ${adj}${issue.minimum.toString()} бошад`;
+      }
+
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Сатри нодуруст: бояд бо "${_issue.prefix}" оғоз шавад`;
+        if (_issue.format === "ends_with") return `Сатри нодуруст: бояд бо "${_issue.suffix}" анҷом ёбад`;
+        if (_issue.format === "includes") return `Сатри нодуруст: бояд "${_issue.includes}"-ро дар бар гирад`;
+        if (_issue.format === "regex") return `Сатри нодуруст: бояд ба намунаи ${_issue.pattern} мувофиқат кунад`;
+        return `${FormatDictionary[_issue.format] ?? issue.format}-и нодуруст`;
+      }
+
+      case "not_multiple_of":
+        return `Рақами нодуруст: бояд ба ${issue.divisor} бе бақия тақсим шавад`;
+
+      case "unrecognized_keys":
+        return `Калид${issue.keys.length > 1 ? "ҳои" : "и"} номаълум: ${util.joinValues(issue.keys, ", ")}`;
+
+      case "invalid_key":
+        return `Калиди нодуруст дар ${issue.origin}`;
+
+      case "invalid_union":
+        if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) {
+          const opts = issue.options.map((o) => `'${o}'`).join(" | ");
+          return `Қимати нодурусти дискриминатор: ${opts} интизор мерафт`;
+        }
+        return "Вуруди нодуруст";
+
+      case "invalid_element":
+        return `Қимати нодуруст дар ${issue.origin}`;
+
+      default:
+        return `Вуруди нодуруст`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

package/src/v4/mini/tests/recursive-types.test.ts

@@ -1,6 +1,22 @@
 import { expect, expectTypeOf, test } from "vitest";
 import { z } from "zod/mini";
 
+test("recursive object schema type aliases", () => {
+  type ObjectField = z.ZodMiniObject<{ [k: string]: ObjectField }>;
+  type Field = z.ZodMiniString<string> | z.ZodMiniObject<{ [k: string]: Field }>;
+  type ObjectValue = { [k: string]: ObjectValue };
+  type Value = string | { [k: string]: Value };
+  expectTypeOf<z.input<ObjectField>>().toEqualTypeOf<ObjectValue>();
+  expectTypeOf<z.output<ObjectField>>().toEqualTypeOf<ObjectValue>();
+  expectTypeOf<keyof z.input<ObjectField>>().toEqualTypeOf<string>();
+  expectTypeOf<keyof z.output<ObjectField>>().toEqualTypeOf<string>();
+  expectTypeOf<z.input<Field>>().toEqualTypeOf<Value>();
+  expectTypeOf<z.output<Field>>().toEqualTypeOf<Value>();
+  const schema: Field = z.object({ nested: z.object({ name: z.string() }) });
+  expect(schema.parse({ nested: { name: "a", extra: true } })).toEqual({ nested: { name: "a" } });
+  expect(schema.safeParse({ nested: { name: 123 } }).success).toBe(false);
+});
+
 test("recursion with z.lazy", () => {
   const data = {
     name: "I",

package/v4/core/compile.cjs

@@ -1525,7 +1525,7 @@ function generateDiscriminatedUnionCheck(doc, ctx, def, accessor) {
         if (!values || values.size === 0) {
             throw new ZodCompileUnsupportedError("discriminated union option without static discriminator values");
         }
-        // Two options claiming one value are not discriminable, and the branch chain below would silently give it to the first. Declining to compile hands that back to the interpreter, whose own map build reports it.
+        // let the interpreter handle collisions instead of compiling first-match dispatch
         for (const value of values) {
             if (claimed.has(value)) {
                 throw new ZodCompileUnsupportedError(`duplicate discriminator value ${String(value)}`);

package/v4/core/compile.js

@@ -1494,7 +1494,7 @@ function generateDiscriminatedUnionCheck(doc, ctx, def, accessor) {
         if (!values || values.size === 0) {
             throw new ZodCompileUnsupportedError("discriminated union option without static discriminator values");
         }
-        // Two options claiming one value are not discriminable, and the branch chain below would silently give it to the first. Declining to compile hands that back to the interpreter, whose own map build reports it.
+        // let the interpreter handle collisions instead of compiling first-match dispatch
         for (const value of values) {
             if (claimed.has(value)) {
                 throw new ZodCompileUnsupportedError(`duplicate discriminator value ${String(value)}`);