ts-procedures 7.3.0 → 8.0.0

package/src/create.ts

@@ -0,0 +1,172 @@
+import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError } from './errors.js'
+import { computeSchema } from './schema/compute-schema.js'
+import { Prettify, TSchemaLib } from './schema/types.js'
+import { captureDefinitionInfo } from './stack-utils.js'
+import {
+  TBuilderConfig,
+  THttpProcedureRegistration,
+  THttpStreamProcedureRegistration,
+  TLocalContext,
+  TProcedureRegistration,
+  TStreamProcedureRegistration,
+} from './types.js'
+
+export type CreateBuilderArg<TContext, TExtendedConfig> = {
+  config?: TBuilderConfig
+  onCreate?: (
+    procedure:
+      | TProcedureRegistration<TContext, TExtendedConfig>
+      | TStreamProcedureRegistration<TContext, TExtendedConfig>
+  ) => void
+}
+
+export function makeCreate<TContext, TExtendedConfig>(
+  procedures: Map<
+    string,
+    | TProcedureRegistration<TContext, TExtendedConfig>
+    | TStreamProcedureRegistration<TContext, TExtendedConfig>
+    | THttpProcedureRegistration<TContext>
+    | THttpStreamProcedureRegistration<TContext>
+  >,
+  builder?: CreateBuilderArg<TContext, TExtendedConfig>
+) {
+  return function Create<TName extends string, TParams, TReturnType>(
+    name: TName,
+    config: {
+      description?: string
+      schema?: {
+        params?: TParams
+        returnType?: TReturnType
+      }
+    } & TExtendedConfig,
+    handler: (
+      ctx: Prettify<TContext & TLocalContext>,
+      params: TSchemaLib<TParams>
+    ) => Promise<TSchemaLib<TReturnType>>
+  ) {
+    // Capture definition location as first action
+    const definitionInfo = captureDefinitionInfo()
+
+    const HTTP_FIELDS = ['path', 'method', 'req', 'res', 'successStatus'] as const
+    const presentHttpFields = HTTP_FIELDS.filter((f) => (config as any)[f] !== undefined)
+    if (presentHttpFields.length > 0) {
+      throw new ProcedureRegistrationError(
+        name,
+        `HTTP fields require CreateHttp / CreateHttpStream. Procedure "${name}" has [${presentHttpFields.join(', ')}] which are not valid on Create.`,
+        definitionInfo,
+      )
+    }
+
+    // BEFORE computeSchema - fail fast on duplicate
+    if (procedures.has(name)) {
+      throw new Error(`Procedure with name ${name} is already registered`)
+    }
+
+    const { jsonSchema, validations } = computeSchema(name, config.schema, definitionInfo)
+
+    // Create error factory once at registration time (outside handler)
+    const errorFactory = (message: string, meta?: object) =>
+      new ProcedureError(name, message, meta, definitionInfo)
+
+    const registeredProcedure: TProcedureRegistration<TContext, TExtendedConfig> = {
+      name,
+      kind: 'rpc',
+      config: {
+        ...config,
+        description: config.description,
+        schema: jsonSchema,
+        validation: {
+          params: validations.params,
+        },
+      },
+
+      handler: async (ctx: Prettify<TContext>, params: TSchemaLib<TParams>) => {
+        try {
+          // Skip validation if caller has already validated or if builder config dictates noRuntimeValidation
+          const skipValidation =
+            (ctx as { isPrevalidated?: boolean }).isPrevalidated ||
+            builder?.config?.noRuntimeValidation
+
+          if (validations?.params && !skipValidation) {
+            const { errors } = validations.params(params)
+
+            if (errors) {
+              throw new ProcedureValidationError(
+                name,
+                `Validation error for ${name}`,
+                errors,
+                definitionInfo
+              )
+            }
+          }
+
+          const localCtx: TLocalContext = {
+            error: errorFactory,
+          }
+
+          // params is correctly typed at the public API boundary;
+          // cast here because TS cannot narrow generics inside implementations
+          return await handler(
+            { ...ctx, ...localCtx } as Prettify<TContext & TLocalContext>,
+            params as any
+          )
+        } catch (error: any) {
+          if (error instanceof ProcedureError) throw error
+          const err = new ProcedureError(
+            name,
+            `Error in handler for ${name} - ${error?.message}`,
+            undefined,
+            definitionInfo
+          )
+          err.cause = error
+          // Preserve original stack but append definition info
+          if (error.stack && definitionInfo.definedAt) {
+            const { file, line, column } = definitionInfo.definedAt
+            err.stack =
+              error.stack +
+              `\n--- Procedure "${name}" defined at ---\n    at ${file}:${line}:${column}`
+          } else if (error.stack) {
+            err.stack = error.stack
+          }
+          throw err
+        }
+      },
+    }
+
+    procedures.set(name, registeredProcedure)
+    builder?.onCreate?.(registeredProcedure)
+
+    const info = {
+      name,
+      ...registeredProcedure.config,
+    }
+
+    // return so can be called directly (ie: int/unit tests)
+    return {
+      [name]: registeredProcedure.handler,
+      procedure: registeredProcedure.handler,
+      info,
+    } as {
+      [K in TName]: (
+        ctx: Prettify<TContext>,
+        params: TSchemaLib<TParams>
+      ) => Promise<TSchemaLib<TReturnType>>
+    } & {
+      procedure: (
+        ctx: Prettify<TContext>,
+        params: TSchemaLib<TParams>
+      ) => Promise<TSchemaLib<TReturnType>>
+      info: {
+        name: TName
+        description?: string
+        schema: {
+          params?: TParams
+          returnType?: TReturnType
+        }
+        validation?: {
+          params?: (params: any) => { errors?: any[] }
+        }
+      } & TExtendedConfig
+    }
+  }
+}

