ts-procedures 7.2.0 → 8.0.0

package/agent_config/claude-code/skills/ts-procedures/api-reference.md

@@ -7,6 +7,9 @@ Factory function that creates a scoped procedure registration system.
 ```typescript
 function Procedures<TContext = unknown, TExtendedConfig = unknown>(
   builder?: {
+    config?: {
+      noRuntimeValidation?: true
+    }
     onCreate?: (procedure: {
       name: string
       isStream?: boolean
@@ -26,14 +29,17 @@ function Procedures<TContext = unknown, TExtendedConfig = unknown>(
 
 ### Parameters
 
+- `builder.config.noRuntimeValidation` — When `true`, every procedure registered through this factory skips AJV validation at call time. Applies to all four creators: `Create` and `CreateStream` skip `schema.params` validation; `CreateHttp` and `CreateHttpStream` skip per-channel `schema.req.{pathParams,query,body,headers}` validation. JSON Schema is still computed at registration time, so `info.schema` and codegen are unaffected. Shape is `noRuntimeValidation?: true` — only `true` is accepted, making the opt-out explicit. Use only for trusted internal factories whose callers are already type-checked at build time; do **not** enable for procedures that accept input from public clients or untyped JSON bodies.
 - `builder.onCreate` — Called each time a procedure is registered. Use for framework integration, route registration, or logging.
 
 ### Return Value
 
 | Method | Description |
 |--------|-------------|
-| `Create(name, config, handler)` | Register a standard async procedure |
-| `CreateStream(name, config, handler)` | Register a streaming async generator procedure |
+| `Create(name, config, handler)` | Register a standard async RPC procedure |
+| `CreateStream(name, config, handler)` | Register a streaming async generator RPC procedure |
+| `CreateHttp(name, config, handler)` | Register a unary HTTP procedure (`path`, `method`, `schema.req`, `schema.res`) |
+| `CreateHttpStream(name, config, handler)` | Register a streaming HTTP procedure |
 | `getProcedures()` | Returns array of all registered procedure metadata |
 | `getProcedure(name)` | Returns single procedure by name, or `undefined` |
 | `removeProcedure(name)` | Removes procedure, returns `true` if found |
@@ -90,7 +96,7 @@ function Create<TName extends string, TParams, TReturnType>(
 |----------|------|-------------|
 | `...TContext` | varies | All base context fields |
 | `error(message, meta?)` | `Function` | Creates `ProcedureError` — throw this for business logic errors |
-| `signal?` | `AbortSignal` | Present when HTTP implementation injects it (Express/Hono do this automatically) |
+| `signal?` | `AbortSignal` | Present when HTTP implementation injects it (`HonoAppBuilder` does this automatically) |
 
 
 ### Return Value
@@ -99,31 +105,6 @@ 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
@@ -195,6 +176,85 @@ When `validateYields: true`:
 
 ---
 
+## CreateHttp\<TName, TReq, TRes, TErrorKey\>(name, config, handler)
+
+Registers a unary HTTP procedure (v8+). First-class surface for REST-style routes with per-channel input (`schema.req`) and structured response (`schema.res`).
+
+```typescript
+function CreateHttp<
+  TName extends string,
+  TReq extends { pathParams?: unknown; query?: unknown; body?: unknown; headers?: unknown } = {},
+  TRes extends { body?: unknown; headers?: unknown } = {},
+  TErrorKey extends string = string
+>(
+  name: TName,
+  config: {
+    path: string
+    method: HttpMethod
+    successStatus?: number
+    scope?: string
+    errors?: TErrorKey[]
+    description?: string
+    schema: {
+      req?: TReq
+      res?: TRes
+    }
+  },
+  handler: (
+    ctx: TContext & TLocalContext,
+    req: { [K in keyof TReq]: TSchemaLib<TReq[K]> }
+  ) => Promise<HttpReturn<TRes>>
+): {
+  [K in TName]: typeof handler
+  procedure: typeof handler
+  info: THttpProcedureRegistration
+}
+```
+
+### Parameters
+
+- `config.path` — Route path. Supports Hono-style path params (`:id`).
+- `config.method` — HTTP method.
+- `config.schema.req` — Per-channel input schemas. Channels: `pathParams`, `query`, `body`, `headers`. Each channel independently validated.
+- `config.schema.res.body` — Response body schema (documentation; not runtime-validated).
+- `config.schema.res.headers` — When declared, handler **must** return `{ body, headers }` instead of the body bare. The builder reads `headers` and forwards them to the HTTP response.
+- `config.errors` — Taxonomy keys this route may emit (populates DocEnvelope for codegen).
+
+### Return Shape
+
+- **No `schema.res.headers`:** handler returns body bare (`T`).
+- **`schema.res.headers` declared:** handler returns `{ body: B, headers: H }`.
+
+### Throws
+
+- `ProcedureRegistrationError` — Path param names don't match `schema.req.pathParams`; or `schema.params` provided on a `CreateHttp` call (wrong creator).
+- `ProcedureValidationError` — At call time if any req channel fails validation.
+- `ProcedureError` — At call time if handler throws.
+
+### Example
+
+```typescript
+const API = Procedures<AppContext>()
+
+API.CreateHttp('GetUser', {
+  path: '/users/:id',
+  method: 'get',
+  schema: {
+    req: {
+      pathParams: Type.Object({ id: Type.String() }),
+      query: Type.Object({ include: Type.Optional(Type.String()) }),
+    },
+    res: {
+      body: Type.Object({ id: Type.String(), name: Type.String() }),
+    },
+  },
+}, async (ctx, { pathParams, query }) => {
+  return await fetchUser(pathParams.id, { include: query.include })
+})
+```
+
+---
+
 ## Error Classes
 
 ### ProcedureError
@@ -246,7 +306,7 @@ class ProcedureYieldValidationError extends ProcedureError {
 
 ### ProcedureRegistrationError extends ProcedureError
 
-Thrown at registration time (schema extraction/compilation failure, duplicate name, or `schema.params` and `schema.input` both defined).
+Thrown at registration time. Common v8 sources: schema extraction/compilation failure, duplicate procedure name, using the removed v7 `schema.input` field (rejected with a migration message pointing to `CreateHttp` / `CreateHttpStream`), declaring both `schema.params` and `schema.req` on the same procedure (mutually exclusive — RPC vs HTTP), passing `schema.params` to `CreateHttp` / `CreateHttpStream` (use `schema.req.body` or `schema.req.query` instead), and path/schema mismatches on HTTP procedures (path declares params not in `schema.req.pathParams`, or vice versa).
 
 ```typescript
 class ProcedureRegistrationError extends ProcedureError {
@@ -258,7 +318,7 @@ class ProcedureRegistrationError extends ProcedureError {
 
 ## Error Taxonomy API
 
-Exported from `ts-procedures/http-errors` (and re-exported from every HTTP builder subpath: `ts-procedures/hono-api`, `ts-procedures/hono-rpc`, `ts-procedures/express-rpc`, `ts-procedures/hono-stream`).
+Exported from `ts-procedures/http-errors` (and re-exported from `ts-procedures/hono`).
 
 ### defineErrorTaxonomy(entries)
 
@@ -630,136 +690,90 @@ Maps schema type to inferred TypeScript type:
 
 ---
 
-## ExpressRPCAppBuilder
-
-HTTP implementation for Express.
-
-```typescript
-class ExpressRPCAppBuilder {
-  constructor(config?: {
-    app?: express.Express
-    pathPrefix?: string
-    onRequestStart?: (req: express.Request) => void
-    onRequestEnd?: (req: express.Request, res: express.Response) => void
-    onSuccess?: (procedure: TProcedureRegistration, req: express.Request, res: express.Response) => void
-    // Error handling — two peer modes plus a cross-cutting observer.
-    errors?: ErrorTaxonomy
-    unknownError?: UnknownErrorConfig
-    onError?: (procedure: TProcedureRegistration, req: express.Request, res: express.Response, error: Error) => void
-    onRequestError?: (ctx: OnRequestErrorContext) => void | Promise<void>
-  })
-
-  register<TFactory>(
-    factory: TFactory,
-    factoryContext: Context | ((req: Request) => Context | Promise<Context>),
-    extendProcedureDoc?: ({ base, procedure }) => Record<string, any>
-  ): this
-
-  build(): express.Application
-
-  static makeRPCHttpRoutePath(params: { name: string; config: RPCConfig; prefix?: string }): string
+## HonoAppBuilder\<TStreamErrorData\>
 
-  get app(): express.Express
-  get docs(): RPCHttpRouteDoc[]
-}
-```
-
-`OnRequestErrorContext` for Express: `{ err: unknown; procedure: TProcedureRegistration; raw: { req, res } }`.
-
-### Route Path
-
-`POST {pathPrefix}/{scope}/{kebab-name}/{version}`
-
-- `scope` can be string or string array (joined as path segments)
-- Procedure name is converted to kebab-case
-
-### Context Resolution
-
-- Static object: `builder.register(factory, { userId: 'system' })`
-- Sync function: `builder.register(factory, (req) => ({ auth: req.headers.authorization }))`
-- Async function: `builder.register(factory, async (req) => ({ user: await getUser(req) }))`
-
-### Signal Injection
-
-Express builder creates a lazy AbortController and aborts on request close. The `signal` is injected into handler context automatically.
+Unified Hono HTTP implementation for v8. A single builder dispatches all four procedure kinds (`Create` → RPC, `CreateStream` → streaming RPC, `CreateHttp` → REST-style, `CreateHttpStream` → streaming REST) from one `register()` call. Replaces v7's separate `HonoRPCAppBuilder` / `HonoStreamAppBuilder` / `HonoAPIAppBuilder` classes.
 
----
-
-## HonoRPCAppBuilder
-
-HTTP implementation for Hono. Same API as ExpressRPCAppBuilder but receives Hono `Context` instead of Express `Request`.
+Config is **stratified**: cross-cutting fields live at the top level, kind-specific fields live in `rpc:` / `api:` / `stream:` blocks.
 
 ```typescript
-class HonoRPCAppBuilder {
+class HonoAppBuilder<TStreamErrorData = unknown> {
   constructor(config?: {
+    // Cross-cutting (apply to every kind)
     app?: Hono
     pathPrefix?: string
-    onRequestStart?: (c: Context) => void
-    onRequestEnd?: (c: Context) => void
-    onSuccess?: (procedure: TProcedureRegistration, c: Context) => void
+
     // Error handling — two peer modes plus a cross-cutting observer.
     errors?: ErrorTaxonomy
     unknownError?: UnknownErrorConfig
-    onError?: (procedure: TProcedureRegistration, c: Context, error: Error) => Response | Promise<Response>
+    onError?: PreStreamOnError                                // imperative pre-stream / unary handler
     onRequestError?: (ctx: OnRequestErrorContext) => void | Promise<void>
-  })
 
-  register<TFactory>(
-    factory: TFactory,
-    factoryContext: Context | ((c: HonoContext) => Context | Promise<Context>),
-    extendProcedureDoc?: ({ base, procedure }) => Record<string, any>
-  ): this
-
-  build(): Hono
-  get app(): Hono
-  get docs(): RPCHttpRouteDoc[]
-}
-```
-
-`OnRequestErrorContext` for Hono RPC: `{ err: unknown; procedure: TProcedureRegistration; raw: Context }`.
-
-### Signal Injection
-
-Uses `c.req.raw.signal` — the native Request signal from the Hono context.
-
----
+    // Lifecycle (every kind)
+    onRequestStart?: (c: Context) => void
+    onRequestEnd?: (c: Context) => void
 
-## HonoStreamAppBuilder\<TErrorData\>
+    // RPC-specific (Create procedures)
+    rpc?: {
+      onSuccess?: (procedure: TProcedureRegistration, c: Context) => void
+    }
 
-Streaming HTTP implementation for Hono. Supports SSE and text streaming modes.
+    // HTTP-specific (CreateHttp procedures)
+    api?: {
+      queryParser?: (queryString: string) => Record<string, unknown>
+      onSuccess?: (procedure: THttpProcedureRegistration, c: Context) => void
+    }
 
-```typescript
-class HonoStreamAppBuilder<TErrorData = unknown> {
-  constructor(config?: {
-    app?: Hono
-    pathPrefix?: string
-    defaultStreamMode?: StreamMode              // 'sse' | 'text', default 'sse'
-    onRequestStart?: (c: Context) => void
-    onRequestEnd?: (c: Context) => void
-    onStreamStart?: (procedure: TStreamProcedureRegistration, c: Context, streamMode: StreamMode) => void
-    onStreamEnd?: (procedure: TStreamProcedureRegistration, c: Context, streamMode: StreamMode) => void
-    errors?: ErrorTaxonomy
-    unknownError?: UnknownErrorConfig
-    onError?: (procedure: TStreamProcedureRegistration, c: Context, error: Error) => Response | Promise<Response>  // renamed from onPreStreamError in v6
-    onRequestError?: (ctx: { err: unknown; procedure: TStreamProcedureRegistration; raw: Context }) => void | Promise<void>
-    onMidStreamError?: (procedure: TStreamProcedureRegistration, c: Context, error: Error) => MidStreamErrorResult<TErrorData> | undefined
+    // Stream-specific (CreateStream + CreateHttpStream procedures)
+    stream?: {
+      defaultStreamMode?: StreamMode      // 'sse' | 'text', default 'sse'
+      onStreamStart?: (
+        procedure: TStreamProcedureRegistration | THttpStreamProcedureRegistration,
+        c: Context,
+        streamMode: StreamMode,
+      ) => void
+      onStreamEnd?: (
+        procedure: TStreamProcedureRegistration | THttpStreamProcedureRegistration,
+        c: Context,
+        streamMode: StreamMode,
+      ) => void
+      onMidStreamError?: (
+        procedure: TStreamProcedureRegistration | THttpStreamProcedureRegistration,
+        c: Context,
+        error: Error,
+      ) => MidStreamErrorResult<TStreamErrorData> | undefined
+    }
   })
 
   register<TFactory>(
     factory: TFactory,
     factoryContext: Context | ((c: HonoContext) => Context | Promise<Context>),
     options?: {
-      streamMode?: StreamMode
+      streamMode?: StreamMode                                          // per-registration override of stream.defaultStreamMode
       extendProcedureDoc?: ({ base, procedure }) => Record<string, any>
     }
   ): this
 
   build(): Hono
+  toDocEnvelope(config?: DocRegistryConfig): DocEnvelope               // single-app convenience
+
   get app(): Hono
-  get docs(): StreamHttpRouteDoc[]
+  get docs(): AnyHttpRouteDoc[]                                        // mixed RPC / HTTP / Stream route docs
 }
 ```
 
+`OnRequestErrorContext`: `{ err: unknown; procedure: AnyProcedureRegistration; raw: Context }`.
+
+### Top-level keys (the only keys allowed at the root of the config)
+
+`app`, `pathPrefix`, `errors`, `unknownError`, `onError`, `onRequestError`, `onRequestStart`, `onRequestEnd`, `rpc`, `api`, `stream`. Anything else is a typo or v7 vestige — `queryParser`, `onSuccess`, `defaultStreamMode`, `onStreamStart`, `onStreamEnd`, `onMidStreamError` belong inside their kind block, not at the root.
+
+### Error Handling
+
+- **RPC + HTTP (unary):** `errors` taxonomy or `onError` callback. Observe via `onRequestError`.
+- **Pre-stream errors** (validation, context resolution failures before the first yield): Returns a JSON error response — no streaming started. Same dispatch as unary: `errors` taxonomy or `onError` callback. Observe via `onRequestError`.
+- **Mid-stream errors** (generator throws after the first yield): Yields error as final event, closes stream. Configure via `stream.onMidStreamError` (the only mid-stream path — the HTTP status is already committed).
+
 ### Stream Modes
 
 **SSE mode** (`'sse'`):
@@ -783,12 +797,14 @@ function sse<T extends object>(data: T, options?: {
 }): T
 ```
 
-### HTTP Methods
+### HTTP Methods (RPC streams)
 
-Both GET and POST are registered for each streaming procedure:
+For `CreateStream` procedures (RPC-style streams), both GET and POST are registered:
 - **GET**: params extracted from query string
 - **POST**: params extracted from JSON body
 
+For `CreateHttpStream`, the method comes from `config.method` (no auto-pairing).
+
 ### MidStreamErrorResult
 
 ```typescript
@@ -798,63 +814,22 @@ type MidStreamErrorResult<TErrorData = unknown> = {
 }
 ```
 
-### Error Handling
-
-- **Pre-stream errors** (validation, context): Returns a JSON error response (no streaming started). Handle via either peer mode — `errors` taxonomy or `onError` callback. Observe via `onRequestError`.
-- **Mid-stream errors** (generator throws): Yields error as final event, closes stream. Handle via `onMidStreamError` (the only mid-stream path — the HTTP status is already committed).
-
----
+### Route Paths
 
-## HonoAPIAppBuilder
+- **RPC (`Create`):** `POST {pathPrefix}/{scope}/{kebab-name}/{version}` (auto-generated).
+- **RPC stream (`CreateStream`):** `GET|POST {pathPrefix}/{scope}/{kebab-name}/{version}`.
+- **HTTP (`CreateHttp` / `CreateHttpStream`):** developer-defined via `config.path` — no auto-generation. Supports Hono path params (`:id`). Final path is `{pathPrefix}{path}` — e.g., `/api/users/:id`.
 
-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
-    // Error handling — two peer modes plus a cross-cutting observer.
-    errors?: ErrorTaxonomy
-    unknownError?: UnknownErrorConfig
-    onError?: (procedure: TProcedureRegistration, c: Context, error: Error) => Response | Promise<Response>
-    onRequestError?: (ctx: OnRequestErrorContext) => void | Promise<void>
-  })
-
-  register<TFactory>(
-    factory: TFactory,
-    factoryContext: Context | ((c: HonoContext) => Context | Promise<Context>),
-    extendProcedureDoc?: ({ base, procedure }) => Record<string, any>
-  ): this
-
-  build(): Hono
-  get app(): Hono
-  get docs(): APIHttpRouteDoc[]
-}
-```
-
-`OnRequestErrorContext` for Hono API: `{ err: unknown; procedure: TProcedureRegistration; raw: Context }`.
-
-### 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
+### Input Channel Extraction (`schema.req` — `CreateHttp` only)
 
 | Channel | HTTP Source | Used For |
 |---------|-----------|----------|
 | `pathParams` | URL path parameters (`c.req.param()`) | `/users/:id` → `{ id: '...' }` |
-| `query` | Query string (parsed via config `queryParser` or native `URLSearchParams`) | `?page=2` → `{ page: 2 }` |
+| `query` | Query string (parsed via `api.queryParser` or native `URLSearchParams`) | `?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
+### Default Success Status (`CreateHttp`)
 
 | Method | Default Status |
 |--------|---------------|
@@ -862,14 +837,14 @@ Developer-defined via `APIConfig.path` — no auto-generation. Supports Hono pat
 | DELETE | 204 (no body) |
 | Others | 200 |
 
-Override with `APIConfig.successStatus`.
+Override with `config.successStatus` on the `CreateHttp` config.
 
-### Build-Time Validation
+### Build-Time Validation (`CreateHttp`)
 
-- 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
+- Path param names in path template must match `schema.req.pathParams` property names
+- `schema.req.pathParams` defined but path has no `:param` segments → error
+- Path has `:param` but `schema.req.pathParams` missing → error
+- Property name mismatch → `ProcedureRegistrationError` at registration time
 
 ### Query Parsing
 
@@ -887,13 +862,15 @@ It does **not** interpret bracket/dot syntax — those stay as part of the liter
 | `?user.name=John` | `{ 'user.name': 'John' }` | `{ user: { name: 'John' } }` |
 | `?tags=a,b,c` | `{ tags: 'a,b,c' }` | `{ tags: ['a', 'b', 'c'] }` |
 
-For nested/bracket/dot/CSV parsing, install `qs` and opt in via `queryParser`:
+For nested/bracket/dot/CSV parsing, install `qs` and opt in via `api.queryParser`:
 
 ```typescript
 import qs from 'qs'
 
-new HonoAPIAppBuilder({
-  queryParser: (raw) => qs.parse(raw) as Record<string, unknown>,
+new HonoAppBuilder({
+  api: {
+    queryParser: (raw) => qs.parse(raw) as Record<string, unknown>,
+  },
 })
 ```
 
@@ -901,6 +878,10 @@ new HonoAPIAppBuilder({
 
 Uses `c.req.raw.signal` — native Request signal from Hono context.
 
+### Single-App Doc Envelope
+
+For apps that build all routes through one `HonoAppBuilder`, `builder.toDocEnvelope()` returns the full `DocEnvelope` directly — no `DocRegistry` wiring needed. `DocRegistry` is still preferred for multi-app aggregation.
+
 ---
 
 ## HTTP Types
@@ -949,48 +930,53 @@ interface StreamHttpRouteDoc extends RPCConfig {
 }
 ```
 
-### APIConfig
+### TCreateHttpConfig (v8)
+
+Config type for `CreateHttp`. HTTP fields are first-class — no `APIConfig` type parameter needed on the factory.
 
 ```typescript
-// Generic over valid taxonomy keys — same pattern as RPCConfig.
-interface APIConfig<TErrorKey extends string = string> {
+type TCreateHttpConfig<TReq, TRes, TErrorKey extends string = string> = {
   path: string
-  method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head'
+  method: HttpMethod
   successStatus?: number
   scope?: string
   errors?: TErrorKey[]
+  description?: string
+  schema: {
+    req?: TReq   // per-channel input: { pathParams?, query?, body?, headers? }
+    res?: TRes   // structured response: { body?, headers? }
+  }
 }
 ```
 
-### APIHttpRouteDoc
+### APIHttpRouteDoc (v8)
 
 ```typescript
-interface APIHttpRouteDoc extends APIConfig {
+interface APIHttpRouteDoc {
   name: string
+  kind: 'http'
+  path: string
   fullPath: string
-  jsonSchema: {
-    pathParams?: Record<string, unknown>
-    query?: Record<string, unknown>
-    body?: Record<string, unknown>
-    headers?: Record<string, unknown>
-    response?: Record<string, unknown>
-  }
+  method: HttpMethod
+  successStatus?: number
+  scope?: string
   errors?: string[]
+  jsonSchema?: {
+    req?: {
+      pathParams?: Record<string, unknown>
+      query?: Record<string, unknown>
+      body?: Record<string, unknown>
+      headers?: Record<string, unknown>
+    }
+    res?: {
+      body?: Record<string, unknown>
+      headers?: 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
-```
+> **v7 → v8 migration:** `APIConfig` and `APIInput` are removed. Replace `Procedures<Ctx, APIConfig>()` with `Procedures<Ctx>()` and replace `.Create(` with `.CreateHttp(`. Replace `schema.input` with `schema.req`.
 
 ### HttpMethod
 
@@ -1033,7 +1019,7 @@ class DocRegistry {
 
 ### DocSource
 
-Any object with a `readonly docs` array. All four HTTP builders (`HonoRPCAppBuilder`, `HonoAPIAppBuilder`, `HonoStreamAppBuilder`, `ExpressRPCAppBuilder`) satisfy this interface.
+Any object with a `readonly docs` array. The built-in `HonoAppBuilder` satisfies this interface.
 
 ```typescript
 interface DocSource<T = AnyHttpRouteDoc> {
@@ -1331,7 +1317,7 @@ interface TypedStream<TYield, TReturn> extends AsyncIterable<TYield> {
 ### Type Parameters
 
 - `TYield` — Type of each yielded value (from `schema.yieldType`)
-- `TReturn` — Type of the stream's return value (from `schema.returnType`). Sent as `event: 'return'` SSE message by `HonoStreamAppBuilder`.
+- `TReturn` — Type of the stream's return value (from `schema.returnType`). Sent as `event: 'return'` SSE message by `HonoAppBuilder`.
 
 ### Key Behavior
 
@@ -1412,7 +1398,7 @@ Inside factory-context closures, read Astro's APIContext via `getAstroContext`:
 ```ts
 import { getAstroContext } from 'ts-procedures/astro'
 
-new HonoAPIAppBuilder()
+new HonoAppBuilder()
   .register(usersAPI, (c) => {
     const astro = getAstroContext(c)
     return { db, user: astro.locals.user ?? null }
@@ -1424,7 +1410,7 @@ Multi-app: pass an array; first non-404 response wins. All-404 falls back to the
 
 Constraints:
 - Astro 5+ in SSR (or `prerender = false`).
-- Express builders are NOT supported by this adapter — Hono builders only.
+- Hono builders only — the adapter accepts `Request`/`Response` apps.
 
 ---
 
@@ -1459,20 +1445,11 @@ 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, APIConfig, APIHttpRouteDoc, APIInput, HttpMethod } from 'ts-procedures/http'
-
-// Express RPC
-import { ExpressRPCAppBuilder } from 'ts-procedures/express-rpc'
-
-// Hono RPC
-import { HonoRPCAppBuilder } from 'ts-procedures/hono-rpc'
-
-// Hono Streaming
-import { HonoStreamAppBuilder, sse } from 'ts-procedures/hono-stream'
+import type { RPCConfig, RPCHttpRouteDoc, StreamHttpRouteDoc, StreamMode, HttpMethod } from 'ts-procedures/http'
+// Note: APIConfig and APIInput are removed in v8. Use CreateHttp with schema.req / schema.res instead.
 
-// Hono API (REST-style)
-import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
-import type { APIConfig, APIHttpRouteDoc, APIInput, HttpMethod } from 'ts-procedures/hono-api'
+// Hono — single unified builder dispatches RPC, HTTP, and streaming kinds
+import { HonoAppBuilder, sse } from 'ts-procedures/hono'
 
 // Client
 import {