schema composition causes Type instantiation is excessively deep and possibly infinite

[asyncawaits]

const baseSchema = v.object({
  [PropertyApiFields?.SELLER_ID]: v.nullish(
    v.pipe(v.string("Invalid company"), v.nonEmpty("Please enter company"))
  ),
  // ...107 more fields
});

const pipedSchema1 = v.pipe(
  baseSchema,
  v.forward(
    v.partialCheck(
      [[PropertyApiFields?.SELLER_ID]],
      (input) => !!input?.[PropertyApiFields?.SELLER_ID],
      "Please select company"
    ),
    [PropertyApiFields?.SELLER_ID]
  ),
  //...18 more fields
);

const pipedSchema2 = v.pipe(
  pipedSchema1,
    //...19 more fields
);

const pipedSchema3 = v.pipe(
  pipedSchema2,
    //...19 more fields
);

const pipedSchema4 = v.pipe(
  pipedSchema3,
    //...19 more fields
);

export const addPropertySchema = v.pipe(
  pipedSchema1,
  pipedSchema2,
  pipedSchema3,
  pipedSchema4
);

export type PropertyRHFInterface = v.InferOutput<typeof addPropertySchema>;

I'm using Valibot version 0.41.0.

[dosubot[bot]]

Hi @asyncawaits! I'm Dosu and I’m helping the valibot team.

This TypeScript error happens because Valibot's schema composition (especially with large objects and deep use of v.pipe, v.forward, and v.partialCheck) creates very complex, deeply nested generic types. TypeScript's type system has limits, and when these are exceeded, you get "Type instantiation is excessively deep and possibly infinite"—especially when inferring types with v.InferOutput on a heavily composed schema.

A known workaround is to use an interface declaration instead of a type alias for your inferred output type. For example, instead of:

export type PropertyRHFInterface = v.InferOutput<typeof addPropertySchema>;

use:

export interface PropertyRHFInterface extends v.InferOutput<typeof addPropertySchema> {}

This pattern has been shown to resolve the error in similar cases with Valibot and RTK Query generics [source].

Other general strategies: split your schema into smaller parts, reduce the depth of composition, or use type assertions (as any) if you can accept less type safety. There are no built-in Valibot solutions for this TypeScript limitation, and recent updates have not introduced new workarounds [source].

Let me know if you want more details on splitting schemas or other patterns!

To reply, just mention @dosu.

---

Share context across your team and agents. Try Dosu.

[asyncawaits]

did not fix the issue by replacingexport type PropertyRHFInterface = v.InferOutput<typeof addPropertySchema>; this with export interface PropertyRHFInterface extends v.InferOutput<typeof addPropertySchema> {}

[dosubot[bot]]

The interface workaround doesn't always resolve this TypeScript error, especially with large or deeply composed Valibot schemas. This happens because TypeScript's type system has limits on recursion and complexity, which Valibot's heavy use of generics and composition can easily exceed—particularly with many nested pipes, forwards, and partials.

There aren't any built-in Valibot solutions or documented workarounds for this issue, and recent updates haven't introduced new fixes for deep type instantiation errors [source]. The main strategies are to split your schema into smaller, more manageable parts, reduce composition depth, or use type assertions like as any if you can accept less type safety. Manual type definitions for your output interface (writing out the shape yourself) can also avoid inference entirely.

If you need more details on how to split schemas or flatten composition, let me know—happy to help brainstorm patterns that fit your use case.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[fabian-hiller]

Can you share a minimal reproduction via the Valibot playground? And can you check if this is fixed in the latest Valibot version?

[asyncawaits]

Thanks for the quick reply.

I tried using the latest version of Valibot (1.1.0), but it didn’t fix the issue. It works fine with fewer fields, but it breaks when handling larger validation schemas.

Since this is production code, I can’t share it on the Valibot playground. Can I send you the project via email instead? It contains the relevant validation-related code.

[asyncawaits]

Hi,

I just wanted to follow up on this issue. I’d really appreciate it if you could take a look whenever you get a chance. I’ve attached the code repo link below for your reference. Please let me know if you need any additional details or clarification from my side.

Thank you for your time and support!

Code: https://github.com/abhishekmardiya/valibot

[fabian-hiller]

I cloned the repo and it worked as expected. I see no Type instantiation is excessively deep ... error in my editor. What TypeScript version are you using? I tested it with v5.9.2.

[asyncawaits]

Thank you so much! It worked after I upgraded my TypeScript version from 5.7.2 to 5.9.2.