Type instantiation is excessively deep and possibly infinite" when using Zod with React Hook Form and @hookform/resolvers

[ahmettavsan]

Zod 3.25.20
Typescript 5.7
"turbo": "^2.5.3",

i am receiving Type instantiation is excessively deep and possibly infinite.ts(2589)

import { useForm } from "react-hook-form";
import { z } from "zod";
import { zodResolver } from "@hookform/resolvers/zod";
import {
  Form,
  FormField,
  FormItem,
  FormLabel,
  FormControl,
  FormMessage,
} from "./form";

import { Input } from "./input";
import { Button } from "./button";

const formSchema = z.object({
  name: z.string().min(2, { message: "İsim en az 2 karakter olmalı" }),
  email: z.string().email({ message: "Geçerli bir e-posta girin" }),
});
type FormSchema = {
  name: string;
  email: string;
};

export default function UserForm() {
  const form = useForm<FormSchema>({
    resolver: zodResolver(formSchema),
    defaultValues: {
      name: "",
      email: "",
    },
  });

  const onSubmit = (values: FormSchema) => {
    console.log("Form gönderildi:", values);
  };

  return (
    <Form {...form}>
      <form
        onSubmit={form.handleSubmit(onSubmit)}
        className="max-w-md space-y-4"
      >
        <FormField
          control={form.control}
          name="name"
          render={({ field }) => (
            <FormItem>
              <FormLabel>İsim</FormLabel>
              <FormControl>
                <Input placeholder="Adınızı girin" {...field} />
              </FormControl>
              <FormMessage />
            </FormItem>
          )}
        />

        <FormField
          control={form.control}
          name="email"
          render={({ field }) => (
            <FormItem>
              <FormLabel>Email</FormLabel>
              <FormControl>
                <Input
                  type="email"
                  placeholder="E-posta adresinizi girin"
                  {...field}
                />
              </FormControl>
              <FormMessage />
            </FormItem>
          )}
        />

        <Button type="submit">Gönder</Button>
      </form>
    </Form>
  );
}

[colinhacks]

Can you create a reproduction repo? There are too many other moving parts (config files, dependency resolution) for me to reproduce with the information provided.

[dr1ss]

@ahmettavsan can you please try to install versions 3.25.7 and 3.25.8 and tell me if you start having this with version 3.25.8 ?

[gr2m]

👋🏼 I ran into the same error while working on vercel/ai#6421. I upgraded to zod@3.25.30

I created a minimal test case to reproduce the error

TypeScript playground

import * as z3 from 'zod/v3';
import * as z4 from 'zod/v4/core';
import { z } from 'zod/v4'

export function test<
  RESULT extends SCHEMA extends z4.$ZodType
    ? z4.infer<SCHEMA>
    : SCHEMA extends z3.Schema
      ? z3.infer<SCHEMA>
     // ^ Type instantiation is excessively deep and possibly infinite
        : never,
  SCHEMA extends z3.Schema | z4.$ZodType,
>(
  schema: SCHEMA,
): RESULT {
  return {} as unknown as RESULT;
}

const schema = z.object({ foo: z.string()})
const funk = test(schema)
const testString: string = funk.foo

const yo: z4.infer<typeof schema> = {
  foo: 'yo'
}

Update

slightly simpler test case

import * as z3 from 'zod/v3';
import * as z4 from 'zod/v4/core';

export function test<
  RESULT extends SCHEMA extends z3.Schema
    ? z3.infer<SCHEMA>
   // ^ Type instantiation is excessively deep and possibly infinite
    : never,
  SCHEMA extends z3.Schema | z4.$ZodType,
>(
  schema: SCHEMA,
): RESULT {
  return {} as unknown as RESULT;
}

const schema = z3.z.object({ foo: z3.z.string()})
const funk = test(schema)
const testString: string = funk.foo

If I replace SCHEMA extends z3.Schema | z4.$ZodType with just SCHEMA extends z3.Schema then the error goes away, so it has something to do that with the fact that type can be either a z3 or z4 type

The error also goes away when doing SCHEMA extends z4.$ZodType ? z4.infer<SCHEMA> instead of using the z3 APIs in the example above. So there must be something that z4.infer does that z3.infer doesn't?

full example using z4 APIs

import * as z3 from 'zod/v3';
import * as z4 from 'zod/v4/core';
import { z } from 'zod/v4';

export function test<
  RESULT extends SCHEMA extends z4.$ZodType
    ? z4.infer<SCHEMA>
        : never,
  SCHEMA extends z4.$ZodType | z3.Schema,
>(
  schema: SCHEMA,
): RESULT {
  return {} as unknown as RESULT;
}

const schema = z.object({ foo: z.string()})
const funk = test(schema)
const testString: string = funk.foo

[gr2m]

@OscarCornish figured out the problem of the "Type instantiation is excessively deep and possibly infinite" error in my test case above. It's not a bug with zod.

I think it's because you are defining RESULT before SCHEMA, even though it depends on schema, which is triggering re-evaluation

Here is the working code for reference: playground link

import * as z3 from 'zod/v3';
import * as z4 from 'zod/v4/core';

type InferSchema<S> =
  S extends z3.Schema ? z3.infer<S> :
  S extends z4.$ZodType ? z4.infer<S> :
  never;

export function test<
  SCHEMA extends z3.Schema | z4.$ZodType,
  RESULT = InferSchema<SCHEMA>
  
>(
  schema: SCHEMA,
): RESULT {
  return {} as unknown as RESULT;
}

const schema = z3.z.object({ foo: z3.z.string()})
const funk = test(schema)
const testString: string = funk.foo

Sorry for the noise, feel free to hide my comments as off topic or resolved.

[colinhacks]

I'm not able to reproduce the original issue with the information provided. Reproductions should be self-contained.

It's very likely this is fixed in recent versions, which contain changes to mitigate "Excessively deep" errors.

Zod 4 support for RHF can be tracked here: react-hook-form/resolvers#776

cc @gr2m Both of your original problem cases now work with zod@3.25.50 (and possible earlier versions).

cc @ahmettavsan for future reference use triple backticks to contain code blocks in issues

```ts
// typescript code here
```

[gr2m]

cc @gr2m Both of your original problem cases now work with zod@3.25.50 (and possible earlier versions).

yes, confirmed! Thanks for all your great work @colinhacks!