feat: zodmint/hono and zodmint/trpc adapters (v2.7.0)

- zodmint/hono: mockHonoHandler() — Hono Handler returning c.json(mock(schema))
  mockHonoApp() — full stub Hono app from route spec array
  Peer dep: hono >= 3.0.0

- zodmint/trpc: mockTrpcCaller() — Proxy-based caller, no @trpc/server required
  mockProcedureOutput() — synchronous one-off output generation
  Per-procedure { schema, options } form supported

- README, CHANGELOG, ROADMAP, playground updated
- 568 tests passing

Author: gonll

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to zodmint are documented here. This project follows [Keep a
 
 ---
 
+## [2.7.0] - 2026-06-03
+
+### Added
+- **`zodmint/hono`** — new sub-entry for testing Hono routes with schema-valid mock data. `mockHonoHandler(schema, options?)` returns a Hono `Handler` that responds with `c.json(mock(schema))`. `mockHonoApp(specs)` builds a complete stub Hono app from a route spec array (`"METHOD /path"`). Supports `status`, `headers`, all `MockOptions`. Invalid method or malformed route throws `ZodForgeError`. Peer dep: `hono >= 3.0.0`.
+- **`zodmint/trpc`** — new sub-entry for mocking tRPC callers. `mockTrpcCaller(procedureMap)` returns a Proxy-based caller where any procedure chain resolves to `Promise<z.infer<S>>`. No `@trpc/server` peer dependency required. Procedure map values can be bare schemas or `{ schema, options }` for per-procedure `MockOptions`. Unknown procedures return `Promise<undefined>`. `mockProcedureOutput(schema, options?)` is a synchronous named wrapper around `mock()` for one-off output generation.
+
+---
+
 ## [2.6.0] - 2026-06-03
 
 ### Added

README.md

@@ -1354,6 +1354,94 @@ const feed = client.getQueryData(["feed"]);
 
 ---
 
+### Hono — `zodmint/hono`
+
+zodmint ships a `zodmint/hono` sub-entry for testing Hono routes with schema-valid mock data. Zero overhead: responds with `c.json()` directly, no HTTP roundtrip.
+
+```bash
+npm install hono
+```
+
+```typescript
+import { mockHonoHandler, mockHonoApp } from "zodmint/hono";
+```
+
+**`mockHonoHandler(schema, options?)`** — a Hono `Handler` that responds with valid mock JSON. Drop it into any route:
+
+```typescript
+import { Hono } from "hono";
+import { mockHonoHandler } from "zodmint/hono";
+
+const app = new Hono();
+app.get("/users/:id", mockHonoHandler(UserSchema));
+app.post("/users",    mockHonoHandler(UserSchema, { status: 201, seed: 42 }));
+
+const res  = await app.request("/users/1");
+const user = await res.json();
+// user passes UserSchema.safeParse  ✓
+```
+
+Accepts all `MockOptions` plus `status` (default 200) and `headers`.
+
+**`mockHonoApp(specs)`** — builds a complete mock Hono app in one call. Useful when you want a full stub API for integration tests:
+
+```typescript
+const mockApi = mockHonoApp([
+  { route: "GET /users/:id", schema: UserSchema },
+  { route: "POST /users",    schema: UserSchema, status: 201 },
+  { route: "GET /posts",     schema: z.array(PostSchema), seed: 2 },
+]);
+
+const res   = await mockApi.request("/posts");
+const posts = await res.json();
+// posts is a valid Post[]  ✓
+```
+
+Route format is `"METHOD /path"` — same convention as `zodmint/msw`. Invalid method or missing space throws `ZodForgeError`.
+
+---
+
+### tRPC — `zodmint/trpc`
+
+zodmint ships a `zodmint/trpc` sub-entry for mocking tRPC callers in unit tests. No `@trpc/server` required — the mock caller is a Proxy that intercepts any procedure chain and returns schema-valid data.
+
+```typescript
+import { mockTrpcCaller, mockProcedureOutput } from "zodmint/trpc";
+```
+
+**`mockTrpcCaller(procedureMap, defaultOptions?)`** — creates a mock caller. Keys are dot-separated procedure paths; values are Zod output schemas (or `{ schema, options }` for per-procedure control):
+
+```typescript
+const caller = mockTrpcCaller({
+  "users.getById": UserSchema,
+  "users.list":    z.array(UserSchema),
+  "posts.create":  { schema: PostSchema, options: { seed: 1 } },
+});
+
+const user  = await caller.users.getById({ id: "1" });   // valid User
+const users = await caller.users.list();                  // valid User[]
+const post  = await caller.posts.create({ title: "hi" }); // valid Post
+```
+
+Every procedure call returns `Promise<z.infer<S>>`. Input arguments are accepted but ignored. Procedures not in the map return `Promise<undefined>` — useful for partially mocking a router.
+
+Cast to your router's caller type for full IDE completion:
+
+```typescript
+import type { createCallerFactory } from "@trpc/server";
+type Caller = ReturnType<ReturnType<typeof createCallerFactory<typeof appRouter>>>;
+
+const caller = mockTrpcCaller({ ... }) as Caller;
+```
+
+**`mockProcedureOutput(schema, options?)`** — synchronous one-off output generation. Named wrapper around `mock()` for clarity in tRPC test contexts:
+
+```typescript
+const output = mockProcedureOutput(getUserOutputSchema, { seed: 42 });
+```
+
+---
+
 ## Prior art
 
 zodmint was built with an eye on the existing ecosystem. Three libraries were studied for orientation:

examples/18-hono.ts

@@ -0,0 +1,36 @@
+// 18-hono.ts — zodmint/hono: mock handlers and apps for Hono route testing
+import { z } from "zod";
+import { Hono } from "hono";
+import { mockHonoHandler, mockHonoApp } from "../src/hono.js";
+
+const UserSchema = z.object({
+  id:    z.string().uuid(),
+  name:  z.string(),
+  email: z.string().email(),
+});
+
+const PostSchema = z.object({
+  id:     z.string().uuid(),
+  title:  z.string(),
+  userId: z.string().uuid(),
+});
+
+// --- mockHonoHandler: attach to any Hono app ---
+const app = new Hono();
+app.get("/users/:id", mockHonoHandler(UserSchema, { seed: 1 }));
+app.post("/users",    mockHonoHandler(UserSchema, { status: 201 }));
+
+const res  = await app.request("/users/abc");
+const user = await res.json();
+console.log("GET /users/:id →", user);
+
+// --- mockHonoApp: build a complete mock API in one call ---
+const mockApi = mockHonoApp([
+  { route: "GET /users/:id", schema: UserSchema },
+  { route: "GET /posts",     schema: z.array(PostSchema), seed: 2 },
+  { route: "POST /users",    schema: UserSchema, status: 201 },
+]);
+
+const postRes  = await mockApi.request("/posts");
+const posts    = await postRes.json();
+console.log("GET /posts →", posts);

examples/19-trpc.ts

@@ -0,0 +1,35 @@
+// 19-trpc.ts — zodmint/trpc: mock callers for tRPC procedure testing
+import { z } from "zod";
+import { mockTrpcCaller, mockProcedureOutput } from "zodmint/trpc";
+
+const UserSchema = z.object({
+  id:    z.string().uuid(),
+  name:  z.string(),
+  email: z.string().email(),
+  role:  z.enum(["admin", "user"]),
+});
+
+const PostSchema = z.object({
+  id:      z.string().uuid(),
+  title:   z.string(),
+  userId:  z.string().uuid(),
+});
+
+// --- mockTrpcCaller: mock a full router's procedures ---
+const caller = mockTrpcCaller({
+  "users.getById":  UserSchema,
+  "users.list":     z.array(UserSchema),
+  "posts.create":   { schema: PostSchema, options: { seed: 1 } },
+});
+
+const user  = await (caller as any).users.getById({ id: "1" });
+const users = await (caller as any).users.list();
+const post  = await (caller as any).posts.create({ title: "Hello" });
+
+console.log("user:",  user);
+console.log("users:", users);
+console.log("post:",  post);
+
+// --- mockProcedureOutput: one-off synchronous output generation ---
+const output = mockProcedureOutput(UserSchema, { seed: 42 });
+console.log("procedure output:", output);

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "zodmint",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "TypeScript-first schema-valid test fixture generator for Zod schemas",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -41,6 +41,16 @@
       "types": "./dist/tanstack-query.d.ts",
       "import": "./dist/tanstack-query.js",
       "require": "./dist/tanstack-query.cjs"
+    },
+    "./trpc": {
+      "types": "./dist/trpc.d.ts",
+      "import": "./dist/trpc.js",
+      "require": "./dist/trpc.cjs"
+    },
+    "./hono": {
+      "types": "./dist/hono.d.ts",
+      "import": "./dist/hono.js",
+      "require": "./dist/hono.cjs"
     }
   },
   "bin": {
@@ -69,11 +79,12 @@
   },
   "peerDependencies": {
     "@prisma/client": ">=5.0.0",
+    "@tanstack/query-core": ">=5.0.0",
     "drizzle-orm": ">=0.29.0",
     "fast-check": ">=3.0.0",
     "msw": ">=2.0.0",
     "zod": ">=3.23.0",
-    "@tanstack/query-core": ">=5.0.0"
+    "hono": ">=3.0.0"
   },
   "peerDependenciesMeta": {
     "@prisma/client": {
@@ -90,48 +101,54 @@
     },
     "@tanstack/query-core": {
       "optional": true
+    },
+    "hono": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@tanstack/query-core": "^5.101.0",
     "@types/node": "^20.0.0",
     "fast-check": "^3.22.0",
+    "hono": "^4.12.23",
     "msw": "^2.14.6",
     "tsup": "^8.0.0",
     "typescript": "^5.4.0",
     "vitest": "^1.6.0",
     "zod": "^4.4.3"
   },
   "keywords": [
-    "zod",
-    "mock",
-    "fixture",
-    "factory",
-    "testing",
+    "boundary-testing",
     "typescript",
-    "schema",
-    "generator",
-    "test-data",
+    "fake-data",
     "mock-data",
+    "factory",
+    "coverage",
+    "db-seed",
     "fixtures",
-    "zod-mock",
-    "zod-faker",
-    "test-fixtures",
-    "fake-data",
-    "data-generator",
-    "msw",
-    "mock-service-worker",
+    "mock",
+    "fixture",
     "snapshot",
-    "pin",
-    "seed",
-    "cli",
     "prisma",
     "drizzle",
+    "cli",
+    "zod",
+    "hono",
+    "trpc",
+    "schema",
     "database-seeding",
-    "db-seed",
+    "msw",
+    "zod-faker",
+    "test-fixtures",
+    "generator",
+    "pin",
+    "test-data",
+    "data-generator",
+    "testing",
+    "seed",
+    "mock-service-worker",
     "storybook",
-    "coverage",
-    "boundary-testing"
+    "zod-mock"
   ],
   "license": "MIT",
   "author": {
@@ -146,4 +163,4 @@
   "bugs": {
     "url": "https://github.com/gonll/zodmint/issues"
   }
-}
+}