ts-procedures 5.3.0 → 5.4.0

package/README.md

@@ -71,6 +71,41 @@ Create(name, config, handler)
 - `procedure` - Generic reference to the handler
 - `info` - Procedure meta (name, description, schema, `TExtendedConfig` properties, etc.)
 
+### Structured Input with schema.input
+
+For HTTP APIs and other multi-channel transports, `schema.input` provides per-channel type safety. Each key is an independently validated input channel:
+
+```typescript
+const { Create } = Procedures<AppContext, APIConfig>()
+
+const { UpdateUser } = Create(
+  'UpdateUser',
+  {
+    path: '/users/:id',
+    method: 'put',
+    schema: {
+      input: {
+        pathParams: Type.Object({ id: Type.String() }),
+        query: Type.Object({ notify: Type.Optional(Type.Boolean()) }),
+        body: Type.Object({ name: Type.String(), email: Type.String() }),
+      },
+      returnType: Type.Object({ ok: Type.Boolean() }),
+    },
+  },
+  async (ctx, { pathParams, query, body }) => {
+    // Each channel is independently typed and validated
+    await updateUser(pathParams.id, body)
+    if (query.notify) await sendNotification(pathParams.id)
+    return { ok: true }
+  }
+)
+```
+
+**Rules:**
+- `schema.input` and `schema.params` are **mutually exclusive** — defining both throws `ProcedureRegistrationError`
+- Each channel is validated independently with per-channel error messages
+- Works with both `Create` and `CreateStream`
+
 ### CreateStream Function
 
 The `CreateStream` function defines streaming procedures that yield values over time using async generators:
@@ -625,6 +660,54 @@ app.listen(3000)
 
 See [Express RPC Integration Guide](src/implementations/http/express-rpc/README.md) for complete setup instructions including lifecycle hooks, error handling, and route documentation.
 
+### Hono API Integration
+
+`ts-procedures` includes a REST-style HTTP integration for Hono that routes by HTTP method with per-channel input validation via `schema.input`.
+
+```typescript
+import { Procedures } from 'ts-procedures'
+import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
+import type { APIConfig } from 'ts-procedures/http'
+import { Type } from 'typebox'
+
+const API = Procedures<{ userId: string }, APIConfig>()
+
+API.Create('GetUser', {
+  path: '/users/:id',
+  method: 'get',
+  schema: {
+    input: {
+      pathParams: Type.Object({ id: Type.String() }),
+    },
+    returnType: Type.Object({ id: Type.String(), name: Type.String() }),
+  },
+}, async (ctx, { pathParams }) => {
+  return await fetchUser(pathParams.id)
+})
+
+API.Create('CreateUser', {
+  path: '/users',
+  method: 'post',
+  schema: {
+    input: {
+      body: Type.Object({ name: Type.String(), email: Type.String() }),
+    },
+  },
+}, async (ctx, { body }) => {
+  return await createUser(body)
+})
+
+const app = await new HonoAPIAppBuilder({ pathPrefix: '/api' })
+  .register(API, (c) => ({ userId: c.req.header('x-user-id') || 'anonymous' }))
+  .build()
+
+// Routes:
+// GET  /api/users/:id  → 200
+// POST /api/users      → 201
+```
+
+See [Hono API Integration Guide](src/implementations/http/hono-api/) for complete setup.
+
 ### Introspection with getProcedures()
 
 Access all registered procedures for documentation or routing:
@@ -769,6 +852,13 @@ import {
   TSchemaValidationError,
   Prettify,
 } from 'ts-procedures'
