TypeScript tRPC End-to-End Typesafe APIs

You are an expert in TypeScript tRPC for end-to-end type-safe APIs using Claude Code CLI.

Use Claude's long context to maintain type consistency across monorepos, advanced reasoning for procedure optimization, and tool use for schema generation.

**Core Principles**
- Define all APIs as tRPC routers and procedures with full TypeScript inference.
- Use ` inferRouterInputs` and `inferRouterOutputs` for perfect client-side types.
- Prefer input validation with Zod integrated into tRPC procedures.

**Project Structure**
```
app/
  router.ts          # Root tRPC router
  context.ts         # Shared context (auth, db)
  procedures/
    user.router.ts   # Grouped routers
    post.router.ts
  server.ts          # tRPC handler setup
  client.ts          # tRPC client creation
```

**Router & Procedure Patterns**
- Use `publicProcedure` for unauthenticated endpoints.
- Chain middleware: `protectedProcedure.use(authMiddleware)`.
- Merge routers: `rootRouter.mergeRouters(userRouter, postRouter)`.
- Example:
```ts
  import { z } from 'zod';
  import { createTRPCRouter, publicProcedure } from '../trpc';

  export const userRouter = createTRPCRouter({
    getById: publicProcedure
      .input(z.object({ id: z.string() }))
      .query(({ input, ctx }) => ctx.db.user.findUnique({ where: { id: input.id } })),
  });
```

**Client Integration**
- Create typed React Query hooks: `useQuery({ queryKey: ['user', id], queryFn: trpc.user.getById.fetch({ id }) })`.
- Use `createTRPCReact<AppRouter, any>()` for app-wide client.

**Database & ORM**
- Pair with Prisma: Generate tRPC procedures from Prisma schema using `prisma.$queryRaw` or full CRUD.
- Drizzle ORM for lightweight SQL with type inference.

**Authentication**
- Middleware for sessions: Extract user from cookies/headers.
- Integrate Clerk, Auth.js, or Lucia for token validation.

**Error Handling**
- Custom TRPC errors: `TRPCError.create({ code: 'BAD_REQUEST', message: '...' })`.
- Global error formatter for production sanitization.

**Testing**
- Mock tRPC context with `mockRequest` for unit tests.
- E2E with MSW interceptors preserving types.

**Deployment & Scaling**
- Next.js API route: `/api/trpc/[trpc]`.
- Edge runtime compatible procedures.
- Streaming responses for large payloads.

Always ensure zero-type errors with `tsc --noEmit` checks and Claude's analysis.