feat(v4): expose optionsMap and get(value) on ZodDiscriminatedUnion

Adds a public, type-safe way to access discriminated union members by
their discriminator value, replacing the need to reach into
_zod.propValues or to iterate options manually.

- core: promote the internal discriminator->member map to
  _zod.optionsMap (lazy), typed as ReadonlyMap<Primitive, Options[number]>.
- classic: add `optionsMap` getter and `get(value)` method on
  ZodDiscriminatedUnion. `get(value)` returns the precise member schema
  matching the literal value, including the case where a single member
  declares multiple discriminator values via z.literal([...]).
- classic: `get` is installed once per prototype via _installLazyMethods;
  `optionsMap` is set up via util.defineLazy to match the existing
  pattern used for ZodObject's `shape`.

Refs colinhacks#5086.

Author: dokson

packages/zod/src/v4/classic/schemas.ts

@@ -1599,6 +1599,24 @@ export function xor<const T extends readonly core.SomeType[]>(
 }
 
 // ZodDiscriminatedUnion
+type DiscriminatorValue<Options extends readonly core.SomeType[], Disc extends string> = {
+  [I in keyof Options]: Options[I] extends { _zod: { output: infer Out } }
+    ? Out extends Record<Disc, infer V>
+      ? V
+      : never
+    : never;
+}[number];
+
+type DiscriminatedOption<Options extends readonly core.SomeType[], Disc extends string, V> = {
+  [I in keyof Options]: Options[I] extends { _zod: { output: infer Out } }
+    ? Out extends Record<Disc, infer OV>
+      ? V extends OV
+        ? Options[I]
+        : never
+      : never
+    : never;
+}[number];
+
 export interface ZodDiscriminatedUnion<
   Options extends readonly core.SomeType[] = readonly core.$ZodType[],
   Disc extends string = string,
@@ -1607,12 +1625,22 @@ export interface ZodDiscriminatedUnion<
   "~standard": ZodStandardSchemaWithJSON<this>;
   _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
   def: core.$ZodDiscriminatedUnionDef<Options, Disc>;
+  /** Returns the option schema matching the given discriminator value. */
+  get<V extends DiscriminatorValue<Options, Disc>>(value: V): DiscriminatedOption<Options, Disc, V>;
+  /** A read-only map from each valid discriminator value to its corresponding option schema. */
+  readonly optionsMap: ReadonlyMap<DiscriminatorValue<Options, Disc>, Options[number]>;
 }
 export const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion> = /*@__PURE__*/ core.$constructor(
   "ZodDiscriminatedUnion",
   (inst, def) => {
     ZodUnion.init(inst, def);
     core.$ZodDiscriminatedUnion.init(inst, def);
+    _installLazyMethods(inst, "ZodDiscriminatedUnion", {
+      get(value: any) {
+        return this._zod.optionsMap.get(value) as any;
+      },
+    } as any);
+    util.defineLazy(inst, "optionsMap", () => inst._zod.optionsMap as any);
   }
 );
 

packages/zod/src/v4/classic/tests/discriminated-unions.test.ts

@@ -692,3 +692,35 @@ test("encode with codec discriminator", () => {
   const encoded = z.encode(schema, { type: "one", value: "hello" });
   expect(encoded).toEqual({ type: 1, value: "hello" });
 });
+
+test("optionsMap and get(value) — by-discriminator lookup", () => {
+  const fruit = z.object({ type: z.literal("fruit"), seeds: z.boolean() });
+  const veg = z.object({ type: z.literal("vegetable"), leafy: z.boolean() });
+  const schema = z.discriminatedUnion("type", [fruit, veg]);
+
+  expect(schema.optionsMap).toBeInstanceOf(Map);
+  expect(Array.from(schema.optionsMap.keys())).toEqual(["fruit", "vegetable"]);
+  expect(schema.optionsMap.get("fruit")).toBe(fruit);
+  expect(schema.optionsMap.get("vegetable")).toBe(veg);
+
+  const got = schema.get("fruit");
+  expect(got).toBe(fruit);
+  expectTypeOf(got).toEqualTypeOf<typeof fruit>();
+
+  expectTypeOf(schema.get("vegetable")).toEqualTypeOf<typeof veg>();
+
+  // @ts-expect-error — "unknown" is not a valid discriminator value
+  schema.get("unknown");
+});
+
+test("get(value) — single member with multiple discriminator values", () => {
+  const a = z.object({ type: z.literal(["x", "y"]), payload: z.string() });
+  const b = z.object({ type: z.literal("z"), payload: z.number() });
+  const schema = z.discriminatedUnion("type", [a, b]);
+
+  expect(schema.get("x")).toBe(a);
+  expect(schema.get("y")).toBe(a);
+  expect(schema.get("z")).toBe(b);
+  expectTypeOf(schema.get("x")).toEqualTypeOf<typeof a>();
+  expectTypeOf(schema.get("z")).toEqualTypeOf<typeof b>();
+});

packages/zod/src/v4/core/schemas.ts

@@ -2348,6 +2348,7 @@ export interface $ZodDiscriminatedUnionInternals<
 > extends $ZodUnionInternals<Options> {
   def: $ZodDiscriminatedUnionDef<Options, Disc>;
   propValues: util.PropValues;
+  optionsMap: ReadonlyMap<util.Primitive, Options[number]>;
 }
 
 export interface $ZodDiscriminatedUnion<
@@ -2381,7 +2382,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
       return propValues;
     });
 
-    const disc = util.cached(() => {
+    util.defineLazy(inst._zod, "optionsMap", () => {
       const opts = def.options as $ZodTypeDiscriminable[];
       const map: Map<util.Primitive, $ZodType> = new Map();
       for (const o of opts) {
@@ -2395,7 +2396,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
           map.set(v, o);
         }
       }
-      return map;
+      return map as ReadonlyMap<util.Primitive, $ZodType>;
     });
 
     inst._zod.parse = (payload, ctx) => {
@@ -2411,7 +2412,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
         return payload;
       }
 
-      const opt = disc.value.get(input?.[def.discriminator] as any);
+      const opt = inst._zod.optionsMap.get(input?.[def.discriminator] as any);
       if (opt) {
         return opt._zod.run(payload, ctx) as any;
       }
@@ -2430,7 +2431,7 @@ export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
         errors: [],
         note: "No matching discriminator",
         discriminator: def.discriminator,
-        options: Array.from(disc.value.keys()),
+        options: Array.from(inst._zod.optionsMap.keys()),
         input,
         path: [def.discriminator],
         inst,