Thanks for the report and the PR. Pushed a different fix on top — wanted to flag what changed and why.

Approach: instead of adding a special-case invalid_type issue with expected: "never", I just guarded the cached first runner so it's only captured when def.options.length === 1. The existing handleUnionResults / handleExclusiveUnionResults helpers already emit invalid_union with errors: [] when given an empty results array, so no new parse branch is needed. Net diff in core/schemas.ts is −6 / +4.

Why not expected: "never": that issue shape collides with what z.never() actually emits, so consumers can't distinguish "input rejected by z.never()" from "input rejected by an empty union." invalid_union with errors: [] is consistent with how non-empty unions report a no-match.

Coverage: also fixes z.discriminatedUnion("...", []) (and zod/mini equivalents), which crashed for the same reason via $ZodUnion.init. Tests added for all six surfaces.

Going to merge as-is.

Comment written with AI assistance.

Reviewed PR #5869. Approved — the fix correctly prevents the out-of-bounds access on empty union/xor options by combining the single/first variables into a single conditional. Traced the empty-results path through both handleUnionResults and handleExclusiveUnionResults to confirm correct invalid_union error production. Review

  ^{｜ View workflow run ｜ via Pullfrog ｜ Using Claude Opus ｜ 𝕏}

TL;DR — z.union([]), z.xor([]), and z.discriminatedUnion(_, []) previously threw an internal error when parsing because the code unconditionally accessed def.options[0]. This PR guards that access so empty unions construct cleanly and reject all input with an invalid_union issue — matching the never type they already infer.

Key changes

• Guard against empty options in $ZodUnion and $ZodXor parse setup — collapses the separate single boolean and first accessor into a single nullable assignment, preventing the crash when options is empty.
• Add tests for empty z.union([]), z.xor([]), and z.discriminatedUnion(_, []) in classic and mini — verifies construction succeeds and that parsing any value produces the expected invalid_union issue with an empty errors array.

_{Summary ｜ 3 files ｜ 1 commit ｜ base: main ← empty-union}

Empty union/xor no longer crashes at parse time

Before: calling z.union([]).safeParse(value) or z.xor([]).safeParse(value) threw a runtime error — def.options[0]._zod.run accessed index 0 of an empty array.
After: both schemas construct without error and reject every input with an invalid_union issue containing an empty errors list, consistent with the never type already inferred at the type level.

The fix is a one-line change applied identically in both $ZodUnion and $ZodXor: the single flag and eager first dereference are merged into a single conditional expression (def.options.length === 1 ? def.options[0]._zod.run : null). When first is null, the fast-path if (first) branch is skipped and the normal multi-option loop runs — which naturally produces the correct invalid_union error for zero options.

z.discriminatedUnion with an empty array already survived construction (it delegates to $ZodUnion.init) but the tests confirm it also reports the right issue shape.

packages/zod/src/v4/core/schemas.ts · packages/zod/src/v4/classic/tests/union.test.ts · packages/zod/src/v4/mini/tests/index.test.ts

  ^{｜ View workflow run ｜ via Pullfrog ｜ Using Claude Opus ｜ 𝕏}

Landed in Zod 4.4