package/src/exports.ts

@@ -5,3 +5,5 @@ export * from './schema/extract-json-schema.js'
 export * from './schema/parser.js'
 export * from './schema/resolve-schema-lib.js'
 export * from './schema/types.js'
+export type { HttpReturn } from './create-http.js'
+export type { TCreateHttpConfig } from './types.js'

package/src/implementations/http/README.md

@@ -4,59 +4,46 @@ HTTP implementation builders for `ts-procedures` that create type-safe, versione
 
 ## Available Implementations
 
-### RPC (Request/Response)
-
-For procedures created with `Create()` - standard request/response pattern using POST.
-
-| Framework | Package | Description |
-|-----------|---------|-------------|
-| [Express RPC](./express-rpc/README.md) | `express-rpc` | Express.js integration |
-| [Hono RPC](./hono-rpc/README.md) | `hono-rpc` | Hono integration (Bun, Deno, Cloudflare Workers, Node.js) |
-
-### Streaming
-
-For procedures created with `CreateStream()` - server-sent events and streaming responses.
-
-| Framework | Package | Description |
+| Framework | Subpath | Description |
 |-----------|---------|-------------|
-| [Hono Stream](./hono-stream/README.md) | `hono-stream` | SSE and text streaming for async generators |
+| HonoAppBuilder | `ts-procedures/hono` | Unified Hono builder — dispatches RPC, RPC streams, REST, and REST streams from one `register()` call. Works on Bun, Deno, Cloudflare Workers, and Node.js. |
 
-### API (REST-style)
+`HonoAppBuilder` is a unified builder: one builder, one `app`, one set of cross-cutting hooks. The procedure kind drives behavior — pick the creator that matches the shape you need.
 
-For procedures using `schema.input` — per-channel input validation with standard HTTP methods.
-
-| Framework | Package | Description |
-|-----------|---------|-------------|
-| [Hono API](./hono-api/) | `hono-api` | REST-style routing by HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD) |
+### Procedure kinds and which creator to use
 