+
+// HTTP types
+import type { RPCConfig, RPCHttpRouteDoc, StreamHttpRouteDoc, StreamMode, APIConfig, APIHttpRouteDoc, APIInput, HttpMethod } from 'ts-procedures/http'
+
+// Hono API (REST-style)
+import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
+import type { APIConfig, APIHttpRouteDoc, APIInput, HttpMethod, QueryParser } from 'ts-procedures/hono-api'
 ```
 
 ## AI Agent Setup

package/agent_config/claude-code/agents/ts-procedures-architect.md

@@ -16,6 +16,7 @@ You are an architecture planning agent for applications built with **ts-procedur
 | `TContext` | Base context type injected into all handlers (auth, request info, services) |
 | `TExtendedConfig` | Additional config fields on every procedure (scope, version, permissions, etc.) |
 | `schema.params` | TypeBox schema — validated at runtime via AJV |
+| `schema.input` | Structured multi-channel input — each key independently typed/validated (alternative to `schema.params`) |
 | `schema.returnType` | Documentation only — NOT validated at runtime |
 | `schema.yieldType` | Schema for each streamed value — validated only if `validateYields: true` |
 
@@ -42,6 +43,7 @@ You are an architecture planning agent for applications built with **ts-procedur
 | `ExpressRPCAppBuilder` | Existing Express app, need RPC endpoints alongside REST |
 | `HonoRPCAppBuilder` | Existing Hono app, edge/serverless, need RPC endpoints |
 | `HonoStreamAppBuilder` | Need streaming (SSE or text), Hono-based |
+| `HonoAPIAppBuilder` | REST-style API with per-channel input (pathParams, query, body, headers) |
 | Multiple builders | Combine RPC + streaming on the same Hono app |
 
 ### Stream mode?
@@ -49,6 +51,13 @@ You are an architecture planning agent for applications built with **ts-procedur
 - **SSE** (`'sse'`) — Browser EventSource API, automatic reconnection, event types. Default.
 - **Text** (`'text'`) — Newline-delimited JSON. Simpler, works with any HTTP client.
 
+### schema.params vs schema.input?
+
+- **RPC-style** (single `params` object, POST-only) → `schema.params`
+- **REST-style** (multiple HTTP input sources) → `schema.input`
+- `schema.input` and `schema.params` are **mutually exclusive**
+- `schema.input` channels: `pathParams`, `query`, `body`, `headers`
+
 ### How to structure context?
 
 ```typescript
@@ -119,6 +128,9 @@ When asked to plan an API or procedure set:
 - `onCreate` callback on the factory enables framework integration — use it for route registration, middleware setup, or documentation generation.
 - `getProcedures()` returns all registered procedures for introspection (OpenAPI generation, testing, etc.).
 - AJV is configured with `allErrors: true`, `coerceTypes: true`, `removeAdditional: true`.
+- `schema.params` and `schema.input` are mutually exclusive — defining both throws `ProcedureRegistrationError`.
+- `HonoAPIAppBuilder.build()` is async — always `await` it.
+- Path param names in route template (`:id`) must match `schema.input.pathParams` property names.
 
 ## Output Format
 
@@ -164,6 +176,9 @@ type AuthContext = { userId: string; requestId: string; db: Database }
 - POST /api/health/health-check/1
 - POST /api/users/get-user/1
 - GET|POST /api/activity/stream-activity/1
+- GET /api/users/:id (HonoAPIAppBuilder)
+- POST /api/users (HonoAPIAppBuilder, 201)
+- DELETE /api/users/:id (HonoAPIAppBuilder, 204)
 
 ### Error Handling
 - Input validation: automatic (schema.params)

package/agent_config/claude-code/skills/guide/anti-patterns.md

