Type instantiation error when using exported Hono RPC types across different directories

[student-101]

Note: I'm new to frontend development, so I apologize if I'm missing something obvious.

I'm encountering a TypeScript error when trying to use Hono's RPC functionality across different directories. The same code works fine when the client is in the same file as the endpoint definition, but fails with a "Type instantiation is excessively deep and possibly infinite" error when the type is exported and used in another directory.

One of Hono's great features is supposed to be its ability to share types between backend and frontend without explicit type definitions, but I'm unable to achieve this across directories.

Here's a working example (same file):

// backend/index.ts
import { Hono } from "hono";
import { hc } from "hono/client";

const app = new Hono()
  .get("/", (c) => c.json({ result: "list books" }))
  .post("/", (c) => c.json({ result: "create a book" }, 201))
  .get("/:id", (c) => c.json({ result: `get ${c.req.param("id")}` }));

const bookApp = new Hono().route("/books", app);

// Works fine
const client = hc<typeof bookApp>("http://localhost/book");

But when I try to use it across directories:

Directory structure:

my-project/
├── backend/
│   ├── index.ts
│   └── package.json
├── frontend/
│   ├── app/
│   │   └── features/
│   │       └── book/
│   │           └── page.tsx
│   └── package.json
├── package.json
└── tsconfig.json

// backend/index.ts
import { Hono } from "hono";
import { hc } from "hono/client";

const app = new Hono()
  .get("/", (c) => c.json({ result: "list books" }))
  .post("/", (c) => c.json({ result: "create a book" }, 201))
  .get("/:id", (c) => c.json({ result: `get ${c.req.param("id")}` }));

const bookApp = new Hono().route("/books", app);
export type BookAppType = typeof bookApp;

// frontend/app/features/book/page.tsx
import { BookAppType } from "@/backend/index";
import { hc } from "hono/client";

// Error: Type instantiation is excessively deep and possibly infinite.ts(2589)
const clientA = hc<BookAppType>("http://localhost/book");

I know I could work around this by explicitly defining types in a shared types file, but that defeats one of the main benefits of Hono's RPC functionality. Is this a known limitation? Are there any solutions that preserve the automatic type inference across directories?

Environment:

• Hono version: 4.6.11

[student-101]

Solved! I wanted to share the solution in case anyone encounters the same issue.

The problem was caused by two factors:

1. Version mismatch between Hono in frontend and backend dependencies

   • After aligning the Hono versions in both packages, part of the issue was resolved

2. Missing TypeScript compiler options

   • The key was adding "strict": true to the compilerOptions in all tsconfig.json files:
     • root tsconfig.json
     • frontend tsconfig.json
     • backend tsconfig.json

After fixing these two issues, the type inference works correctly across directories as expected.

Thanks for the great RPC functionality in Hono! I'm closing this discussion.