-## Procedure Types
+| Procedure kind | Created with | Config shape | Handler return | HTTP methods | Use case |
+|----------------|--------------|--------------|----------------|--------------|----------|
+| `rpc` | `Create()` | `RPCConfig` (`scope`, `version`) | `Promise<T>` | POST | Standard request/response |
+| `rpc-stream` | `CreateStream()` | `RPCConfig` | `AsyncGenerator<T>` | GET, POST | RPC-style streaming (SSE / text) |
+| `http` | `CreateHttp()` | `APIConfig` (`path`, `method`) | `Promise<T>` | GET, POST, PUT, DELETE, PATCH, HEAD | REST-style endpoint with `schema.req` channels |
+| `http-stream` | `CreateHttpStream()` | `APIConfig` | `AsyncGenerator<T>` | GET, POST | REST-style streaming endpoint |
 
-| Type | Created With | Handler Return | HTTP Methods | Use Case |
-|------|--------------|----------------|--------------|----------|
-| RPC | `Create()` | `Promise<T>` | POST | Standard request/response |
-| Stream | `CreateStream()` | `AsyncGenerator<T>` | GET, POST | Real-time updates, SSE |
-| API | `Create()` | `Promise<T>` | GET, POST, PUT, DELETE, PATCH, HEAD | REST-style endpoints with per-channel input |
+`HonoAppBuilder` accepts all four kinds from the same factory.
 
 ## Core Concepts
 
-### Config Interface
+### Config Interfaces
 
-All HTTP implementations use a shared configuration interface:
+RPC and RPC-stream procedures share `RPCConfig`:
 
 ```typescript
 interface RPCConfig {
   scope: string | string[]  // Route path segment(s)
   version: number           // API version number
+  errors?: string[]         // Optional taxonomy keys for typed-client narrowing
 }
 ```
 
-#### APIConfig (REST-style)
+REST-style procedures (`CreateHttp` / `CreateHttpStream`) use `APIConfig`:
 
 ```typescript
 interface APIConfig {
   path: string              // Route path with Hono params (e.g., '/users/:id')
   method: HttpMethod        // 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head'
   successStatus?: number    // Default: POST→201, DELETE→204, others→200
+  scope?: string            // Optional grouping for codegen file emission
+  errors?: string[]
 }
 ```
 