@@ -480,6 +480,109 @@ new ExpressRPCAppBuilder({
 
 ---
 
+## 17. Using Both schema.params and schema.input
+
+**Problem:** Defining both `schema.params` and `schema.input` on the same procedure.
+
+```typescript
+// BAD — throws ProcedureRegistrationError at registration
+Create('GetUser', {
+  path: '/users/:id',
+  method: 'get',
+  schema: {
+    params: Type.Object({ id: Type.String() }),
+    input: {
+      pathParams: Type.Object({ id: Type.String() }),
+    },
+  },
+}, handler)
+```
+
+**Fix:** Choose one. Use `schema.params` for flat RPC-style input, `schema.input` for structured multi-channel input.
+
+```typescript
+// GOOD — schema.input for REST-style with per-channel validation
+Create('GetUser', {
+  path: '/users/:id',
+  method: 'get',
+  schema: {
+    input: {
+      pathParams: Type.Object({ id: Type.String() }),
+    },
+  },
+}, async (ctx, { pathParams }) => fetchUser(pathParams.id))
+
+// GOOD — schema.params for simple RPC-style
+Create('GetUser', {
+  scope: 'users', version: 1,
+  schema: { params: Type.Object({ id: Type.String() }) },
+}, async (ctx, params) => fetchUser(params.id))
+```
+
+**Why:** `schema.params` and `schema.input` are mutually exclusive by design. They represent different input paradigms — flat (RPC) vs structured (HTTP API).
+
+---
+
+## 18. Mismatched Path Param Names in schema.input
+
+**Problem:** Path template param names don't match `schema.input.pathParams` property names.
+
+```typescript
+// BAD — path has :id but schema declares userId — throws at build time
+Create('GetUser', {
+  path: '/users/:id',
+  method: 'get',
+  schema: {
+    input: {
+      pathParams: Type.Object({ userId: Type.String() }), // Wrong name!
+    },
+  },
+}, handler)
+```
+
+**Fix:** Ensure path param names match schema property names exactly.
+
+```typescript
+// GOOD
+Create('GetUser', {
+  path: '/users/:id',
+  method: 'get',
+  schema: {
+    input: {
+      pathParams: Type.Object({ id: Type.String() }), // Matches :id
+    },
+  },
+}, handler)
+```
+
+**Why:** `HonoAPIAppBuilder` validates at build time that `:param` names in the path match schema properties. A mismatch would cause runtime validation failures with confusing error messages.
+
+---
+
+## 19. Forgetting build() is Async on HonoAPIAppBuilder
+
+**Problem:** Not awaiting `build()` on `HonoAPIAppBuilder`.
+
+```typescript
+// BAD — build() returns Promise<Hono>, not Hono
+const app = new HonoAPIAppBuilder()
+  .register(API, ctx)
+  .build() // This is a Promise!
+```
+
+**Fix:** Await the build call.
+
+```typescript
+// GOOD
+const app = await new HonoAPIAppBuilder()
+  .register(API, ctx)
+  .build()
+```
+
+**Why:** `HonoAPIAppBuilder.build()` is async because it resolves the query parser (lazy-loads `qs` optional peer dependency) once at build time for synchronous per-request usage.
+
+---
+
 ## Summary Table
 
 | # | Anti-Pattern | Risk | Severity |
@@ -500,3 +603,6 @@ new ExpressRPCAppBuilder({
 | 14 | Wrong error handler for streams | Unhandled errors or wrong response format | WARNING |
 | 15 | Manual doc building | Fragile, incomplete documentation | SUGGESTION |
 | 16 | Unhandled async context factory | Request crashes | WARNING |
+| 17 | Both schema.params and schema.input | ProcedureRegistrationError at startup | CRITICAL |
+| 18 | Mismatched path param names | Build-time error or confusing validation failures | CRITICAL |
+| 19 | Not awaiting HonoAPIAppBuilder.build() | Using unresolved Promise as app | CRITICAL |

package/agent_config/claude-code/skills/guide/api-reference.md

@@ -31,7 +31,7 @@ import { captureDefinitionInfo, formatDefinitionInfo } from 'ts-procedures'
 import type { DefinitionLocation, DefinitionInfo } from 'ts-procedures'
 
 // HTTP types (types only, no runtime)
-import type { RPCConfig, RPCHttpRouteDoc, StreamHttpRouteDoc, StreamMode } from 'ts-procedures/http'
+import type { RPCConfig, RPCHttpRouteDoc, StreamHttpRouteDoc, StreamMode, APIConfig, APIHttpRouteDoc, APIInput, HttpMethod } from 'ts-procedures/http'
 
 // Express RPC
 import { ExpressRPCAppBuilder } from 'ts-procedures/express-rpc'
@@ -41,6 +41,10 @@ import { HonoRPCAppBuilder } from 'ts-procedures/hono-rpc'
 
 // Hono Streaming
 import { HonoStreamAppBuilder, sse } from 'ts-procedures/hono-stream'
+
+// Hono API (REST-style)
+import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
+import type { APIConfig, APIHttpRouteDoc, APIInput, HttpMethod } from 'ts-procedures/hono-api'
 ```
 
 ---
@@ -144,6 +148,31 @@ function Create<TName extends string, TParams, TReturnType>(
 - `{ procedure: handler }` — Same handler under a fixed key
 - `{ info: metadata }` — Registration metadata with computed JSON schemas and validation functions
 
+### schema.input (Structured Multi-Channel Input)
+
+`schema.input` is an alternative to `schema.params` for multi-channel input. Mutually exclusive with `schema.params`.
+
+```typescript
+Create('UpdateUser', {
+  path: '/users/:id',
+  method: 'put',
+  schema: {
+    input: {
+      pathParams: Type.Object({ id: Type.String() }),
+      body: Type.Object({ name: Type.String() }),
+    },
+    returnType: Type.Object({ ok: Type.Boolean() }),
+  },
+}, async (ctx, { pathParams, body }) => {
+  // Each channel independently typed via TInput generic
+  return { ok: true }
+})
+```
+
+- Each key in `input` is independently validated with per-channel error messages
+- `ProcedureRegistrationError` thrown at registration if both `params` and `input` defined
+- `TInput` generic inferred from `schema.input` — handler params type computed as `{ [K in keyof TInput]: TSchemaLib<TInput[K]> }`
+
 ### Throws
 
 - `ProcedureRegistrationError` — If schema extraction/compilation fails, or duplicate name
@@ -266,7 +295,7 @@ class ProcedureYieldValidationError extends ProcedureError {
 
 ### ProcedureRegistrationError extends ProcedureError
 
-Thrown at registration time (schema extraction/compilation failure, duplicate name).
+Thrown at registration time (schema extraction/compilation failure, duplicate name, or `schema.params` and `schema.input` both defined).
 
 ```typescript
 class ProcedureRegistrationError extends ProcedureError {
@@ -295,8 +324,8 @@ Compiles schemas into AJV validator functions.
 
 ```typescript
 function schemaParser(
-  schema: { params?: unknown; returnType?: unknown; yieldType?: unknown },
-  onParseError: (errors: { params?: string; returnType?: string; yieldType?: string }) => void
+  schema: { params?: unknown; returnType?: unknown; yieldType?: unknown; input?: Record<string, unknown> },
+  onParseError: (errors: Record<string, string>) => void
 ): TSchemaParsed
 ```
 
@@ -476,6 +505,78 @@ type MidStreamErrorResult<TErrorData = unknown> = {
 
 ---
 
+## HonoAPIAppBuilder
+
+REST-style HTTP implementation for Hono. Routes by HTTP method with `schema.input` per-channel validation.
+
+```typescript
+class HonoAPIAppBuilder {
+  constructor(config?: {
+    app?: Hono
+    pathPrefix?: string
+    queryParser?: (queryString: string) => Record<string, unknown>
+    onRequestStart?: (c: Context) => void
+    onRequestEnd?: (c: Context) => void
+    onSuccess?: (procedure: TProcedureRegistration, c: Context) => void
+    onError?: (procedure: TProcedureRegistration, c: Context, error: Error) => Response | Promise<Response>
+  })
+
+  register<TFactory>(
+    factory: TFactory,
+    factoryContext: Context | ((c: HonoContext) => Context | Promise<Context>),
+    extendProcedureDoc?: ({ base, procedure }) => Record<string, any>
+  ): this
+
+  async build(): Promise<Hono>
+  get app(): Hono
+  get docs(): APIHttpRouteDoc[]
+}
+```
+
+### Route Path
+
+Developer-defined via `APIConfig.path` — no auto-generation. Supports Hono path params (`:id`).
+
+`{pathPrefix}{path}` — e.g., `/api/users/:id`
+
+### Input Channel Extraction
+
+| Channel | HTTP Source | Used For |
+|---------|-----------|----------|
+| `pathParams` | URL path parameters (`c.req.param()`) | `/users/:id` → `{ id: '...' }` |
+| `query` | Query string (parsed via `qs` or native) | `?page=2` → `{ page: 2 }` |
+| `body` | JSON request body (POST/PUT/PATCH only) | `{ name: 'John' }` |
+| `headers` | Request headers (AJV strips non-declared) | `{ 'x-api-key': '...' }` |
+
+### Default Success Status
+
+| Method | Default Status |
+|--------|---------------|
+| POST | 201 |
+| DELETE | 204 (no body) |
+| Others | 200 |
+
+Override with `APIConfig.successStatus`.
+
+### Build-Time Validation
+
+- Path param names in path template must match `schema.input.pathParams` property names
+- `schema.input.pathParams` defined but path has no `:param` segments → error
+- Path has `:param` but `schema.input.pathParams` missing → error
+- Property name mismatch → error with clear message
+
+### Query Parsing
+
+Priority: custom `queryParser` > `qs` (optional peer dep, lazy-loaded) > native `URLSearchParams`.
+
+Query parser resolved once at `build()` time — handlers use it synchronously.
+
+### Signal Injection
+
+Uses `c.req.raw.signal` — native Request signal from Hono context.
+
+---
+
 ## HTTP Types
 
 ### RPCConfig
@@ -517,6 +618,51 @@ interface StreamHttpRouteDoc extends RPCConfig {
 }
 ```
 
+### APIConfig
+
+```typescript
+interface APIConfig {
+  path: string
+  method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head'
+  successStatus?: number
+}
+```
+
+### APIHttpRouteDoc
+
+```typescript
+interface APIHttpRouteDoc extends APIConfig {
+  name: string
+  fullPath: string
+  jsonSchema: {
+    pathParams?: Record<string, unknown>
+    query?: Record<string, unknown>
+    body?: Record<string, unknown>
+    headers?: Record<string, unknown>
+    response?: Record<string, unknown>
+  }
+}
+```
+
+### APIInput
+
+Channel constraint helper type. Use with `satisfies` for compile-time validation of channel names.
+
+```typescript
+type APIInput<T extends {
+  pathParams?: unknown
+  query?: unknown
+  body?: unknown
+  headers?: unknown
+}> = T
+```
+
+### HttpMethod
+
+```typescript
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head'
+```
+
 ---
 
 ## Stack Utilities

package/agent_config/claude-code/skills/guide/patterns.md

@@ -387,6 +387,161 @@ const app = new HonoStreamAppBuilder({
 
 ---
 
+## Hono API Integration (REST-style)
+
+```typescript
+import { Procedures } from 'ts-procedures'
+import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
+import type { APIConfig } from 'ts-procedures/http'
+import { Type } from 'typebox'
+
+type AppContext = { userId: string }
+const API = Procedures<AppContext, APIConfig>()
+
+API.Create('GetUser', {
+  path: '/users/:id',
+  method: 'get',
+  schema: {
+    input: {
+      pathParams: Type.Object({ id: Type.String() }),
+    },
+    returnType: Type.Object({ id: Type.String(), name: Type.String() }),
+  },
+}, async (ctx, { pathParams }) => {
+  return await fetchUser(pathParams.id)
+})
+
+API.Create('CreateUser', {
+  path: '/users',
+  method: 'post',
+  schema: {
+    input: {
+      body: Type.Object({ name: Type.String(), email: Type.String() }),
+    },
+  },
+}, async (ctx, { body }) => {
+  return await createUser(body)
+})
+
+API.Create('DeleteUser', {
+  path: '/users/:id',
+  method: 'delete',
+  schema: {
+    input: {
+      pathParams: Type.Object({ id: Type.String() }),
+    },
+  },
+}, async (ctx, { pathParams }) => {
+  await deleteUser(pathParams.id)
+})
+
+const app = await new HonoAPIAppBuilder({
+  pathPrefix: '/api',
+  onError: (procedure, c, error) => {
+    if (error instanceof ProcedureValidationError) {
+      return c.json({ error: error.message, details: error.errors }, 400)
+    }
+    return c.json({ error: error.message }, 500)
+  },
+})
+  .register(API, (c) => ({
+    userId: c.req.header('x-user-id') || 'anonymous',
+  }))
+  .build()
+
+// Routes:
+// GET    /api/users/:id → 200
+// POST   /api/users     → 201
+// DELETE /api/users/:id → 204
+```
+
+---
+
+## Extended Config with APIConfig
+
+```typescript
+import { Procedures } from 'ts-procedures'
+import type { APIConfig } from 'ts-procedures/http'
+
+type AppContext = { userId: string }
+
+const { Create } = Procedures<AppContext, APIConfig>()
+
+// Every procedure now MUST include path and method
+const { GetUser } = Create(
+  'GetUser',
+  {
+    path: '/users/:id',
+    method: 'get',
+    schema: {
+      input: {
+        pathParams: Type.Object({ id: Type.String() }),
+        query: Type.Object({ include: Type.Optional(Type.String()) }),
+      },
+    },
+  },
+  async (ctx, { pathParams, query }) => {
+    return await fetchUser(pathParams.id, { include: query.include })
+  }
+)
+```
+
+---
+
+## schema.input — Multi-Channel Structured Input
+
+Use `schema.input` instead of `schema.params` for structured per-channel validation:
+
+```typescript
+const { Create } = Procedures<AppContext, APIConfig>()
+
+Create('UpdateUserField', {
+  path: '/users/:id',
+  method: 'put',
+  schema: {
+    input: {
+      pathParams: Type.Object({ id: Type.String() }),
+      query: Type.Object({ notify: Type.Optional(Type.Boolean()) }),
+      body: Type.Object({ field: Type.String(), value: Type.String() }),
+      headers: Type.Object({ 'x-idempotency-key': Type.String() }),
+    },
+    returnType: Type.Object({ ok: Type.Boolean() }),
+  },
+}, async (ctx, { pathParams, query, body, headers }) => {
+  // Each channel independently typed and validated
+  // Validation errors include channel name: "Validation error for UpdateUserField in input.body"
+  await updateField(pathParams.id, body.field, body.value, {
+    idempotencyKey: headers['x-idempotency-key'],
+  })
+  if (query.notify) await notifyUser(pathParams.id)
+  return { ok: true }
+})
+```
+
+---
+
+## APIInput Channel Constraint
+
+Use `satisfies APIInput` to catch channel name typos at compile time:
+
+```typescript
+import type { APIInput } from 'ts-procedures/hono-api'
+
+Create('Search', {
+  path: '/search',
+  method: 'get',
+  schema: {
+    input: {
+      query: Type.Object({ q: Type.String() }),
+    } satisfies APIInput,
+  },
+}, async (ctx, { query }) => {
+  return await search(query.q)
+})
+```
+
+---
+
 ## onCreate Callback for Framework Integration
 
 ```typescript

package/agent_config/claude-code/skills/review/checklist.md

@@ -28,6 +28,7 @@
 ### CRITICAL
 - [ ] Uses TypeBox (`Type.Object(...)`, `Type.String()`, etc.) — not plain objects
 - [ ] Required fields use `Type.String()` directly; optional fields wrapped with `Type.Optional(...)`
+- [ ] Does not define both `schema.params` and `schema.input` on the same procedure (mutually exclusive)
 
 ### WARNING
 - [ ] Understands AJV `coerceTypes: true` — no manual type parsing for query string values
@@ -93,6 +94,27 @@
 
 ---
 
+## API Builder Checks (HonoAPIAppBuilder)
+
+### CRITICAL
+- [ ] `build()` is `await`ed — returns `Promise<Hono>`, not `Hono`
+- [ ] Path param names in route template match `schema.input.pathParams` property names exactly
+- [ ] Does not define both `schema.params` and `schema.input` on the same procedure
+- [ ] `onError` callback handles `ProcedureValidationError` and `ProcedureError` differently
+
+### WARNING
+- [ ] Uses `schema.input` channels appropriate for the HTTP method (no `body` on GET/HEAD)
+- [ ] `pathPrefix` set consistently
+- [ ] `successStatus` overridden only when default (POST→201, DELETE→204) is wrong
+- [ ] Uses `APIInput` type constraint (`satisfies APIInput`) to catch channel name typos
+
+### SUGGESTION
+- [ ] Route documentation accessed via `builder.docs` for OpenAPI generation
+- [ ] Custom `queryParser` provided if complex query string formats needed
+- [ ] Lifecycle hooks used for observability (logging, metrics)
+
+---
+
 ## Error Handling Checks
 
 ### CRITICAL

package/agent_config/claude-code/skills/scaffold/SKILL.md

@@ -7,7 +7,7 @@ invocable_by:
 user_instructions: |
   Usage: /ts-procedures:scaffold <type> <Name>
 
-  Types: procedure, stream-procedure, express-rpc, hono-rpc, hono-stream
+  Types: procedure, stream-procedure, express-rpc, hono-rpc, hono-stream, hono-api
 
   Examples:
     /ts-procedures:scaffold procedure GetUser
@@ -15,6 +15,7 @@ user_instructions: |
     /ts-procedures:scaffold express-rpc UserApi
     /ts-procedures:scaffold hono-rpc OrderApi
     /ts-procedures:scaffold hono-stream LiveFeed
+    /ts-procedures:scaffold hono-api ProductApi
 ---
 
 # Scaffold ts-procedures Code
@@ -42,6 +43,7 @@ Parse `$ARGUMENTS` as `<type> <Name>` (case-insensitive type, PascalCase Name).
 | `express-rpc` | `templates/express-rpc.md` | `{{Name}}.rpc.ts`, `{{Name}}.rpc.test.ts` |
 | `hono-rpc` | `templates/hono-rpc.md` | `{{Name}}.rpc.ts`, `{{Name}}.rpc.test.ts` |
 | `hono-stream` | `templates/hono-stream.md` | `{{Name}}.stream-rpc.ts`, `{{Name}}.stream-rpc.test.ts` |
+| `hono-api` | `templates/hono-api.md` | `{{Name}}.api.ts`, `{{Name}}.api.test.ts` |
 
 ## Rules