@@ -110,71 +97,94 @@ builder.register(Factory, async (c) => {
 
 All HTTP implementations automatically inject an `AbortSignal` into the handler context as `ctx.signal`. This signal aborts when the client disconnects, enabling handlers to cancel in-flight work (fetch calls, database queries, etc.).
 
-| Framework | Signal Source | Behavior |
-|-----------|-------------|----------|
-| Hono RPC | `c.req.raw.signal` | Web standard Request signal |
-| Hono Stream | `c.req.raw.signal` | Combined with internal stream AbortController via `AbortSignal.any()` |
-| Express RPC | Lazy `AbortController` | Created on first `ctx.signal` access, wired to `req.on('close')` |
+| Framework | Procedure kind | Signal source | Behavior |
+|-----------|---------------|---------------|----------|
+| HonoAppBuilder | `rpc`, `http` | `c.req.raw.signal` | Web standard Request signal |
+| HonoAppBuilder | `rpc-stream`, `http-stream` | `c.req.raw.signal` | Combined with internal stream AbortController via `AbortSignal.any()` |
 
 For streaming procedures, `signal.reason` is `'stream-completed'` on normal completion, allowing handlers to distinguish from client disconnection.
 
 ### Error Handling
 
-All four builders support two peer error-handling modes — **declarative** (`errors` taxonomy + `unknownError`) and **imperative** (`onError` callback) — plus a cross-cutting `onRequestError` observer for logging, tracing, and metrics.
+Both builders support two peer error-handling modes — **declarative** (`errors` taxonomy + `unknownError`) and **imperative** (`onError` callback) — plus a cross-cutting `onRequestError` observer for logging, tracing, and metrics.
 
 Full spec (taxonomy shape, `toResponse`/`onCatch`/`match`, per-route narrowing, mid-stream caveats): **[docs/http-integrations.md § Error Handling](../../../docs/http-integrations.md#error-handling)**.
 
 ### Lifecycle Hooks
 
-**RPC Implementations:**
+`HonoAppBuilder`'s config is **stratified**: cross-cutting hooks live at the top level, kind-specific hooks live inside `rpc:`, `api:`, and `stream:` blocks.
+
+```typescript
+new HonoAppBuilder({
+  // Cross-cutting (every kind)
+  onRequestStart, onRequestEnd, onRequestError,
+  errors, unknownError, onError,
+
+  // Kind-specific blocks
+  rpc:    { onSuccess },
+  api:    { queryParser, onSuccess },
+  stream: { defaultStreamMode, onStreamStart, onStreamEnd, onMidStreamError },
+})
+```
+
+**Non-streaming flow (`rpc`, `http`):**
 
 ```
 onRequestStart → handler → onSuccess → onRequestEnd
                     ↓
               (on error)
                     ↓
-              onError handler
+            onRequestError (observer)
+                    ↓
+        errors taxonomy / onError fallback
                     ↓
               onRequestEnd
 ```
 
-**Stream Implementations:**
+**Streaming flow (`rpc-stream`, `http-stream`):**
 
 ```
 onRequestStart → onStreamStart → [yields...] → onStreamEnd → onRequestEnd
                       ↓
                  (on error)
                       ↓
-               error in stream
-                      ↓
-                onStreamEnd
+   ┌──────────────────┴──────────────────┐
+   ↓ (pre-stream — before onStreamStart) ↓ (mid-stream — after first yield)
+errors taxonomy / onError → onRequestEnd  onMidStreamError → onStreamEnd → onRequestEnd
 ```
 
-| Hook | Available In | Trigger |
-|------|--------------|---------|
-| `onRequestStart` | Both | Before route handler |
-| `onRequestEnd` | Both | After response sent |
-| `onSuccess` | RPC, API | After successful handler |
-| `onError` | RPC, API | On handler error |
-| `onStreamStart` | Stream | Before first yield |
-| `onStreamEnd` | Stream | After stream completes |
-| `onError` (HonoStream) | Stream | Imperative pre-stream error callback — peer of `errors` taxonomy |
-| `onRequestError` | All | Cross-cutting observer — fires for every caught error before dispatch |
-| `onMidStreamError` | Stream | On mid-stream error (generator throws) |
+Pre-stream errors short-circuit before `onStreamStart` fires, so `onStreamEnd` does **not** run on that path. Mid-stream errors run `onMidStreamError` and then still fire `onStreamEnd` because the stream had already started.
+
+| Hook | Config block | Triggers on |
+|------|--------------|-------------|
+| `onRequestStart` | top-level | Before route handler (every kind) |
+| `onRequestEnd` | top-level | After response sent (every kind) |
+| `onRequestError` | top-level | Cross-cutting observer — fires for every caught error before dispatch |
+| `onError` | top-level | Imperative pre-stream error callback — peer of `errors` taxonomy |
+| `errors` / `unknownError` | top-level | Declarative taxonomy dispatch |
+| `rpc.onSuccess` | `rpc:` | After successful RPC handler |
+| `api.onSuccess` | `api:` | After successful HTTP handler |
+| `api.queryParser` | `api:` | Custom query-string parser for HTTP routes |
+| `stream.defaultStreamMode` | `stream:` | Default mode (`'sse'` \| `'text'`) for both stream kinds |
+| `stream.onStreamStart` | `stream:` | Before first yield |
+| `stream.onStreamEnd` | `stream:` | After stream completes |
+| `stream.onMidStreamError` | `stream:` | On mid-stream error (generator throws after first yield) |
 
 ### Route Documentation
 
-Each registered procedure generates documentation accessible via `builder.docs`.
+Each registered procedure generates documentation accessible via `builder.docs`. Every doc carries a `kind` discriminant for reliable narrowing.
 
-**RPC Documentation (`RPCHttpRouteDoc`):**
+**RPC (`RPCHttpRouteDoc`, `kind: 'rpc'`):**
 
 ```typescript
 interface RPCHttpRouteDoc {
+  kind: 'rpc'
   name: string
   path: string
   method: 'post'
   scope: string | string[]
   version: number
+  errors?: string[]
   jsonSchema: {
     body?: object      // From schema.params
     response?: object  // From schema.returnType
@@ -182,16 +192,18 @@ interface RPCHttpRouteDoc {
 }
 ```
 
-**Stream Documentation (`StreamHttpRouteDoc`):**
+**RPC stream (`StreamHttpRouteDoc`, `kind: 'stream'`):**
 
 ```typescript
 interface StreamHttpRouteDoc {
+  kind: 'stream'
   name: string
   path: string
   methods: ('get' | 'post')[]
   streamMode: 'sse' | 'text'
   scope: string | string[]
   version: number
+  errors?: string[]
   jsonSchema: {
     params?: object     // From schema.params
     yieldType?: object  // From schema.yieldType
@@ -200,31 +212,65 @@ interface StreamHttpRouteDoc {
 }
 ```
 
-**API Documentation (`APIHttpRouteDoc`):**
+**REST (`APIHttpRouteDoc`, `kind: 'api'`):**
 
 ```typescript
 interface APIHttpRouteDoc {
+  kind: 'api'
   name: string
+  scope?: string
   path: string
   method: HttpMethod
-  fullPath: string
+  fullPath: string           // Includes pathPrefix
   successStatus?: number
+  errors?: string[]
   jsonSchema: {
-    pathParams?: object    // From schema.input.pathParams
-    query?: object         // From schema.input.query
-    body?: object          // From schema.input.body
-    headers?: object       // From schema.input.headers
-    response?: object      // From schema.returnType
+    req?: {
+      pathParams?: object    // From schema.req.pathParams
+      query?: object         // From schema.req.query
+      body?: object          // From schema.req.body
+      headers?: object       // From schema.req.headers
+    }
+    res?: {
+      body?: object           // From schema.res.body
+      headers?: object        // From schema.res.headers
+    }
+  }
+}
+```
+
+**REST stream (`HttpStreamRouteDoc`, `kind: 'http-stream'`):**
+
+```typescript
+interface HttpStreamRouteDoc {
+  kind: 'http-stream'
+  name: string
+  scope?: string
+  path: string
+  method: HttpMethod
+  fullPath: string
+  streamMode: 'sse' | 'text'
+  errors?: string[]
+  jsonSchema: {
+    req?: {
+      pathParams?: object
+      query?: object
+      body?: object
+      headers?: object
+    }
+    res?: { headers?: object }
+    yield?: object
+    returnType?: object
   }
 }
 ```
 
 ### Builder Pattern
 
-All implementations follow the same builder pattern:
+Both builders follow the same pattern:
 
 ```typescript
-const builder = new AppBuilder(config)
+const builder = new HonoAppBuilder(config)
   .register(PublicFactory, publicContextResolver)
   .register(ProtectedFactory, protectedContextResolver)
 
@@ -232,9 +278,9 @@ const app = builder.build()
 const docs = builder.docs
 ```
 
-All four builders' `build()` methods are synchronous — they return the framework app instance directly. Don't `await` the call.
+`build()` is synchronous — it returns the framework app instance directly. Don't `await` the call.
 
-**Single Hono server across builders:** all three Hono builders (`HonoRPCAppBuilder`, `HonoAPIAppBuilder`, `HonoStreamAppBuilder`) accept an optional `app?: Hono` in their config. Pass the same `new Hono()` instance to mount RPC, API, and Stream routes onto one server — the builders are registration scopes, not separate servers. See **[docs/http-integrations.md § One Hono Server, Multiple Builders](../../../docs/http-integrations.md#one-hono-server-multiple-builders)**.
+A single `HonoAppBuilder` registers procedures of every kind from the same factory and mounts them on one Hono `app`. The optional `app?: Hono` config lets you mount onto an existing Hono instance that already has custom middleware, health checks, or static routes; if omitted, the builder constructs its own.
 
 **Key methods:**
 
@@ -248,11 +294,13 @@ All four builders' `build()` methods are synchronous — they return the framewo
 | Property | Type | Description |
 |----------|------|-------------|
 | `app` | Framework app | The underlying framework application |
-| `docs` | Route doc array | Route documentation (populated after `build()`) |
+| `docs` | Route doc array | Route documentation, lazily computed on first read; `build()` also populates it. |
 
 ### DocRegistry
 
-Composes route documentation from multiple builders into a typed envelope, replacing manual `/docs` endpoint assembly.
+For single-builder apps, prefer `builder.toDocEnvelope({ basePath, errors })` — it wraps `DocRegistry` for the common case and produces an envelope identical to the multi-app aggregator.
+
+For multi-app aggregation (e.g., two `HonoAppBuilder` instances mounted on different prefixes), `DocRegistry` composes route documentation from every source into one typed envelope:
 
 ```typescript
 import { DocRegistry } from 'ts-procedures/http-docs'
@@ -261,9 +309,8 @@ const docs = new DocRegistry({
   basePath: '/api',
   errors: appErrors,  // your ErrorTaxonomy — framework defaults auto-merged and deduped
 })
-  .from(rpcBuilder)
-  .from(apiBuilder)
-  .from(streamBuilder)
+  .from(builderA)
+  .from(builderB)
 
 app.get('/docs', (c) => c.json(docs.toJSON()))
 ```
@@ -271,34 +318,37 @@ app.get('/docs', (c) => c.json(docs.toJSON()))
 - `from()` stores a reference — routes are read lazily at `toJSON()` time
 - `toJSON()` supports optional `filter` and `transform` options
 - `errors` accepts an `ErrorTaxonomy` or raw `ErrorDoc[]`; framework defaults are auto-merged (opt out via `includeDefaults: false`)
-- All builders satisfy the `DocSource` interface (`{ readonly docs: AnyHttpRouteDoc[] }`)
+- Every builder satisfies the `DocSource` interface (`{ readonly docs: AnyHttpRouteDoc[] }`)
 
 ### Client Code Generation
 
 Generate type-safe client SDKs from your DocRegistry output. The codegen reads the `DocEnvelope` JSON and produces per-scope TypeScript files with typed params, response types, and callable functions.
 
-**Requirements:** All routes need a `scope` field for file grouping. RPC and Stream routes already have `scope` via `RPCConfig`. API routes support optional `scope` on `APIConfig`:
+**Requirements:** every route needs a `scope` field for file grouping. RPC and stream routes carry `scope` via `RPCConfig`. REST routes (`CreateHttp` / `CreateHttpStream`) carry an optional `scope` directly on the procedure config:
 
 ```typescript
-const apiBuilder = new HonoAPIAppBuilder()
-apiBuilder.register(factory, (c) => ctx, {
+procs.CreateHttp('GetUser', {
+  path: '/users/:id',
+  method: 'get',
   scope: 'users', // Used for codegen file grouping
-})
+  schema: { req: { pathParams: Type.Object({ id: Type.String() }) } },
+}, async (_, { pathParams }) => /* ... */)
 ```
 
-**Route type handling in generated code:**
+**Route-doc kinds and how the codegen consumes them:**
 
-| Builder | Route Kind | Params Source | Generated Callable |
-|---------|-----------|---------------|-------------------|
-| HonoRPCAppBuilder | `rpc` | `jsonSchema.body` → flat params | `client.call()` |
-| HonoAPIAppBuilder | `api` | `jsonSchema.pathParams/query/body/headers` → structured params | `client.call()` |
-| HonoStreamAppBuilder | `stream` | `jsonSchema.params` → flat params | `client.stream()` |
+| Doc kind | Source procedure | Params shape in generated callable | Generated callable |
+|----------|------------------|------------------------------------|--------------------|
+| `rpc` | `Create()` | `jsonSchema.body` → flat params | `client.call()` |
+| `api` | `CreateHttp()` | `jsonSchema.req.{pathParams,query,body,headers}` → structured params | `client.call()` |
+| `stream` | `CreateStream()` | `jsonSchema.params` → flat params | `client.stream()` |
+| `http-stream` | `CreateHttpStream()` | `jsonSchema.req.{pathParams,query,body,headers}` → structured params | `client.stream()` |
 
 **SSE return values:** Stream procedures that return a value have it sent as `event: 'return'` SSE message. The client's `TypedStream.result` promise resolves with this value.
 
 **SSE yieldType unwrapping:** Codegen detects the SSE envelope in `yieldType` and uses the inner `data` schema for the generated `Yield` type.
 
-**Kind discriminant:** All route docs include a `kind` field (`'rpc' | 'api' | 'stream'`) for reliable type narrowing in the codegen pipeline and consumer code.
+**Kind discriminant:** All route docs include a `kind` field (`'rpc' | 'api' | 'stream' | 'http-stream'`) for reliable type narrowing in the codegen pipeline and consumer code.
 
 **Namespace types:** Use `--namespace-types` to wrap generated types in nested TS namespaces (`Scope.Route.Params`) instead of flat prefixed exports (`RouteParams`).
 
@@ -308,17 +358,6 @@ apiBuilder.register(factory, (c) => ctx, {
 
 **Clean output directory:** Use `--clean-out-dir` (or `cleanOutDir: true` in the programmatic API) to recursively remove the output directory before writing, so scope files left over from deleted or renamed scopes are pruned. Skipped under `--dry-run`.
 
-## Framework Comparison
-
-| Aspect | Express | Hono |
-|--------|---------|------|
-| Context param | `req: express.Request` | `c: Context` |
-| Error handler return | `void` (mutates res) | `Response` |
-| Body access | `req.body` | `await c.req.json()` |
-| Header access | `req.headers['x-id']` | `c.req.header('x-id')` |
-| JSON middleware | Auto-added (or manual) | Built-in |
-| Streaming support | Not yet | `hono-stream` |
-
 ## TypeScript Types
 
 ```typescript
@@ -326,6 +365,7 @@ import type {
   RPCConfig,
   RPCHttpRouteDoc,
   StreamHttpRouteDoc,
+  HttpStreamRouteDoc,
   StreamMode,
   APIConfig,
   APIHttpRouteDoc,

package/src/implementations/http/astro/README.md

@@ -1,6 +1,6 @@
 # `ts-procedures/astro`
 
-Drop one or more pre-built Hono apps (from `HonoAPIAppBuilder`, `HonoRPCAppBuilder`, or `HonoStreamAppBuilder`) into a single Astro catch-all endpoint. Procedure handlers can read Astro's per-request data (`locals`, `cookies`, `redirect`, `params`) inside their factory-context closures.
+Drop one or more pre-built Hono apps (from `HonoAppBuilder`, `HonoAppBuilder`, or `HonoAppBuilder`) into a single Astro catch-all endpoint. Procedure handlers can read Astro's per-request data (`locals`, `cookies`, `redirect`, `params`) inside their factory-context closures.
 
 > **Requires SSR.** Your Astro project must use `output: 'server'` or `output: 'hybrid'` with `export const prerender = false` in the catch-all file. Static-prerender mode bypasses live endpoints.
 
@@ -16,12 +16,12 @@ npm install ts-procedures hono astro
 
 ```ts
 // src/server/api.ts
-import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
+import { HonoAppBuilder } from 'ts-procedures/hono'
 import { getAstroContext } from 'ts-procedures/astro'
 import { usersAPI } from './procedures/users'
 import { db } from './db'
 
-export const apiApp = new HonoAPIAppBuilder()
+export const apiApp = new HonoAppBuilder()
   .register(usersAPI, (c) => {
     const astro = getAstroContext(c)
     return { db, user: astro.locals.user ?? null }
@@ -81,9 +81,8 @@ Dispatch rules:
 
 ## Streams
 
-`HonoStreamAppBuilder` returns a `Response` with a `ReadableStream` body. Astro SSR forwards that body verbatim — no additional configuration. Client disconnects abort `ctx.signal` inside the stream handler.
+`HonoAppBuilder` returns a `Response` with a `ReadableStream` body. Astro SSR forwards that body verbatim — no additional configuration. Client disconnects abort `ctx.signal` inside the stream handler.
 
 ## What's NOT included
 
-- Express RPC support (Express uses Node `req`/`res`, not Web Fetch).
 - DocRegistry coupling — wire `DocRegistry` against the same builders separately for client codegen.