ts-procedures 7.2.0 → 8.0.0

package/docs/superpowers/plans/2026-05-08-hono-app-builder-convergence.md

@@ -0,0 +1,3365 @@
+# HonoAppBuilder Convergence Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace the three Hono builders (`HonoRPCAppBuilder`, `HonoAPIAppBuilder`, `HonoStreamAppBuilder`) with a single `HonoAppBuilder` that accepts any `Procedures<>()` factory and dispatches each procedure to the correct handler by `kind`.
+
+**Architecture:** New `src/implementations/http/hono/` directory containing the public builder + per-kind handler/doc modules. Shared error-dispatch primitives extracted to `src/implementations/http/error-dispatch.ts` (one level up so it can be reused by future framework adapters). Old `hono-rpc/`, `hono-api/`, `hono-stream/` directories deleted entirely.
+
+**Tech Stack:** TypeScript, Hono 4.x, Vitest 4.x, AJV (validation, unchanged), TypeBox (schema authoring, unchanged).
+
+**Spec:** `docs/superpowers/specs/2026-05-08-hono-app-builder-convergence-design.md`
+
+**Pre-existing infrastructure this plan depends on (do not modify):**
+- `src/implementations/http/error-taxonomy.ts` — `defineErrorTaxonomy`, `resolveErrorResponse`, `defaultErrorTaxonomy`, `UnknownErrorConfig`, `taxonomyToErrorDocs`, `PROCEDURE_REGISTRATION_ERROR_DOC`
+- `src/implementations/http/doc-registry.ts` — `DocRegistry` class
+- `src/implementations/types.ts` — `RPCConfig`, `APIConfig`, `RPCHttpRouteDoc`, `APIHttpRouteDoc`, `StreamHttpRouteDoc`, `HttpStreamRouteDoc`, `AnyHttpRouteDoc`, `DocSource`, `DocEnvelope`, `ProceduresFactory`, `ExtractContext`, `ExtractConfig`, `HttpMethod`, `StreamMode`, `APIInput`
+- `src/types.ts` — `TProcedureRegistration`, `TStreamProcedureRegistration`, `THttpProcedureRegistration`, `THttpStreamProcedureRegistration`, `ProcedureKind`
+- `src/index.ts` — `Procedures` factory
+
+---
+
+## File Structure
+
+**Created:**
+- `src/implementations/http/error-dispatch.ts` — shared `dispatchPreStreamError` + `dispatchMidStreamError`
+- `src/implementations/http/error-dispatch.test.ts`
+- `src/implementations/http/hono/index.ts` — `HonoAppBuilder` class (public surface)
+- `src/implementations/http/hono/index.test.ts` — public-surface tests
+- `src/implementations/http/hono/types.ts` — `HonoAppBuilderConfig`, `HonoFactoryItem`, `OnRequestErrorContext`, `AnyProcedureRegistration`
+- `src/implementations/http/hono/path.ts` — `makeRoutePath`, `resolveFullPath`
+- `src/implementations/http/hono/path.test.ts`
+- `src/implementations/http/hono/handlers/rpc.ts` — `installRpcRoute`
+- `src/implementations/http/hono/handlers/rpc.test.ts`
+- `src/implementations/http/hono/handlers/http.ts` — `installHttpRoute`
+- `src/implementations/http/hono/handlers/http.test.ts`
+- `src/implementations/http/hono/handlers/stream.ts` — `installRpcStreamRoute`
+- `src/implementations/http/hono/handlers/stream.test.ts`
+- `src/implementations/http/hono/handlers/http-stream.ts` — `installHttpStreamRoute`
+- `src/implementations/http/hono/handlers/http-stream.test.ts`
+- `src/implementations/http/hono/docs/rpc-doc.ts`
+- `src/implementations/http/hono/docs/http-doc.ts`
+- `src/implementations/http/hono/docs/stream-doc.ts`
+- `src/implementations/http/hono/docs/http-stream-doc.ts`
+
+**Deleted entirely (after the new code passes its tests):**
+- `src/implementations/http/hono-rpc/` (4 files — index.ts, types.ts, index.test.ts, error-taxonomy.test.ts)
+- `src/implementations/http/hono-api/` (4 files)
+- `src/implementations/http/hono-stream/` (4 files)
+
+**Modified:**
+- `package.json` — remove `./hono-rpc`, `./hono-api`, `./hono-stream` exports; add `./hono` export
+- `src/implementations/http/doc-registry.test.ts` — update imports + assertions to point at `HonoAppBuilder`
+- `src/implementations/http/on-request-error.test.ts` — collapse three describe blocks into one, retarget at `HonoAppBuilder`
+- `src/implementations/http/route-errors.test.ts` — retarget imports
+- `src/implementations/http/error-taxonomy.test.ts` — retarget imports (top-level file, not the per-builder ones)
+- `src/implementations/http/README.md` — rewrite around single builder
+- `docs/http-integrations.md` — rewrite around single builder
+- `CLAUDE.md` — update references to old builder names
+- `README.md` — update v8 changelog/migration entry
+- `agent_config/claude-code/skills/ts-procedures/SKILL.md`, `patterns.md`, `anti-patterns.md`, `api-reference.md` — update examples
+- `agent_config/claude-code/skills/ts-procedures-scaffold/templates/` — delete `hono-rpc.ts`, `hono-stream.ts`; rename/rewrite `hono-api.ts` → `hono.ts`
+- `agent_config/copilot/copilot-instructions.md`, `agent_config/cursor/cursorrules` — same content updates
+- `src/types.ts` — update `ProcedureKind` JSDoc references from old builder names to `HonoAppBuilder`
+- `src/create-stream.ts` — update comments referring to `HonoStreamAppBuilder`
+- `src/implementations/http/doc-registry.ts` — update comment referring to `HonoRPCAppBuilder`
+
+---
+
+## Phase 1 — Foundation (independent, no impact on existing code)
+
+### Task 1: Create `path.ts` — `makeRoutePath` + `resolveFullPath`
+
+**Files:**
+- Create: `src/implementations/http/hono/path.ts`
+- Test: `src/implementations/http/hono/path.test.ts`
+
+The `makeRoutePath` function dispatches by kind: rpc/rpc-stream get scope+name+version generation, http/http-stream prepend the prefix to a developer-supplied path. `resolveFullPath` is the helper for the http case (also used directly by the http handlers).
+
+- [ ] **Step 1: Write the failing test**
+
+Create `src/implementations/http/hono/path.test.ts`:
+
+```ts
+import { describe, expect, test } from 'vitest'
+import { makeRoutePath, resolveFullPath } from './path.js'
+import type {
+  TProcedureRegistration,
+  TStreamProcedureRegistration,
+  THttpProcedureRegistration,
+  THttpStreamProcedureRegistration,
+} from '../../../types.js'
+
+describe('makeRoutePath', () => {
+  test('rpc: scope/name/version with kebab-case', () => {
+    const proc = {
+      name: 'GetUser',
+      kind: 'rpc',
+      config: { scope: 'users', version: 1 },
+      handler: async () => undefined,
+    } as unknown as TProcedureRegistration
+    expect(makeRoutePath({ procedure: proc })).toBe('/users/get-user/1')
+  })
+
+  test('rpc: array scope joined with /', () => {
+    const proc = {
+      name: 'List',
+      kind: 'rpc',
+      config: { scope: ['UserModule', 'admin'], version: 2 },
+      handler: async () => undefined,
+    } as unknown as TProcedureRegistration
+    expect(makeRoutePath({ procedure: proc })).toBe('/user-module/admin/list/2')
+  })
+
+  test('rpc: pathPrefix is normalized (leading slash inserted)', () => {
+    const proc = {
+      name: 'Echo',
+      kind: 'rpc',
+      config: { scope: 'echo', version: 1 },
+      handler: async () => undefined,
+    } as unknown as TProcedureRegistration
+    expect(makeRoutePath({ procedure: proc, prefix: 'api/v1' })).toBe('/api/v1/echo/echo/1')
+  })
+
+  test('rpc-stream: same shape as rpc', () => {
+    const proc = {
+      name: 'Tail',
+      kind: 'rpc-stream',
+      isStream: true,
+      config: { scope: 'logs', version: 1 },
+      handler: async function* () {},
+    } as unknown as TStreamProcedureRegistration
+    expect(makeRoutePath({ procedure: proc, prefix: '/api' })).toBe('/api/logs/tail/1')
+  })
+
+  test('http: prepends prefix to config.path', () => {
+    const proc = {
+      name: 'GetUser',
+      kind: 'http',
+      config: { path: '/users/:id', method: 'get' },
+      handler: async () => undefined,
+    } as unknown as THttpProcedureRegistration
+    expect(makeRoutePath({ procedure: proc, prefix: '/api/v1' })).toBe('/api/v1/users/:id')
+  })
+
+  test('http: leading slash on path is preserved (not duplicated)', () => {
+    const proc = {
+      name: 'Get',
+      kind: 'http',
+      config: { path: 'users', method: 'get' },
+      handler: async () => undefined,
+    } as unknown as THttpProcedureRegistration
+    expect(makeRoutePath({ procedure: proc, prefix: '/api' })).toBe('/api/users')
+  })
+
+  test('http-stream: same shape as http', () => {
+    const proc = {
+      name: 'TailLogs',
+      kind: 'http-stream',
+      config: { path: '/logs/tail', method: 'get' },
+      handler: async () => ({ stream: (async function* () {})(), initialHeaders: undefined }),
+    } as unknown as THttpStreamProcedureRegistration
+    expect(makeRoutePath({ procedure: proc })).toBe('/logs/tail')
+  })
+})
+
+describe('resolveFullPath', () => {
+  test('combines prefix and path', () => {
+    expect(resolveFullPath('/users', '/api/v1')).toBe('/api/v1/users')
+  })
+  test('normalizes prefix without leading slash', () => {
+    expect(resolveFullPath('/users', 'api')).toBe('/api/users')
+  })
+  test('normalizes path without leading slash', () => {
+    expect(resolveFullPath('users', '/api')).toBe('/api/users')
+  })
+  test('no prefix', () => {
+    expect(resolveFullPath('/users')).toBe('/users')
+  })
+})
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx vitest run src/implementations/http/hono/path.test.ts`
+Expected: FAIL — module `./path.js` does not exist.
+
+- [ ] **Step 3: Implement `path.ts`**
+
+Create `src/implementations/http/hono/path.ts`:
+
+```ts
+import { kebabCase } from 'es-toolkit/string'
+import { castArray } from 'es-toolkit/compat'
+import type {
+  TProcedureRegistration,
+  TStreamProcedureRegistration,
+  THttpProcedureRegistration,
+  THttpStreamProcedureRegistration,
+} from '../../../types.js'
+
+export type AnyProcedureRegistration =
+  | TProcedureRegistration
+  | TStreamProcedureRegistration
+  | THttpProcedureRegistration<any>
+  | THttpStreamProcedureRegistration<any>
+
+function normalizePrefix(prefix?: string): string {
+  if (!prefix) return ''
+  return prefix.startsWith('/') ? prefix : `/${prefix}`
+}
+
+/**
+ * Resolves the full route path for any procedure kind.
+ *
+ * - `rpc` / `rpc-stream`: `{prefix}/{kebab(scope)}/{kebab(name)}/{version}`
+ * - `http` / `http-stream`: `{prefix}{config.path}` (path-as-given, prefix normalized)
+ */
+export function makeRoutePath({
+  procedure,
+  prefix,
+}: {
+  procedure: AnyProcedureRegistration
+  prefix?: string
+}): string {
+  const normalizedPrefix = normalizePrefix(prefix)
+
+  switch (procedure.kind) {
+    case 'rpc':
+    case 'rpc-stream': {
+      const cfg = procedure.config as { scope: string | string[]; version: number }
+      const scopeSegments = castArray(cfg.scope).map(kebabCase).join('/')
+      return `${normalizedPrefix}/${scopeSegments}/${kebabCase(procedure.name)}/${String(cfg.version).trim()}`
+    }
+    case 'http':
+    case 'http-stream': {
+      const cfg = procedure.config as { path: string }
+      return resolveFullPath(cfg.path, prefix)
+    }
+  }
+}
+
+/**
+ * Combines a developer-supplied path with an optional prefix. Both are
+ * normalized to begin with a single `/`.
+ */
+export function resolveFullPath(procedurePath: string, prefix?: string): string {
+  const normalizedPrefix = normalizePrefix(prefix)
+  const normalizedPath = procedurePath.startsWith('/') ? procedurePath : `/${procedurePath}`
+  return `${normalizedPrefix}${normalizedPath}`
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx vitest run src/implementations/http/hono/path.test.ts`
+Expected: PASS — all 11 tests green.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/implementations/http/hono/path.ts src/implementations/http/hono/path.test.ts
+git commit -m "$(cat <<'EOF'
+feat(hono): add unified path resolver for all four procedure kinds
+
+makeRoutePath dispatches by procedure.kind: rpc/rpc-stream use
+scope+name+version generation; http/http-stream prepend the prefix to
+config.path. Foundation for HonoAppBuilder convergence.
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
+EOF
+)"
+```
+
+---
+
+### Task 2: `error-dispatch.ts` — `dispatchPreStreamError`
+
+**Files:**
+- Create: `src/implementations/http/error-dispatch.ts`
+- Test: `src/implementations/http/error-dispatch.test.ts`
+
+Pulls the inline three-step dispatch (observer → taxonomy → onError → hard default) out of the existing builders into one shared module. The pre-stream form returns a `Response`; mid-stream form (added in Task 3) returns body data.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `src/implementations/http/error-dispatch.test.ts`:
+
+```ts
+import { describe, expect, test, vi } from 'vitest'
+import { Hono } from 'hono'
+import { dispatchPreStreamError } from './error-dispatch.js'
+import { defineErrorTaxonomy } from './error-taxonomy.js'
+import { ProcedureValidationError } from '../../errors.js'
+
+function makeContext() {
+  // Hono's Context isn't directly constructible, so spin a request through
+  // a Hono app and capture the context inside a route handler.
+  return new Promise<import('hono').Context>((resolve) => {
+    const app = new Hono()
+    app.get('/', (c) => {
+      resolve(c)
+      return c.text('ok')
+    })
+    app.request('/')
+  })
+}
+
+const dummyProcedure = {
+  name: 'Test',
+  kind: 'rpc',
+  config: { scope: 'test', version: 1 },
+  handler: async () => undefined,
+} as any
+
+describe('dispatchPreStreamError', () => {
+  test('default taxonomy: ProcedureValidationError → 400', async () => {
+    const c = await makeContext()
+    const err = new ProcedureValidationError('Test', 'Validation error for Test', [
+      { instancePath: '/x', message: 'expected number' } as any,
+    ])
+
+    const res = await dispatchPreStreamError({
+      err,
+      procedure: dummyProcedure,
+      raw: c,
+      cfg: {},
+    })
+
+    expect(res.status).toBe(400)
+    const body = await res.json()
+    expect(body.name).toBe('ProcedureValidationError')
+    expect(body.procedureName).toBe('Test')
+  })
+
+  test('user taxonomy entry takes precedence', async () => {
+    const c = await makeContext()
+    class MyError extends Error {
+      constructor(public reason: string) { super(reason) }
+    }
+    const errors = defineErrorTaxonomy({
+      MyError: { class: MyError, statusCode: 422, toResponse: (e) => ({ name: 'MyError', reason: e.reason }) },
+    })
+
+    const res = await dispatchPreStreamError({
+      err: new MyError('boom'),
+      procedure: dummyProcedure,
+      raw: c,
+      cfg: { errors },
+    })
+
+    expect(res.status).toBe(422)
+    expect(await res.json()).toEqual({ name: 'MyError', reason: 'boom' })
+  })
+
+  test('falls back to onError imperative callback', async () => {
+    const c = await makeContext()
+    const onError = vi.fn().mockResolvedValue(c.json({ ok: false }, 503))
+
+    const res = await dispatchPreStreamError({
+      err: new Error('unmatched'),
+      procedure: dummyProcedure,
+      raw: c,
+      cfg: { onError: (proc, raw, e) => onError(proc, raw, e) },
+    })
+
+    expect(onError).toHaveBeenCalled()
+    expect(res.status).toBe(503)
+  })
+
+  test('hard default 500 when nothing matches', async () => {
+    const c = await makeContext()
+    const res = await dispatchPreStreamError({
+      err: new Error('boom'),
+      procedure: dummyProcedure,
+      raw: c,
+      cfg: {},
+    })
+    expect(res.status).toBe(500)
+    expect(await res.json()).toEqual({ error: 'boom' })
+  })
+
+  test('onRequestError observer fires before dispatch and is awaited', async () => {
+    const c = await makeContext()
+    const calls: string[] = []
+    const onRequestError = vi.fn(async () => {
+      calls.push('observer')
+    })
+    const errors = defineErrorTaxonomy({
+      AnyError: {
+        match: (e): e is Error => e instanceof Error,
+        statusCode: 500,
+        toResponse: () => {
+          calls.push('toResponse')
+          return { name: 'AnyError' }
+        },
+      },
+    })
+
+    await dispatchPreStreamError({
+      err: new Error('x'),
+      procedure: dummyProcedure,
+      raw: c,
+      cfg: { errors, onRequestError },
+    })
+
+    expect(calls).toEqual(['observer', 'toResponse'])
+    expect(onRequestError).toHaveBeenCalledWith({ err: expect.any(Error), procedure: dummyProcedure, raw: c })
+  })
+
+  test('observer throw is swallowed and logged', async () => {
+    const c = await makeContext()
+    const consoleErr = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const onRequestError = vi.fn(() => { throw new Error('observer broke') })
+
+    const res = await dispatchPreStreamError({
+      err: new Error('x'),
+      procedure: dummyProcedure,
+      raw: c,
+      cfg: { onRequestError },
+    })
+
+    expect(res.status).toBe(500)
+    expect(consoleErr).toHaveBeenCalled()
+    consoleErr.mockRestore()
+  })
+})
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx vitest run src/implementations/http/error-dispatch.test.ts`
+Expected: FAIL — module does not exist.
+
+- [ ] **Step 3: Implement `error-dispatch.ts` (pre-stream half)**
+
+Create `src/implementations/http/error-dispatch.ts`:
+
+```ts
+import type { Context } from 'hono'
+import {
+  resolveErrorResponse,
+  type ErrorTaxonomy,
+  type UnknownErrorConfig,
+} from './error-taxonomy.js'
+import type {
+  TProcedureRegistration,
+  TStreamProcedureRegistration,
+  THttpProcedureRegistration,
+  THttpStreamProcedureRegistration,
+} from '../../types.js'
+
+export type AnyProcedureRegistration =
+  | TProcedureRegistration
+  | TStreamProcedureRegistration
+  | THttpProcedureRegistration<any>
+  | THttpStreamProcedureRegistration<any>
+
+export type OnRequestErrorContext = {
+  err: unknown
+  procedure: AnyProcedureRegistration
+  raw: Context
+}
+
+export type OnRequestErrorObserver = (
+  ctx: OnRequestErrorContext,
+) => void | Promise<void>
+
+export type PreStreamOnError = (
+  procedure: AnyProcedureRegistration,
+  raw: Context,
+  err: Error,
+) => Response | Promise<Response>
+
+export type PreStreamErrorConfig = {
+  errors?: ErrorTaxonomy
+  unknownError?: UnknownErrorConfig
+  onError?: PreStreamOnError
+  onRequestError?: OnRequestErrorObserver
+}
+
+/**
+ * Used by rpc, http, and the pre-stream guard in stream / http-stream
+ * handlers. Order: onRequestError observer (awaited, throws swallowed) →
+ * taxonomy resolver → imperative onError → hard default 500.
+ */
+export async function dispatchPreStreamError(params: {
+  err: unknown
+  procedure: AnyProcedureRegistration
+  raw: Context
+  cfg: PreStreamErrorConfig
+}): Promise<Response> {
+  const { err, procedure, raw, cfg } = params
+
+  if (cfg.onRequestError) {
+    try {
+      await cfg.onRequestError({ err, procedure, raw })
+    } catch (observerErr) {
+      console.error(
+        '[ts-procedures hono] onRequestError threw — swallowed:',
+        observerErr,
+      )
+    }
+  }
+
+  if (cfg.errors || cfg.unknownError) {
+    const resolved = resolveErrorResponse({
+      err,
+      userTaxonomy: cfg.errors,
+      unknownError: cfg.unknownError,
+      procedure,
+      raw,
+    })
+    if (resolved) {
+      await resolved.runOnCatch()
+      return raw.json(resolved.body, resolved.statusCode as never)
+    }
+  }
+
+  if (cfg.onError) {
+    return cfg.onError(procedure, raw, err as Error)
+  }
+
+  return raw.json({ error: (err as Error).message }, 500)
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npx vitest run src/implementations/http/error-dispatch.test.ts`
+Expected: PASS — 6 tests green.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/implementations/http/error-dispatch.ts src/implementations/http/error-dispatch.test.ts
+git commit -m "$(cat <<'EOF'
+feat(http): extract dispatchPreStreamError shared helper
+
+Consolidates the observer→taxonomy→onError→default chain duplicated
+across hono-rpc, hono-api, and hono-stream into one helper. Lives one
+level up from hono/ so future framework adapters can reuse it.
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
+EOF
+)"
+```
+
+---
+
+### Task 3: `error-dispatch.ts` — `dispatchMidStreamError`
+
+**Files:**
+- Modify: `src/implementations/http/error-dispatch.ts`
+- Modify: `src/implementations/http/error-dispatch.test.ts`
+
+Mid-stream dispatcher returns body bytes (not a `Response`) because the HTTP status is already committed when streaming starts. The result includes optional SSE event/id/retry overrides and a deferred `runOnCatch`.
+
+- [ ] **Step 1: Add failing tests for the mid-stream dispatcher**
+
+Append to `src/implementations/http/error-dispatch.test.ts`:
+
+```ts
+import { dispatchMidStreamError } from './error-dispatch.js'
+// `sse` currently lives in hono-stream/index.ts. Task 11 moves it into
+// hono/handlers/stream.ts and rewrites this import to './hono/handlers/stream.js'.
+import { sse } from './hono-stream/index.js'
+
+const streamProcedure = {
+  name: 'Tail',
+  kind: 'rpc-stream',
+  isStream: true,
+  config: { scope: 'logs', version: 1 },
+  handler: async function* () {},
+} as any
+
+describe('dispatchMidStreamError', () => {
+  test('uses taxonomy body when configured', async () => {
+    const c = await makeContext()
+    class MidErr extends Error {}
+    const errors = defineErrorTaxonomy({
+      MidErr: { class: MidErr, statusCode: 500, toResponse: () => ({ name: 'MidErr', detail: 'x' }) },
+    })
+
+    const result = await dispatchMidStreamError({
+      err: new MidErr('mid'),
+      procedure: streamProcedure,
+      raw: c,
+      cfg: { errors },
+    })
+
+    expect(result.data).toEqual({ name: 'MidErr', detail: 'x' })
+    expect(result.sseEvent).toBe('error')
+    expect(result.runOnCatch).toBeTypeOf('function')
+  })
+
+  test('falls back to onMidStreamError', async () => {
+    const c = await makeContext()
+    const result = await dispatchMidStreamError({
+      err: new Error('boom'),
+      procedure: streamProcedure,
+      raw: c,
+      cfg: {
+        onMidStreamError: () => ({ data: { kind: 'fail', msg: 'boom' } }),
+      },
+    })
+
+    expect(result.data).toEqual({ kind: 'fail', msg: 'boom' })
+    expect(result.sseEvent).toBe('Tail') // procedure name override
+  })
+
+  test('hard default { error: msg } when nothing matches', async () => {
+    const c = await makeContext()
+    const result = await dispatchMidStreamError({
+      err: new Error('plain'),
+      procedure: streamProcedure,
+      raw: c,
+      cfg: {},
+    })
+
+    expect(result.data).toEqual({ error: 'plain' })
+    expect(result.sseEvent).toBe('error')
+  })
+
+  test('onRequestError observer fires before dispatch (mid-stream form)', async () => {
+    const c = await makeContext()
+    const onRequestError = vi.fn(async () => {})
+
+    await dispatchMidStreamError({
+      err: new Error('x'),
+      procedure: streamProcedure,
+      raw: c,
+      cfg: { onRequestError },
+    })
+
+    expect(onRequestError).toHaveBeenCalled()
+  })
+})
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx vitest run src/implementations/http/error-dispatch.test.ts`
+Expected: FAIL — `dispatchMidStreamError` not exported.
+
+- [ ] **Step 3: Add `dispatchMidStreamError` to `error-dispatch.ts`**
+
+Append to `src/implementations/http/error-dispatch.ts`:
+
+```ts
+export type MidStreamErrorResult<TErrorData = unknown> = {
+  data: TErrorData
+  closeStream?: boolean
+}
+
+export type OnMidStreamError<TErrorData = unknown> = (
+  procedure: TStreamProcedureRegistration | THttpStreamProcedureRegistration<any>,
+  raw: Context,
+  err: Error,
+) => MidStreamErrorResult<TErrorData> | undefined
+
+export type MidStreamErrorConfig<TErrorData = unknown> = {
+  errors?: ErrorTaxonomy
+  unknownError?: UnknownErrorConfig
+  onMidStreamError?: OnMidStreamError<TErrorData>
+  onRequestError?: OnRequestErrorObserver
+}
+
+export type DispatchedMidStreamError = {
+  data: unknown
+  sseEvent?: string
+  sseId?: string
+  sseRetry?: number
+  runOnCatch?: () => Promise<void>
+}
+
+/**
+ * Used inside SSE / text-stream generator catch blocks. Returns the bytes
+ * to write to the open stream — the HTTP status is already committed, so we
+ * can't return a Response. Order matches dispatchPreStreamError: observer
+ * (awaited, throws swallowed) → taxonomy → onMidStreamError → hard default.
+ */
+export async function dispatchMidStreamError<TErrorData = unknown>(params: {
+  err: unknown
+  procedure: TStreamProcedureRegistration | THttpStreamProcedureRegistration<any>
+  raw: Context
+  cfg: MidStreamErrorConfig<TErrorData>
+}): Promise<DispatchedMidStreamError> {
+  const { err, procedure, raw, cfg } = params
+
+  if (cfg.onRequestError) {
+    try {
+      await cfg.onRequestError({ err, procedure, raw })
+    } catch (observerErr) {
+      console.error(
+        '[ts-procedures hono] onRequestError (mid-stream) threw — swallowed:',
+        observerErr,
+      )
+    }
+  }
+
+  if (cfg.errors || cfg.unknownError) {
+    const resolved = resolveErrorResponse({
+      err,
+      userTaxonomy: cfg.errors,
+      unknownError: cfg.unknownError,
+      procedure,
+      raw,
+    })
+    if (resolved) {
+      return {
+        data: resolved.body,
+        sseEvent: 'error',
+        runOnCatch: resolved.runOnCatch,
+      }
+    }
+  }
+
+  if (cfg.onMidStreamError) {
+    const result = cfg.onMidStreamError(procedure, raw, err as Error)
+    if (result?.data !== undefined) {
+      return {
+        data: result.data,
+        sseEvent: procedure.name,
+      }
+    }
+  }
+
+  return {
+    data: { error: (err as Error).message },
+    sseEvent: 'error',
+  }
+}
+```
+
+You also need to add the import at the top of `error-dispatch.ts`:
+
+```ts
+import type { TStreamProcedureRegistration, THttpStreamProcedureRegistration } from '../../types.js'
+```
+
+For the test imports of `sse`, use the existing path until Task 9 moves it: `import { sse } from './hono-stream/index.js'`.
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `npx vitest run src/implementations/http/error-dispatch.test.ts`
+Expected: PASS — all 10 tests green.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/implementations/http/error-dispatch.ts src/implementations/http/error-dispatch.test.ts
+git commit -m "$(cat <<'EOF'
+feat(http): add dispatchMidStreamError for stream catch blocks
+
+Returns body bytes plus optional SSE event/id/retry overrides, since
+HTTP status is already committed once streaming starts. Same order as
+the pre-stream form: observer → taxonomy → onMidStreamError → default.
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
+EOF
+)"
+```
+
+---
+
+## Phase 2 — Doc Builders (one per kind, pure functions)
+
+### Task 4: `docs/rpc-doc.ts` — `buildRpcRouteDoc`
+
+**Files:**
+- Create: `src/implementations/http/hono/docs/rpc-doc.ts`
+
+Pure function — extracts an `RPCHttpRouteDoc` from a `TProcedureRegistration<any, RPCConfig>`. No tests for the pure builders in isolation; they're covered by the handler integration tests in Phase 3 and by the `index.test.ts` envelope tests in Phase 4.
+
+- [ ] **Step 1: Implement `rpc-doc.ts`**
+
+Create `src/implementations/http/hono/docs/rpc-doc.ts`:
+
+```ts
+import type { TProcedureRegistration } from '../../../../types.js'
+import type { RPCConfig, RPCHttpRouteDoc } from '../../../types.js'
+import { makeRoutePath } from '../path.js'
+
+export function buildRpcRouteDoc(
+  procedure: TProcedureRegistration<any, RPCConfig>,
+  prefix: string | undefined,
+  extend?: (params: { base: RPCHttpRouteDoc; procedure: TProcedureRegistration<any, RPCConfig> }) => Record<string, unknown>,
+): RPCHttpRouteDoc {
+  const config = procedure.config as RPCConfig & {
+    schema?: { params?: Record<string, unknown>; returnType?: Record<string, unknown> }
+    errors?: string[]
+  }
+
+  const jsonSchema: { body?: Record<string, unknown>; response?: Record<string, unknown> } = {}
+  if (config.schema?.params) jsonSchema.body = config.schema.params
+  if (config.schema?.returnType) jsonSchema.response = config.schema.returnType
+
+  const base: RPCHttpRouteDoc = {
+    kind: 'rpc',
+    name: procedure.name,
+    version: config.version,
+    scope: config.scope,
+    path: makeRoutePath({ procedure, prefix }),
+    method: 'post',
+    jsonSchema,
+  }
+  if (config.errors && config.errors.length > 0) {
+    base.errors = [...config.errors]
+  }
+
+  const extended = extend ? extend({ base, procedure }) : {}
+  return { ...extended, ...base }
+}
+```
+
+- [ ] **Step 2: Verify it builds**
+
+Run: `npx tsc --noEmit`
+Expected: PASS — no type errors. (No test file yet; integration tests come in Phase 3.)
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/implementations/http/hono/docs/rpc-doc.ts
+git commit -m "feat(hono): add rpc-doc builder
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 5: `docs/stream-doc.ts` — `buildStreamRouteDoc`
+
+**Files:**
+- Create: `src/implementations/http/hono/docs/stream-doc.ts`
+
+- [ ] **Step 1: Implement `stream-doc.ts`**
+
+Create `src/implementations/http/hono/docs/stream-doc.ts`:
+
+```ts
+import type { TStreamProcedureRegistration } from '../../../../types.js'
+import type { RPCConfig, StreamHttpRouteDoc, StreamMode } from '../../../types.js'
+import { makeRoutePath } from '../path.js'
+
+export function buildStreamRouteDoc(
+  procedure: TStreamProcedureRegistration<any, RPCConfig>,
+  streamMode: StreamMode,
+  prefix: string | undefined,
+  extend?: (params: { base: StreamHttpRouteDoc; procedure: TStreamProcedureRegistration<any, RPCConfig> }) => Record<string, unknown>,
+): StreamHttpRouteDoc {
+  const config = procedure.config as RPCConfig & {
+    schema?: { params?: Record<string, unknown>; yieldType?: Record<string, unknown>; returnType?: Record<string, unknown> }
+    errors?: string[]
+  }
+
+  const jsonSchema: StreamHttpRouteDoc['jsonSchema'] = {}
+  if (config.schema?.params) jsonSchema.params = config.schema.params
+
+  if (streamMode === 'sse') {
+    jsonSchema.yieldType = {
+      type: 'object',
+      description: 'SSE message envelope. The data field contains the procedure yield value.',
+      required: ['data', 'event', 'id'],
+      properties: {
+        data: config.schema?.yieldType ?? {},
+        event: { type: 'string' },
+        id: { type: 'string' },
+        retry: { type: 'number' },
+      },
+    }
+  } else if (config.schema?.yieldType) {
+    jsonSchema.yieldType = config.schema.yieldType
+  }
+
+  if (config.schema?.returnType) jsonSchema.returnType = config.schema.returnType
+
+  // POST first so codegen (which reads `methods[0]`) defaults to POST. POST is
+  // the canonical method for streams because it can carry a body for params.
+  const base: StreamHttpRouteDoc = {
+    kind: 'stream',
+    name: procedure.name,
+    version: config.version,
+    scope: config.scope,
+    path: makeRoutePath({ procedure, prefix }),
+    methods: ['post', 'get'],
+    streamMode,
+    jsonSchema,
+  }
+  if (config.errors && config.errors.length > 0) base.errors = [...config.errors]
+
+  const extended = extend ? extend({ base, procedure }) : {}
+  return { ...extended, ...base }
+}
+```
+
+- [ ] **Step 2: Verify build**
+
+Run: `npx tsc --noEmit`
+Expected: PASS.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/implementations/http/hono/docs/stream-doc.ts
+git commit -m "feat(hono): add stream-doc builder
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 6: `docs/http-doc.ts` — `buildHttpRouteDoc`
+
+**Files:**
+- Create: `src/implementations/http/hono/docs/http-doc.ts`
+
+- [ ] **Step 1: Implement `http-doc.ts`**
+
+Create `src/implementations/http/hono/docs/http-doc.ts`:
+
+```ts
+import type { THttpProcedureRegistration } from '../../../../types.js'
+import type { APIHttpRouteDoc } from '../../../types.js'
+import { resolveFullPath } from '../path.js'
+
+export function buildHttpRouteDoc(
+  procedure: THttpProcedureRegistration<any>,
+  prefix: string | undefined,
+  extend?: (params: { base: APIHttpRouteDoc; procedure: THttpProcedureRegistration<any> }) => Record<string, unknown>,
+): APIHttpRouteDoc {
+  const config = procedure.config
+  const fullPath = resolveFullPath(config.path, prefix)
+  const reqSchema = config.schema?.req
+  const resSchema = config.schema?.res
+  const jsonSchema: APIHttpRouteDoc['jsonSchema'] = {}
+
+  if (reqSchema && (reqSchema.pathParams || reqSchema.query || reqSchema.body || reqSchema.headers)) {
+    jsonSchema.req = {}
+    if (reqSchema.pathParams) jsonSchema.req.pathParams = reqSchema.pathParams as any
+    if (reqSchema.query) jsonSchema.req.query = reqSchema.query as any
+    if (reqSchema.body) jsonSchema.req.body = reqSchema.body as any
+    if (reqSchema.headers) jsonSchema.req.headers = reqSchema.headers as any
+  }
+  if (resSchema && (resSchema.body || resSchema.headers)) {
+    jsonSchema.res = {}
+    if (resSchema.body) jsonSchema.res.body = resSchema.body as any
+    if (resSchema.headers) jsonSchema.res.headers = resSchema.headers as any
+  }
+
+  const base: APIHttpRouteDoc = {
+    kind: 'api',
+    name: procedure.name,
+    scope: config.scope,
+    path: config.path,
+    method: config.method,
+    fullPath,
+    jsonSchema,
+  }
+  if (config.successStatus) base.successStatus = config.successStatus
+  if (config.errors && config.errors.length > 0) base.errors = [...config.errors]
+
+  const extended = extend ? extend({ base, procedure }) : {}
+  return { ...extended, ...base }
+}
+```
+
+- [ ] **Step 2: Verify build**
+
+Run: `npx tsc --noEmit`
+Expected: PASS.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/implementations/http/hono/docs/http-doc.ts
+git commit -m "feat(hono): add http-doc builder
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 7: `docs/http-stream-doc.ts` — `buildHttpStreamRouteDoc`
+
+**Files:**
+- Create: `src/implementations/http/hono/docs/http-stream-doc.ts`
+
+- [ ] **Step 1: Implement `http-stream-doc.ts`**
+
+Create `src/implementations/http/hono/docs/http-stream-doc.ts`:
+
+```ts
+import type { THttpStreamProcedureRegistration } from '../../../../types.js'
+import type { HttpStreamRouteDoc } from '../../../types.js'
+import { resolveFullPath } from '../path.js'
+
+export function buildHttpStreamRouteDoc(
+  procedure: THttpStreamProcedureRegistration<any>,
+  prefix: string | undefined,
+  extend?: (params: {
+    base: HttpStreamRouteDoc
+    procedure: THttpStreamProcedureRegistration<any>
+  }) => Record<string, unknown>,
+): HttpStreamRouteDoc {
+  const config = procedure.config
+  const fullPath = resolveFullPath(config.path, prefix)
+  const reqSchema = config.schema?.req
+  const resSchema = config.schema?.res
+  const jsonSchema: HttpStreamRouteDoc['jsonSchema'] = {}
+
+  if (reqSchema && (reqSchema.pathParams || reqSchema.query || reqSchema.body || reqSchema.headers)) {
+    jsonSchema.req = {}
+    if (reqSchema.pathParams) jsonSchema.req.pathParams = reqSchema.pathParams as any
+    if (reqSchema.query) jsonSchema.req.query = reqSchema.query as any
+    if (reqSchema.body) jsonSchema.req.body = reqSchema.body as any
+    if (reqSchema.headers) jsonSchema.req.headers = reqSchema.headers as any
+  }
+  if (resSchema?.headers) jsonSchema.res = { headers: resSchema.headers as any }
+  if (config.schema?.yield) jsonSchema.yield = config.schema.yield as any
+  if (config.schema?.returnType) jsonSchema.returnType = config.schema.returnType as any
+
+  const base: HttpStreamRouteDoc = {
+    kind: 'http-stream',
+    name: procedure.name,
+    scope: config.scope,
+    path: config.path,
+    method: config.method,
+    fullPath,
+    streamMode: 'sse',
+    jsonSchema,
+  }
+  if (config.errors && config.errors.length > 0) base.errors = [...config.errors]
+
+  const extended = extend ? extend({ base, procedure }) : {}
+  return { ...extended, ...base }
+}
+```
+
+- [ ] **Step 2: Verify build**
+
+Run: `npx tsc --noEmit`
+Expected: PASS.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/implementations/http/hono/docs/http-stream-doc.ts
+git commit -m "feat(hono): add http-stream-doc builder
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+## Phase 3 — Per-Kind Handler Modules
+
+Each handler installer takes `(app, procedure, factoryItem, config, docs)` and:
+1. Builds the route doc, pushes to `docs`.
+2. Registers a Hono handler that resolves context, extracts params, invokes the procedure, applies result, calls `dispatchPreStreamError` on throw.
+
+### Task 8: Define shared `types.ts` for the hono module
+
+**Files:**
+- Create: `src/implementations/http/hono/types.ts`
+
+This file is referenced by all handler modules and the public `index.ts`. No tests — pure type declarations.
+
+- [ ] **Step 1: Implement `types.ts`**
+
+Create `src/implementations/http/hono/types.ts`:
+
+```ts
+import type { Context, Hono } from 'hono'
+import type { ErrorTaxonomy, UnknownErrorConfig } from '../error-taxonomy.js'
+import type {
+  AnyProcedureRegistration,
+  OnRequestErrorObserver,
+  OnMidStreamError,
+  PreStreamOnError,
+} from '../error-dispatch.js'
+import type {
+  ProceduresFactory,
+  ExtractContext,
+  StreamMode,
+  AnyHttpRouteDoc,
+  RPCHttpRouteDoc,
+  APIHttpRouteDoc,
+  StreamHttpRouteDoc,
+  HttpStreamRouteDoc,
+} from '../../types.js'
+import type {
+  TProcedureRegistration,
+  TStreamProcedureRegistration,
+  THttpProcedureRegistration,
+} from '../../../types.js'
+
+export type { AnyProcedureRegistration } from '../error-dispatch.js'
+
+/** Default query parser using URLSearchParams. */
+export type QueryParser = (queryString: string) => Record<string, unknown>
+
+export type OnRequestErrorContext = {
+  err: unknown
+  procedure: AnyProcedureRegistration
+  raw: Context
+}
+
+export type ExtendProcedureDoc = (params: {
+  base: RPCHttpRouteDoc | APIHttpRouteDoc | StreamHttpRouteDoc | HttpStreamRouteDoc
+  procedure: AnyProcedureRegistration
+}) => Record<string, unknown>
+
+export type HonoFactoryItem<TFactory extends ProceduresFactory = ProceduresFactory> = {
+  factory: TFactory
+  factoryContext:
+    | ExtractContext<TFactory>
+    | ((c: Context) => ExtractContext<TFactory> | Promise<ExtractContext<TFactory>>)
+  streamMode?: StreamMode
+  extendProcedureDoc?: ExtendProcedureDoc
+}
+
+export type HonoAppBuilderConfig<TStreamErrorData = unknown> = {
+  /** Existing Hono app. If omitted, a new instance is created. */
+  app?: Hono
+  /** Path prefix applied to every route across all kinds. */
+  pathPrefix?: string
+
+  // Error handling — peers
+  errors?: ErrorTaxonomy
+  unknownError?: UnknownErrorConfig
+  onError?: PreStreamOnError
+  /** Cross-cutting observer — fires for every caught error before dispatch. */
+  onRequestError?: OnRequestErrorObserver
+
+  // Lifecycle (every kind)
+  onRequestStart?: (c: Context) => void
+  onRequestEnd?: (c: Context) => void
+
+  // Kind-specific blocks
+  rpc?: {
+    onSuccess?: (procedure: TProcedureRegistration, c: Context) => void
+  }
+  api?: {
+    queryParser?: QueryParser
+    onSuccess?: (procedure: THttpProcedureRegistration<any>, c: Context) => void
+  }
+  stream?: {
+    /** Default for both rpc-stream and http-stream. */
+    defaultStreamMode?: StreamMode
+    onStreamStart?: (
+      procedure: TStreamProcedureRegistration | THttpProcedureRegistration<any>,
+      c: Context,
+      streamMode: StreamMode,
+    ) => void
+    onStreamEnd?: (
+      procedure: TStreamProcedureRegistration | THttpProcedureRegistration<any>,
+      c: Context,
+      streamMode: StreamMode,
+    ) => void
+    onMidStreamError?: OnMidStreamError<TStreamErrorData>
+  }
+}
+
+export type DocAccumulator = AnyHttpRouteDoc[]
+```
+
+- [ ] **Step 2: Verify build**
+
+Run: `npx tsc --noEmit`
+Expected: PASS.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/implementations/http/hono/types.ts
+git commit -m "feat(hono): add HonoAppBuilderConfig + factory item types
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 9: `handlers/rpc.ts` — `installRpcRoute`
+
+**Files:**
+- Create: `src/implementations/http/hono/handlers/rpc.ts`
+- Test: `src/implementations/http/hono/handlers/rpc.test.ts`
+
+- [ ] **Step 1: Write the failing test**
+
+Create `src/implementations/http/hono/handlers/rpc.test.ts`:
+
+```ts
+import { describe, expect, test, vi } from 'vitest'
+import { Hono } from 'hono'
+import { Type } from 'typebox'
+import { Procedures } from '../../../../index.js'
+import type { RPCConfig } from '../../../types.js'
+import { installRpcRoute } from './rpc.js'
+
+function buildApp(register: (factory: ReturnType<typeof Procedures<{}, RPCConfig>>) => void, cfg: any = {}) {
+  const RPC = Procedures<{ userId: string }, RPCConfig>()
+  register(RPC)
+  const app = new Hono()
+  const docs: any[] = []
+  for (const proc of RPC.getProcedures().values()) {
+    if (proc.kind !== 'rpc') continue
+    installRpcRoute({
+      app,
+      procedure: proc as any,
+      factoryItem: { factory: RPC, factoryContext: () => ({ userId: '123' }) },
+      cfg,
+      docs,
+    })
+  }
+  return { app, docs }
+}
+
+describe('installRpcRoute', () => {
+  test('mounts POST route at scope/name/version path', async () => {
+    const { app, docs } = buildApp((RPC) => {
+      RPC.Create('Echo', {
+        scope: 'echo',
+        version: 1,
+        schema: { params: Type.Object({ msg: Type.String() }) },
+      }, async (_ctx, params) => params)
+    })
+
+    const res = await app.request('/echo/echo/1', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ msg: 'hi' }),
+    })
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ msg: 'hi' })
+    expect(docs).toHaveLength(1)
+    expect(docs[0].kind).toBe('rpc')
+    expect(docs[0].path).toBe('/echo/echo/1')
+  })
+
+  test('rpc.onSuccess fires after handler', async () => {
+    const onSuccess = vi.fn()
+    const { app } = buildApp((RPC) => {
+      RPC.Create('Ping', { scope: 'p', version: 1 }, async () => ({ ok: true }))
+    }, { rpc: { onSuccess } })
+
+    await app.request('/p/ping/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    expect(onSuccess).toHaveBeenCalledOnce()
+  })
+
+  test('thrown error → dispatchPreStreamError default 500', async () => {
+    const { app } = buildApp((RPC) => {
+      RPC.Create('Boom', { scope: 'b', version: 1 }, async () => { throw new Error('boom') })
+    })
+
+    const res = await app.request('/b/boom/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    expect(res.status).toBe(500)
+    expect(await res.json()).toEqual({ error: 'boom' })
+  })
+
+  test('AbortSignal is injected into ctx', async () => {
+    let receivedSignal: AbortSignal | undefined
+    const { app } = buildApp((RPC) => {
+      RPC.Create('Sig', { scope: 's', version: 1 }, async (ctx) => {
+        receivedSignal = ctx.signal
+        return {}
+      })
+    })
+
+    await app.request('/s/sig/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    expect(receivedSignal).toBeInstanceOf(AbortSignal)
+  })
+})
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/rpc.test.ts`
+Expected: FAIL — `./rpc.js` not found.
+
+- [ ] **Step 3: Implement `handlers/rpc.ts`**
+
+Create `src/implementations/http/hono/handlers/rpc.ts`:
+
+```ts
+import type { Context, Hono } from 'hono'
+import type { TProcedureRegistration } from '../../../../types.js'
+import type { RPCConfig } from '../../../types.js'
+import { dispatchPreStreamError } from '../../error-dispatch.js'
+import { buildRpcRouteDoc } from '../docs/rpc-doc.js'
+import type { DocAccumulator, HonoAppBuilderConfig, HonoFactoryItem } from '../types.js'
+
+export function installRpcRoute(params: {
+  app: Hono
+  procedure: TProcedureRegistration<any, RPCConfig>
+  factoryItem: HonoFactoryItem
+  cfg: HonoAppBuilderConfig
+  docs: DocAccumulator
+}): void {
+  const { app, procedure, factoryItem, cfg, docs } = params
+
+  const route = buildRpcRouteDoc(
+    procedure,
+    cfg.pathPrefix,
+    factoryItem.extendProcedureDoc as any,
+  )
+  docs.push(route)
+
+  app.post(route.path, async (c: Context) => {
+    try {
+      const context =
+        typeof factoryItem.factoryContext === 'function'
+          ? await (factoryItem.factoryContext as (c: Context) => any)(c)
+          : factoryItem.factoryContext
+
+      const body = await c.req.json().catch(() => ({}))
+      const result = await procedure.handler(
+        { ...context, signal: c.req.raw.signal },
+        body,
+      )
+
+      cfg.rpc?.onSuccess?.(procedure, c)
+
+      return c.json(result)
+    } catch (error) {
+      return dispatchPreStreamError({
+        err: error,
+        procedure,
+        raw: c,
+        cfg: {
+          errors: cfg.errors,
+          unknownError: cfg.unknownError,
+          onError: cfg.onError,
+          onRequestError: cfg.onRequestError,
+        },
+      })
+    }
+  })
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/rpc.test.ts`
+Expected: PASS — 4 tests green.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/implementations/http/hono/handlers/rpc.ts src/implementations/http/hono/handlers/rpc.test.ts
+git commit -m "feat(hono): add installRpcRoute handler
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 10: `handlers/http.ts` — `installHttpRoute`
+
+**Files:**
+- Create: `src/implementations/http/hono/handlers/http.ts`
+- Test: `src/implementations/http/hono/handlers/http.test.ts`
+
+Implements the API/REST-style handler. Extracts structured params per channel (`pathParams`, `query`, `body`, `headers`), invokes the procedure, supports `{ body, headers }` and bare-result return shapes, and applies `successStatus` defaults.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `src/implementations/http/hono/handlers/http.test.ts`:
+
+```ts
+import { describe, expect, test, vi } from 'vitest'
+import { Hono } from 'hono'
+import { Type } from 'typebox'
+import { Procedures } from '../../../../index.js'
+import { installHttpRoute } from './http.js'
+
+function buildApp(setup: (P: ReturnType<typeof Procedures<any>>) => void, cfg: any = {}) {
+  const P = Procedures<{ uid: string }>()
+  setup(P)
+  const app = new Hono()
+  const docs: any[] = []
+  for (const proc of P.getProcedures().values()) {
+    if (proc.kind !== 'http') continue
+    installHttpRoute({
+      app,
+      procedure: proc as any,
+      factoryItem: { factory: P, factoryContext: () => ({ uid: 'u1' }) },
+      cfg,
+      docs,
+    })
+  }
+  return { app, docs }
+}
+
+describe('installHttpRoute', () => {
+  test('GET with pathParams and query', async () => {
+    const { app, docs } = buildApp((P) => {
+      P.CreateHttp('GetUser', {
+        path: '/users/:id',
+        method: 'get',
+        scope: 'users',
+        schema: {
+          req: {
+            pathParams: Type.Object({ id: Type.String() }),
+            query: Type.Object({ include: Type.Optional(Type.String()) }),
+          },
+          res: { body: Type.Object({ id: Type.String(), include: Type.Optional(Type.String()) }) },
+        },
+      }, async (_ctx, { pathParams, query }) => ({ body: { id: pathParams.id, include: query.include } }))
+    })
+
+    const res = await app.request('/users/abc?include=foo')
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ id: 'abc', include: 'foo' })
+    expect(docs[0].kind).toBe('api')
+    expect(docs[0].fullPath).toBe('/users/:id')
+  })
+
+  test('POST with body, default 201', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateHttp('Create', {
+        path: '/items',
+        method: 'post',
+        schema: {
+          req: { body: Type.Object({ name: Type.String() }) },
+          res: { body: Type.Object({ name: Type.String() }) },
+        },
+      }, async (_ctx, { body }) => ({ body }))
+    })
+
+    const res = await app.request('/items', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'gizmo' }),
+    })
+    expect(res.status).toBe(201)
+    expect(await res.json()).toEqual({ name: 'gizmo' })
+  })
+
+  test('DELETE returns 204 with no body', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateHttp('Delete', {
+        path: '/items/:id',
+        method: 'delete',
+        schema: { req: { pathParams: Type.Object({ id: Type.String() }) } },
+      }, async () => ({}))
+    })
+
+    const res = await app.request('/items/x', { method: 'DELETE' })
+    expect(res.status).toBe(204)
+    expect(await res.text()).toBe('')
+  })
+
+  test('headers in result are forwarded', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateHttp('WithHeaders', {
+        path: '/h', method: 'get',
+        schema: { res: { body: Type.Object({ ok: Type.Boolean() }), headers: Type.Object({}) } },
+      }, async () => ({ body: { ok: true }, headers: { 'x-trace': 'abc' } }))
+    })
+    const res = await app.request('/h')
+    expect(res.headers.get('x-trace')).toBe('abc')
+    expect(await res.json()).toEqual({ ok: true })
+  })
+
+  test('api.onSuccess fires after handler', async () => {
+    const onSuccess = vi.fn()
+    const { app } = buildApp((P) => {
+      P.CreateHttp('Ping', { path: '/ping', method: 'get' }, async () => ({}))
+    }, { api: { onSuccess } })
+
+    await app.request('/ping')
+    expect(onSuccess).toHaveBeenCalledOnce()
+  })
+
+  test('thrown error → dispatchPreStreamError default 500', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateHttp('Boom', { path: '/boom', method: 'get' }, async () => { throw new Error('x') })
+    })
+    const res = await app.request('/boom')
+    expect(res.status).toBe(500)
+    expect(await res.json()).toEqual({ error: 'x' })
+  })
+
+  test('custom queryParser is used', async () => {
+    const queryParser = vi.fn((q: string) => ({ parsed: true, raw: q }))
+    const { app } = buildApp((P) => {
+      P.CreateHttp('Q', { path: '/q', method: 'get', schema: { req: { query: Type.Any() } } },
+        async (_ctx, { query }) => ({ body: query }))
+    }, { api: { queryParser } })
+
+    const res = await app.request('/q?a=1&b=2')
+    expect(queryParser).toHaveBeenCalledWith('a=1&b=2')
+    expect(await res.json()).toEqual({ parsed: true, raw: 'a=1&b=2' })
+  })
+})
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/http.test.ts`
+Expected: FAIL — `./http.js` not found.
+
+- [ ] **Step 3: Implement `handlers/http.ts`**
+
+Create `src/implementations/http/hono/handlers/http.ts`:
+
+```ts
+import type { Context, Hono } from 'hono'
+import type { THttpProcedureRegistration } from '../../../../types.js'
+import type { HttpMethod } from '../../../types.js'
+import { dispatchPreStreamError } from '../../error-dispatch.js'
+import { buildHttpRouteDoc } from '../docs/http-doc.js'
+import type { DocAccumulator, HonoAppBuilderConfig, HonoFactoryItem, QueryParser } from '../types.js'
+
+const BODY_METHODS: HttpMethod[] = ['post', 'put', 'patch']
+
+function defaultSuccessStatus(method: HttpMethod): number {
+  switch (method) {
+    case 'post':   return 201
+    case 'delete': return 204
+    default:       return 200
+  }
+}
+
+function parseQueryNative(queryString: string): Record<string, unknown> {
+  const sp = new URLSearchParams(queryString)
+  const result: Record<string, unknown> = {}
+  for (const key of new Set(sp.keys())) {
+    const values = sp.getAll(key)
+    result[key] = values.length > 1 ? values : values[0]
+  }
+  return result
+}
+
+function extractQuery(url: string, parser: QueryParser): Record<string, unknown> {
+  const q = url.indexOf('?')
+  if (q === -1) return {}
+  const raw = url.slice(q + 1)
+  return raw ? parser(raw) : {}
+}
+
+async function extractParams(
+  c: Context,
+  method: HttpMethod,
+  reqSchema: Record<string, unknown>,
+  parser: QueryParser,
+): Promise<Record<string, unknown>> {
+  const params: Record<string, unknown> = {}
+  for (const channel of Object.keys(reqSchema)) {
+    switch (channel) {
+      case 'pathParams':
+        params.pathParams = c.req.param()
+        break
+      case 'query':
+        params.query = extractQuery(c.req.url, parser)
+        break
+      case 'body':
+        if (BODY_METHODS.includes(method)) {
+          params.body = await c.req.json().catch(() => ({}))
+        }
+        break
+      case 'headers': {
+        const obj: Record<string, string> = {}
+        c.req.raw.headers.forEach((v, k) => { obj[k] = v })
+        params.headers = obj
+        break
+      }
+      default:
+        params[channel] = undefined
+    }
+  }
+  return params
+}
+
+export function installHttpRoute(params: {
+  app: Hono
+  procedure: THttpProcedureRegistration<any>
+  factoryItem: HonoFactoryItem
+  cfg: HonoAppBuilderConfig
+  docs: DocAccumulator
+}): void {
+  const { app, procedure, factoryItem, cfg, docs } = params
+  const queryParser = cfg.api?.queryParser ?? parseQueryNative
+
+  const route = buildHttpRouteDoc(
+    procedure,
+    cfg.pathPrefix,
+    factoryItem.extendProcedureDoc as any,
+  )
+  docs.push(route)
+
+  const successStatus = procedure.config.successStatus ?? defaultSuccessStatus(procedure.config.method)
+  const reqSchema = procedure.config.schema?.req
+
+  app.on(procedure.config.method.toUpperCase(), route.fullPath, async (c: Context) => {
+    try {
+      const context =
+        typeof factoryItem.factoryContext === 'function'
+          ? await (factoryItem.factoryContext as (c: Context) => any)(c)
+          : factoryItem.factoryContext
+
+      const reqParams = reqSchema
+        ? await extractParams(c, procedure.config.method, reqSchema, queryParser)
+        : undefined
+
+      const result = await procedure.handler(
+        { ...context, signal: c.req.raw.signal },
+        reqParams,
+      )
+
+      cfg.api?.onSuccess?.(procedure, c)
+
+      // 204 No Content — no body, just optional headers
+      if (successStatus === 204) {
+        if (result && typeof result === 'object' && 'headers' in result && (result as any).headers) {
+          for (const [k, v] of Object.entries((result as any).headers as Record<string, string>)) {
+            c.header(k, v)
+          }
+        }
+        return c.body(null, 204)
+      }
+
+      let body: unknown = result
+      let headers: Record<string, string> | undefined
+
+      if (result && typeof result === 'object' && 'body' in result && 'headers' in result) {
+        body = (result as any).body
+        headers = (result as any).headers as Record<string, string>
+      } else if (result && typeof result === 'object' && 'headers' in result && !('body' in result)) {
+        for (const [k, v] of Object.entries((result as any).headers as Record<string, string>)) {
+          c.header(k, v)
+        }
+        return c.body(null, successStatus as any)
+      } else if (result && typeof result === 'object' && 'body' in result && !('headers' in result)) {
+        body = (result as any).body
+      }
+
+      if (headers) for (const [k, v] of Object.entries(headers)) c.header(k, v)
+      return c.json(body, successStatus as any)
+    } catch (error) {
+      return dispatchPreStreamError({
+        err: error,
+        procedure,
+        raw: c,
+        cfg: {
+          errors: cfg.errors,
+          unknownError: cfg.unknownError,
+          onError: cfg.onError,
+          onRequestError: cfg.onRequestError,
+        },
+      })
+    }
+  })
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/http.test.ts`
+Expected: PASS — 7 tests green.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/implementations/http/hono/handlers/http.ts src/implementations/http/hono/handlers/http.test.ts
+git commit -m "feat(hono): add installHttpRoute handler
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 11: `handlers/stream.ts` — `installRpcStreamRoute` + `sse` helper
+
+**Files:**
+- Create: `src/implementations/http/hono/handlers/stream.ts`
+- Test: `src/implementations/http/hono/handlers/stream.test.ts`
+
+Moves `sse(data, options)` from `hono-stream/index.ts` into this module. Pre-stream validates params, throws `ProcedureValidationError` (caught by `dispatchPreStreamError`). Mid-stream uses `dispatchMidStreamError`. Pumps SSE or text mode.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `src/implementations/http/hono/handlers/stream.test.ts`:
+
+```ts
+import { describe, expect, test, vi } from 'vitest'
+import { Hono } from 'hono'
+import { Type } from 'typebox'
+import { Procedures } from '../../../../index.js'
+import type { RPCConfig } from '../../../types.js'
+import { installRpcStreamRoute } from './stream.js'
+
+function buildApp(setup: (P: ReturnType<typeof Procedures<any, RPCConfig>>) => void, cfg: any = {}) {
+  const P = Procedures<{ uid: string }, RPCConfig>()
+  setup(P)
+  const app = new Hono()
+  const docs: any[] = []
+  for (const proc of P.getProcedures().values()) {
+    if (proc.kind !== 'rpc-stream') continue
+    installRpcStreamRoute({
+      app,
+      procedure: proc as any,
+      factoryItem: { factory: P, factoryContext: () => ({ uid: 'u1' }) },
+      cfg,
+      docs,
+      streamMode: cfg.stream?.defaultStreamMode ?? 'sse',
+    })
+  }
+  return { app, docs }
+}
+
+describe('installRpcStreamRoute', () => {
+  test('SSE: yields are written as data events; final return as event:return', async () => {
+    const { app, docs } = buildApp((P) => {
+      P.CreateStream('Counts', { scope: 'c', version: 1 }, async function* () {
+        yield 1
+        yield 2
+        return 'done'
+      })
+    })
+    expect(docs[0].kind).toBe('stream')
+    expect(docs[0].path).toBe('/c/counts/1')
+
+    const res = await app.request('/c/counts/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    expect(res.status).toBe(200)
+    const text = await res.text()
+    expect(text).toContain('data: 1')
+    expect(text).toContain('data: 2')
+    expect(text).toContain('event: return')
+    expect(text).toContain('data: "done"')
+  })
+
+  test('mid-stream throw → dispatchMidStreamError default { error }', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateStream('Boom', { scope: 'b', version: 1 }, async function* () {
+        yield 'first'
+        throw new Error('mid-boom')
+      })
+    })
+    const res = await app.request('/b/boom/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    const text = await res.text()
+    expect(text).toContain('event: error')
+    expect(text).toContain('"error":"mid-boom"')
+  })
+
+  test('pre-stream validation error → 400 via dispatchPreStreamError', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateStream('NeedsParams', {
+        scope: 'n', version: 1,
+        schema: { params: Type.Object({ id: Type.String() }) },
+      }, async function* () { yield 'ok' })
+    })
+    const res = await app.request('/n/needs-params/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    expect(res.status).toBe(400)
+    const body = await res.json()
+    expect(body.name).toBe('ProcedureValidationError')
+  })
+
+  test('onStreamStart and onStreamEnd fire', async () => {
+    const onStreamStart = vi.fn()
+    const onStreamEnd = vi.fn()
+    const { app } = buildApp((P) => {
+      P.CreateStream('Ev', { scope: 'e', version: 1 }, async function* () { yield 'x' })
+    }, { stream: { onStreamStart, onStreamEnd } })
+
+    await app.request('/e/ev/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    expect(onStreamStart).toHaveBeenCalled()
+    expect(onStreamEnd).toHaveBeenCalled()
+  })
+})
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/stream.test.ts`
+Expected: FAIL — `./stream.js` not found.
+
+- [ ] **Step 3: Implement `handlers/stream.ts`**
+
+Create `src/implementations/http/hono/handlers/stream.ts`:
+
+```ts
+import type { Context, Hono } from 'hono'
+import { streamSSE, streamText } from 'hono/streaming'
+import type { TStreamProcedureRegistration } from '../../../../types.js'
+import type { RPCConfig, StreamMode } from '../../../types.js'
+import { ProcedureValidationError } from '../../../../errors.js'
+import { dispatchMidStreamError, dispatchPreStreamError } from '../../error-dispatch.js'
+import { buildStreamRouteDoc } from '../docs/stream-doc.js'
+import type { DocAccumulator, HonoAppBuilderConfig, HonoFactoryItem } from '../types.js'
+
+export type SSEOptions = {
+  event?: string
+  id?: string
+  retry?: number
+}
+
+const sseMetadata = new WeakMap<object, SSEOptions>()
+
+/**
+ * Marks an object yield as an SSE event with custom metadata. Stream handlers
+ * read this metadata to set the SSE `event:`, `id:`, and `retry:` fields.
+ */
+export function sse<T extends object>(data: T, options?: SSEOptions): T {
+  sseMetadata.set(data, options ?? {})
+  return data
+}
+
+function getSSEMeta(value: unknown): SSEOptions | undefined {
+  if (typeof value === 'object' && value !== null) {
+    return sseMetadata.get(value as object)
+  }
+  return undefined
+}
+
+export function installRpcStreamRoute(params: {
+  app: Hono
+  procedure: TStreamProcedureRegistration<any, RPCConfig>
+  factoryItem: HonoFactoryItem
+  cfg: HonoAppBuilderConfig
+  docs: DocAccumulator
+  streamMode: StreamMode
+}): void {
+  const { app, procedure, factoryItem, cfg, docs, streamMode } = params
+
+  const route = buildStreamRouteDoc(
+    procedure,
+    streamMode,
+    cfg.pathPrefix,
+    factoryItem.extendProcedureDoc as any,
+  )
+  docs.push(route)
+
+  const handler = async (c: Context) => {
+    try {
+      const context =
+        typeof factoryItem.factoryContext === 'function'
+          ? await (factoryItem.factoryContext as (c: Context) => any)(c)
+          : factoryItem.factoryContext
+
+      const reqParams =
+        c.req.method === 'GET'
+          ? Object.fromEntries(new URL(c.req.url).searchParams)
+          : await c.req.json().catch(() => ({}))
+
+      // Pre-stream validation — throw so the catch routes through dispatchPreStreamError.
+      if ((procedure.config as any).validation?.params) {
+        const { errors } = (procedure.config as any).validation.params(reqParams)
+        if (errors) {
+          throw new ProcedureValidationError(
+            procedure.name,
+            `Validation error for ${procedure.name}`,
+            errors,
+          )
+        }
+      }
+
+      cfg.stream?.onStreamStart?.(procedure, c, streamMode)
+
+      return streamMode === 'sse'
+        ? handleSSE(procedure, context, reqParams, c, cfg)
+        : handleText(procedure, context, reqParams, c, cfg)
+    } catch (error) {
+      return dispatchPreStreamError({
+        err: error,
+        procedure,
+        raw: c,
+        cfg: {
+          errors: cfg.errors,
+          unknownError: cfg.unknownError,
+          onError: cfg.onError,
+          onRequestError: cfg.onRequestError,
+        },
+      })
+    }
+  }
+
+  app.get(route.path, handler)
+  app.post(route.path, handler)
+}
+
+function handleSSE(
+  procedure: TStreamProcedureRegistration<any, RPCConfig>,
+  context: any,
+  reqParams: any,
+  c: Context,
+  cfg: HonoAppBuilderConfig,
+) {
+  return streamSSE(c, async (stream) => {
+    const generator = procedure.handler(
+      { ...context, signal: c.req.raw.signal, isPrevalidated: true } as any,
+      reqParams,
+    )
+    stream.onAbort(async () => { await generator.return(undefined) })
+
+    let eventId = 0
+    try {
+      const iterator = generator[Symbol.asyncIterator]()
+      let it = await iterator.next()
+
+      while (!it.done) {
+        const value = it.value
+        const meta = getSSEMeta(value)
+        const data =
+          typeof value === 'string' ? value
+          : value != null ? JSON.stringify(value)
+          : ''
+
+        await stream.writeSSE({
+          data,
+          event: meta?.event ?? procedure.name,
+          id: meta?.id ?? String(eventId++),
+          ...(meta?.retry !== undefined && { retry: meta.retry }),
+        })
+        it = await iterator.next()
+      }
+
+      if (it.value !== undefined) {
+        const data = typeof it.value === 'string' ? it.value : JSON.stringify(it.value)
+        await stream.writeSSE({ data, event: 'return', id: String(eventId++) })
+      }
+    } catch (error) {
+      const dispatched = await dispatchMidStreamError({
+        err: error,
+        procedure,
+        raw: c,
+        cfg: {
+          errors: cfg.errors,
+          unknownError: cfg.unknownError,
+          onMidStreamError: cfg.stream?.onMidStreamError,
+          onRequestError: cfg.onRequestError,
+        },
+      })
+
+      const meta = getSSEMeta(dispatched.data)
+      await stream.writeSSE({
+        data: typeof dispatched.data === 'string' ? dispatched.data : JSON.stringify(dispatched.data),
+        event: meta?.event ?? dispatched.sseEvent ?? 'error',
+        id: meta?.id ?? dispatched.sseId ?? String(eventId++),
+        ...((meta?.retry ?? dispatched.sseRetry) !== undefined && {
+          retry: (meta?.retry ?? dispatched.sseRetry) as number,
+        }),
+      })
+
+      if (dispatched.runOnCatch) await dispatched.runOnCatch()
+    } finally {
+      cfg.stream?.onStreamEnd?.(procedure, c, 'sse')
+      cfg.onRequestEnd?.(c)
+    }
+  })
+}
+
+function handleText(
+  procedure: TStreamProcedureRegistration<any, RPCConfig>,
+  context: any,
+  reqParams: any,
+  c: Context,
+  cfg: HonoAppBuilderConfig,
+) {
+  return streamText(c, async (stream) => {
+    const generator = procedure.handler(
+      { ...context, signal: c.req.raw.signal, isPrevalidated: true } as any,
+      reqParams,
+    )
+    stream.onAbort(async () => { await generator.return(undefined) })
+
+    try {
+      for await (const value of generator) {
+        await stream.writeln(JSON.stringify(value))
+      }
+    } catch (error) {
+      const dispatched = await dispatchMidStreamError({
+        err: error,
+        procedure,
+        raw: c,
+        cfg: {
+          errors: cfg.errors,
+          unknownError: cfg.unknownError,
+          onMidStreamError: cfg.stream?.onMidStreamError,
+          onRequestError: cfg.onRequestError,
+        },
+      })
+      await stream.writeln(JSON.stringify(dispatched.data))
+      if (dispatched.runOnCatch) await dispatched.runOnCatch()
+    } finally {
+      cfg.stream?.onStreamEnd?.(procedure, c, 'text')
+      cfg.onRequestEnd?.(c)
+    }
+  })
+}
+
+export type { MidStreamErrorResult } from '../../error-dispatch.js'
+```
+
+Now update the test file in `error-dispatch.test.ts` (Task 3) — change the placeholder import comment to actually import `sse` from this new module. Edit the file: replace the placeholder import line with `import { sse } from './hono/handlers/stream.js'`.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/stream.test.ts src/implementations/http/error-dispatch.test.ts`
+Expected: PASS — 4 + 10 = 14 tests green.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/implementations/http/hono/handlers/stream.ts src/implementations/http/hono/handlers/stream.test.ts src/implementations/http/error-dispatch.test.ts
+git commit -m "feat(hono): add installRpcStreamRoute handler + sse helper
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 12: `handlers/http-stream.ts` — `installHttpStreamRoute`
+
+**Files:**
+- Create: `src/implementations/http/hono/handlers/http-stream.ts`
+- Test: `src/implementations/http/hono/handlers/http-stream.test.ts`
+
+Mounts http-stream procedures (developer-supplied path, `{ stream, initialHeaders }` return shape, SSE only). Adds mid-stream error handling that the existing `hono-api.ts` lacks — calls `dispatchMidStreamError` inside the SSE pump catch.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `src/implementations/http/hono/handlers/http-stream.test.ts`:
+
+```ts
+import { describe, expect, test, vi } from 'vitest'
+import { Hono } from 'hono'
+import { Type } from 'typebox'
+import { Procedures } from '../../../../index.js'
+import { installHttpStreamRoute } from './http-stream.js'
+
+function buildApp(setup: (P: ReturnType<typeof Procedures<any>>) => void, cfg: any = {}) {
+  const P = Procedures<{ uid: string }>()
+  setup(P)
+  const app = new Hono()
+  const docs: any[] = []
+  for (const proc of P.getProcedures().values()) {
+    if (proc.kind !== 'http-stream') continue
+    installHttpStreamRoute({
+      app,
+      procedure: proc as any,
+      factoryItem: { factory: P, factoryContext: () => ({ uid: 'u1' }) },
+      cfg,
+      docs,
+    })
+  }
+  return { app, docs }
+}
+
+describe('installHttpStreamRoute', () => {
+  test('SSE pumping with initialHeaders and event:return', async () => {
+    const { app, docs } = buildApp((P) => {
+      P.CreateHttpStream('Tail', {
+        path: '/logs/tail', method: 'get',
+        schema: { yield: Type.Object({ line: Type.String() }) },
+      }, async () => ({
+        stream: (async function* () {
+          yield { line: 'a' }
+          yield { line: 'b' }
+          return 'fin'
+        })(),
+        initialHeaders: { 'x-trace': 'abc' },
+      }))
+    })
+    expect(docs[0].kind).toBe('http-stream')
+
+    const res = await app.request('/logs/tail')
+    expect(res.headers.get('x-trace')).toBe('abc')
+    const text = await res.text()
+    expect(text).toContain('"line":"a"')
+    expect(text).toContain('"line":"b"')
+    expect(text).toContain('event: return')
+    expect(text).toContain('"fin"')
+  })
+
+  test('mid-stream throw → dispatchMidStreamError default { error }', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateHttpStream('Boom', { path: '/boom', method: 'get' }, async () => ({
+        stream: (async function* () {
+          yield { ok: 1 }
+          throw new Error('mid')
+        })(),
+      }))
+    })
+    const res = await app.request('/boom')
+    const text = await res.text()
+    expect(text).toContain('event: error')
+    expect(text).toContain('"error":"mid"')
+  })
+
+  test('pre-stream throw → dispatchPreStreamError 500', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateHttpStream('Pre', { path: '/pre', method: 'get' }, async () => {
+        throw new Error('pre')
+      })
+    })
+    const res = await app.request('/pre')
+    expect(res.status).toBe(500)
+    expect(await res.json()).toEqual({ error: 'pre' })
+  })
+})
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/http-stream.test.ts`
+Expected: FAIL — `./http-stream.js` not found.
+
+- [ ] **Step 3: Implement `handlers/http-stream.ts`**
+
+Create `src/implementations/http/hono/handlers/http-stream.ts`:
+
+```ts
+import type { Context, Hono } from 'hono'
+import { streamSSE } from 'hono/streaming'
+import type { THttpStreamProcedureRegistration } from '../../../../types.js'
+import type { HttpMethod } from '../../../types.js'
+import { dispatchMidStreamError, dispatchPreStreamError } from '../../error-dispatch.js'
+import { buildHttpStreamRouteDoc } from '../docs/http-stream-doc.js'
+import type { DocAccumulator, HonoAppBuilderConfig, HonoFactoryItem, QueryParser } from '../types.js'
+
+const BODY_METHODS: HttpMethod[] = ['post', 'put', 'patch']
+
+function parseQueryNative(queryString: string): Record<string, unknown> {
+  const sp = new URLSearchParams(queryString)
+  const result: Record<string, unknown> = {}
+  for (const key of new Set(sp.keys())) {
+    const values = sp.getAll(key)
+    result[key] = values.length > 1 ? values : values[0]
+  }
+  return result
+}
+
+function extractQuery(url: string, parser: QueryParser): Record<string, unknown> {
+  const q = url.indexOf('?')
+  if (q === -1) return {}
+  const raw = url.slice(q + 1)
+  return raw ? parser(raw) : {}
+}
+
+async function extractParams(
+  c: Context,
+  method: HttpMethod,
+  reqSchema: Record<string, unknown>,
+  parser: QueryParser,
+): Promise<Record<string, unknown>> {
+  const params: Record<string, unknown> = {}
+  for (const channel of Object.keys(reqSchema)) {
+    switch (channel) {
+      case 'pathParams':
+        params.pathParams = c.req.param()
+        break
+      case 'query':
+        params.query = extractQuery(c.req.url, parser)
+        break
+      case 'body':
+        if (BODY_METHODS.includes(method)) {
+          params.body = await c.req.json().catch(() => ({}))
+        }
+        break
+      case 'headers': {
+        const obj: Record<string, string> = {}
+        c.req.raw.headers.forEach((v, k) => { obj[k] = v })
+        params.headers = obj
+        break
+      }
+      default:
+        params[channel] = undefined
+    }
+  }
+  return params
+}
+
+export function installHttpStreamRoute(params: {
+  app: Hono
+  procedure: THttpStreamProcedureRegistration<any>
+  factoryItem: HonoFactoryItem
+  cfg: HonoAppBuilderConfig
+  docs: DocAccumulator
+}): void {
+  const { app, procedure, factoryItem, cfg, docs } = params
+  const queryParser = cfg.api?.queryParser ?? parseQueryNative
+
+  const route = buildHttpStreamRouteDoc(
+    procedure,
+    cfg.pathPrefix,
+    factoryItem.extendProcedureDoc as any,
+  )
+  docs.push(route)
+
+  const reqSchema = procedure.config.schema?.req
+
+  app.on(procedure.config.method.toUpperCase(), route.fullPath, async (c: Context) => {
+    try {
+      const context =
+        typeof factoryItem.factoryContext === 'function'
+          ? await (factoryItem.factoryContext as (c: Context) => any)(c)
+          : factoryItem.factoryContext
+
+      const reqParams = reqSchema
+        ? await extractParams(c, procedure.config.method, reqSchema as Record<string, unknown>, queryParser)
+        : undefined
+
+      const { stream: gen, initialHeaders } = await procedure.handler(
+        { ...context, signal: c.req.raw.signal },
+        reqParams,
+      )
+
+      if (initialHeaders) {
+        for (const [k, v] of Object.entries(initialHeaders)) c.header(k, v)
+      }
+
+      cfg.stream?.onStreamStart?.(procedure, c, 'sse')
+
+      return streamSSE(c, async (stream) => {
+        let eventId = 0
+        try {
+          let it = await gen.next()
+          while (!it.done) {
+            const data = typeof it.value === 'string' ? it.value : JSON.stringify(it.value)
+            await stream.writeSSE({ data, event: procedure.name, id: String(eventId++) })
+            it = await gen.next()
+          }
+          if (it.value !== undefined) {
+            const data = typeof it.value === 'string' ? it.value : JSON.stringify(it.value)
+            await stream.writeSSE({ data, event: 'return', id: String(eventId++) })
+          }
+        } catch (error) {
+          const dispatched = await dispatchMidStreamError({
+            err: error,
+            procedure,
+            raw: c,
+            cfg: {
+              errors: cfg.errors,
+              unknownError: cfg.unknownError,
+              onMidStreamError: cfg.stream?.onMidStreamError,
+              onRequestError: cfg.onRequestError,
+            },
+          })
+          await stream.writeSSE({
+            data: typeof dispatched.data === 'string' ? dispatched.data : JSON.stringify(dispatched.data),
+            event: dispatched.sseEvent ?? 'error',
+            id: String(eventId++),
+            ...(dispatched.sseRetry !== undefined && { retry: dispatched.sseRetry }),
+          })
+          if (dispatched.runOnCatch) await dispatched.runOnCatch()
+        } finally {
+          cfg.stream?.onStreamEnd?.(procedure, c, 'sse')
+          cfg.onRequestEnd?.(c)
+        }
+      })
+    } catch (error) {
+      return dispatchPreStreamError({
+        err: error,
+        procedure,
+        raw: c,
+        cfg: {
+          errors: cfg.errors,
+          unknownError: cfg.unknownError,
+          onError: cfg.onError,
+          onRequestError: cfg.onRequestError,
+        },
+      })
+    }
+  })
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/http-stream.test.ts`
+Expected: PASS — 3 tests green.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/implementations/http/hono/handlers/http-stream.ts src/implementations/http/hono/handlers/http-stream.test.ts
+git commit -m "feat(hono): add installHttpStreamRoute handler
+
+Adds mid-stream error handling that the existing hono-api http-stream
+branch was missing — generator throws now dispatch through
+dispatchMidStreamError instead of propagating into an unhandled SSE
+abort.
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+## Phase 4 — HonoAppBuilder Public Class
+
+### Task 13: `index.ts` — class skeleton + `register` + lazy `docs`
+
+**Files:**
+- Create: `src/implementations/http/hono/index.ts`
+- Test: `src/implementations/http/hono/index.test.ts`
+
+- [ ] **Step 1: Write the failing test**
+
+Create `src/implementations/http/hono/index.test.ts`:
+
+```ts
+import { describe, expect, test } from 'vitest'
+import { Hono } from 'hono'
+import { Type } from 'typebox'
+import { Procedures } from '../../../index.js'
+import type { RPCConfig } from '../../types.js'
+import { HonoAppBuilder } from './index.js'
+
+describe('HonoAppBuilder — public surface', () => {
+  test('constructor with no args', () => {
+    const b = new HonoAppBuilder()
+    expect(b.app).toBeInstanceOf(Hono)
+    expect(b.docs).toEqual([])
+    expect(b.skippedProcedures).toEqual([])
+  })
+
+  test('constructor accepts existing Hono app', () => {
+    const custom = new Hono()
+    const b = new HonoAppBuilder({ app: custom })
+    expect(b.app).toBe(custom)
+  })
+
+  test('register is chainable', () => {
+    const b = new HonoAppBuilder()
+    const P = Procedures<{}, RPCConfig>()
+    const result = b.register(P, () => ({}))
+    expect(result).toBe(b)
+  })
+
+  test('docs is lazily computed before build()', () => {
+    const b = new HonoAppBuilder()
+    const P = Procedures<{}, RPCConfig>()
+    P.Create('A', { scope: 's', version: 1 }, async () => ({}))
+    b.register(P, () => ({}))
+
+    const docs1 = b.docs
+    expect(docs1).toHaveLength(1)
+    expect(docs1[0].kind).toBe('rpc')
+    // Calling docs again returns the same cached array reference
+    expect(b.docs).toBe(docs1)
+  })
+
+  test('docs reads after build() return the same content', () => {
+    const b = new HonoAppBuilder()
+    const P = Procedures<{}, RPCConfig>()
+    P.Create('A', { scope: 's', version: 1 }, async () => ({}))
+    b.register(P, () => ({}))
+    b.build()
+    expect(b.docs).toHaveLength(1)
+  })
+})
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx vitest run src/implementations/http/hono/index.test.ts`
+Expected: FAIL — `./index.js` not found.
+
+- [ ] **Step 3: Implement `index.ts` skeleton**
+
+Create `src/implementations/http/hono/index.ts`:
+
+```ts
+import { Context, Hono } from 'hono'
+import type {
+  AnyHttpRouteDoc,
+  ProceduresFactory,
+  ExtractContext,
+  StreamMode,
+} from '../../types.js'
+import { buildRpcRouteDoc } from './docs/rpc-doc.js'
+import { buildStreamRouteDoc } from './docs/stream-doc.js'
+import { buildHttpRouteDoc } from './docs/http-doc.js'
+import { buildHttpStreamRouteDoc } from './docs/http-stream-doc.js'
+import { installRpcRoute } from './handlers/rpc.js'
+import { installRpcStreamRoute } from './handlers/stream.js'
+import { installHttpRoute } from './handlers/http.js'
+import { installHttpStreamRoute } from './handlers/http-stream.js'
+import { makeRoutePath as _makeRoutePath } from './path.js'
+import type {
+  HonoAppBuilderConfig,
+  HonoFactoryItem,
+  ExtendProcedureDoc,
+  AnyProcedureRegistration,
+  OnRequestErrorContext,
+} from './types.js'
+
+export type { HonoAppBuilderConfig, OnRequestErrorContext, ExtendProcedureDoc } from './types.js'
+export type { AnyProcedureRegistration } from './types.js'
+export { sse } from './handlers/stream.js'
+export type { SSEOptions, MidStreamErrorResult } from './handlers/stream.js'
+export { defineErrorTaxonomy } from '../error-taxonomy.js'
+export type { ErrorTaxonomy, ErrorTaxonomyEntry, UnknownErrorConfig } from '../error-taxonomy.js'
+export type { QueryParser } from './types.js'
+
+export class HonoAppBuilder<TStreamErrorData = unknown> {
+  private readonly _app: Hono
+  private readonly factories: HonoFactoryItem<any>[] = []
+  private _docs: AnyHttpRouteDoc[] | null = null
+  private _skipped: { name: string; reason: string }[] = []
+  private _built = false
+
+  constructor(readonly config?: HonoAppBuilderConfig<TStreamErrorData>) {
+    this._app = config?.app ?? new Hono()
+
+    if (config?.onRequestStart) {
+      this._app.use('*', async (c, next) => {
+        config.onRequestStart!(c)
+        await next()
+      })
+    }
+    if (config?.onRequestEnd) {
+      this._app.use('*', async (c, next) => {
+        await next()
+        config.onRequestEnd!(c)
+      })
+    }
+  }
+
+  static makeRoutePath = _makeRoutePath
+
+  get app(): Hono {
+    return this._app
+  }
+
+  /**
+   * Lazily computed on first read or `build()`. Computing without `build()`
+   * lets tests and tooling introspect routes without spinning up handlers.
+   */
+  get docs(): AnyHttpRouteDoc[] {
+    if (this._docs === null) this.computeDocs()
+    return this._docs!
+  }
+
+  get skippedProcedures(): { name: string; reason: string }[] {
+    return this._skipped
+  }
+
+  register<TFactory extends ProceduresFactory>(
+    factory: TFactory,
+    factoryContext:
+      | ExtractContext<TFactory>
+      | ((c: Context) => ExtractContext<TFactory> | Promise<ExtractContext<TFactory>>),
+    options?: {
+      streamMode?: StreamMode
+      extendProcedureDoc?: ExtendProcedureDoc
+    },
+  ): this {
+    this.factories.push({
+      factory,
+      factoryContext,
+      streamMode: options?.streamMode,
+      extendProcedureDoc: options?.extendProcedureDoc,
+    } as HonoFactoryItem<any>)
+    // Invalidate the docs cache — next read recomputes.
+    this._docs = null
+    return this
+  }
+
+  private computeDocs(): void {
+    const docs: AnyHttpRouteDoc[] = []
+    const skipped: { name: string; reason: string }[] = []
+
+    for (const item of this.factories) {
+      for (const procedure of item.factory.getProcedures().values() as Iterable<AnyProcedureRegistration>) {
+        const prefix = this.config?.pathPrefix
+        switch (procedure.kind) {
+          case 'rpc':
+            docs.push(buildRpcRouteDoc(procedure as any, prefix, item.extendProcedureDoc as any))
+            break
+          case 'rpc-stream':
+            docs.push(buildStreamRouteDoc(
+              procedure as any,
+              item.streamMode ?? this.config?.stream?.defaultStreamMode ?? 'sse',
+              prefix,
+              item.extendProcedureDoc as any,
+            ))
+            break
+          case 'http':
+            docs.push(buildHttpRouteDoc(procedure as any, prefix, item.extendProcedureDoc as any))
+            break
+          case 'http-stream':
+            docs.push(buildHttpStreamRouteDoc(procedure as any, prefix, item.extendProcedureDoc as any))
+            break
+          default: {
+            const reason = `Unknown procedure kind "${(procedure as any).kind}"`
+            skipped.push({ name: (procedure as any).name, reason })
+          }
+        }
+      }
+    }
+
+    this._docs = docs
+    this._skipped = skipped
+  }
+
+  /**
+   * Mounts every registered procedure on the Hono app and returns it.
+   * Idempotent: calling twice is a no-op on the second call.
+   */
+  build(): Hono {
+    if (this._built) return this._app
+    this._built = true
+
+    const docs: AnyHttpRouteDoc[] = []
+    const skipped: { name: string; reason: string }[] = []
+    const cfg = this.config ?? {}
+
+    for (const item of this.factories) {
+      for (const procedure of item.factory.getProcedures().values() as Iterable<AnyProcedureRegistration>) {
+        switch (procedure.kind) {
+          case 'rpc':
+            installRpcRoute({ app: this._app, procedure: procedure as any, factoryItem: item, cfg, docs })
+            break
+          case 'rpc-stream': {
+            const streamMode = item.streamMode ?? cfg.stream?.defaultStreamMode ?? 'sse'
+            installRpcStreamRoute({ app: this._app, procedure: procedure as any, factoryItem: item, cfg, docs, streamMode })
+            break
+          }
+          case 'http':
+            installHttpRoute({ app: this._app, procedure: procedure as any, factoryItem: item, cfg, docs })
+            break
+          case 'http-stream':
+            installHttpStreamRoute({ app: this._app, procedure: procedure as any, factoryItem: item, cfg, docs })
+            break
+          default: {
+            const reason = `Unknown procedure kind "${(procedure as any).kind}"`
+            skipped.push({ name: (procedure as any).name, reason })
+            console.warn(`[ts-procedures hono] Skipping procedure "${(procedure as any).name}": ${reason}`)
+          }
+        }
+      }
+    }
+
+    this._docs = docs
+    this._skipped = skipped
+    return this._app
+  }
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx vitest run src/implementations/http/hono/index.test.ts`
+Expected: PASS — 5 tests green.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/implementations/http/hono/index.ts src/implementations/http/hono/index.test.ts
+git commit -m "feat(hono): add HonoAppBuilder class with lazy docs + dispatch
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 14: Mixed-kind dispatch integration test + `toDocEnvelope`
+
+**Files:**
+- Modify: `src/implementations/http/hono/index.ts` — add `toDocEnvelope`
+- Modify: `src/implementations/http/hono/index.test.ts`
+
+Verifies that one factory containing all four procedure kinds dispatches correctly under one builder. Adds `toDocEnvelope()` mirroring `DocRegistry.toJSON()`.
+
+- [ ] **Step 1: Append failing tests**
+
+Append to `src/implementations/http/hono/index.test.ts`:
+
+```ts
+import { Type } from 'typebox'
+import { Procedures } from '../../../index.js'
+import type { RPCConfig } from '../../types.js'
+import { defineErrorTaxonomy } from '../error-taxonomy.js'
+
+describe('HonoAppBuilder — mixed-kind dispatch', () => {
+  test('one factory with all four kinds mounts each at the correct path', async () => {
+    const P = Procedures<{ uid: string }, RPCConfig>()
+    P.Create('Echo', { scope: 'rpc', version: 1 }, async (_ctx, p) => p)
+    P.CreateStream('Tail', { scope: 'rpc', version: 1 }, async function* () { yield 1 })
+    P.CreateHttp('GetUser', { path: '/users/:id', method: 'get' }, async () => ({ body: { id: '1' } }))
+    P.CreateHttpStream('Watch', { path: '/watch', method: 'get' }, async () => ({
+      stream: (async function* () { yield 'tick' })(),
+    }))
+
+    const app = new HonoAppBuilder()
+      .register(P, () => ({ uid: 'u1' }))
+      .build()
+
+    const rpc = await app.request('/rpc/echo/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    expect(rpc.status).toBe(200)
+
+    const stream = await app.request('/rpc/tail/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    expect(stream.status).toBe(200)
+
+    const http = await app.request('/users/1')
+    expect(http.status).toBe(200)
+
+    const httpStream = await app.request('/watch')
+    expect(httpStream.status).toBe(200)
+  })
+
+  test('toDocEnvelope produces same shape as DocRegistry.toJSON', async () => {
+    const { DocRegistry } = await import('../doc-registry.js')
+
+    const P = Procedures<{}, RPCConfig>()
+    P.Create('Echo', { scope: 'e', version: 1 }, async () => ({}))
+
+    const errors = defineErrorTaxonomy({})
+    const builder = new HonoAppBuilder({ pathPrefix: '/api', errors })
+    builder.register(P, () => ({}))
+    builder.build()
+
+    const builderEnvelope = builder.toDocEnvelope({ basePath: '/api', errors })
+    const registryEnvelope = new DocRegistry({ basePath: '/api', errors }).from(builder).toJSON()
+
+    expect(builderEnvelope.basePath).toBe(registryEnvelope.basePath)
+    expect(builderEnvelope.routes).toEqual(registryEnvelope.routes)
+    expect(builderEnvelope.errors.map(e => e.name).sort()).toEqual(registryEnvelope.errors.map(e => e.name).sort())
+  })
+
+  test('toDocEnvelope filter and transform options work', () => {
+    const P = Procedures<{}, RPCConfig>()
+    P.Create('A', { scope: 's', version: 1 }, async () => ({}))
+    P.Create('B', { scope: 's', version: 1 }, async () => ({}))
+
+    const builder = new HonoAppBuilder().register(P, () => ({}))
+    const onlyA = builder.toDocEnvelope({ filter: r => r.name === 'A' })
+    expect(onlyA.routes).toHaveLength(1)
+    expect(onlyA.routes[0].name).toBe('A')
+
+    const tagged = builder.toDocEnvelope({
+      transform: env => ({ ...env, tagged: true }) as any,
+    }) as any
+    expect(tagged.tagged).toBe(true)
+  })
+})
+```
+
+- [ ] **Step 2: Add `toDocEnvelope` to `index.ts`**
+
+First, add a static import to the top of `src/implementations/http/hono/index.ts` (alongside the other imports):
+
+```ts
+import { DocRegistry } from '../doc-registry.js'
+import type { DocEnvelope, ErrorDoc, HeaderDoc } from '../../types.js'
+import type { ErrorTaxonomy } from '../error-taxonomy.js'
+```
+
+Then append the method to the `HonoAppBuilder` class body:
+
+```ts
+  /**
+   * Produces a {@link DocEnvelope} for single-app usage. For multi-app
+   * aggregation, use {@link DocRegistry} and `from(builder)` instead.
+   *
+   * Mirrors `DocRegistry.toJSON()` options so the two paths produce
+   * interchangeable envelopes for the codegen pipeline.
+   */
+  toDocEnvelope<T = DocEnvelope>(options?: {
+    basePath?: string
+    errors?: ErrorTaxonomy | ErrorDoc[]
+    includeDefaults?: boolean
+    headers?: HeaderDoc[]
+    filter?: (route: AnyHttpRouteDoc) => boolean
+    transform?: (envelope: DocEnvelope) => T
+  }): T {
+    return new DocRegistry({
+      basePath: options?.basePath ?? this.config?.pathPrefix,
+      errors: options?.errors ?? this.config?.errors,
+      includeDefaults: options?.includeDefaults,
+      headers: options?.headers,
+    }).from(this).toJSON<T>(options)
+  }
+```
+
+- [ ] **Step 3: Run tests to verify they pass**
+
+Run: `npx vitest run src/implementations/http/hono/index.test.ts`
+Expected: PASS — 8 tests green (5 existing + 3 new).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/implementations/http/hono/index.ts src/implementations/http/hono/index.test.ts
+git commit -m "feat(hono): add toDocEnvelope + mixed-kind dispatch coverage
+
+Delegates to DocRegistry internally so single-app and multi-app paths
+produce byte-identical envelopes for codegen.
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+## Phase 5 — Wire Up Exports
+
+### Task 15: Add `./hono` to `package.json#exports`
+
+**Files:**
+- Modify: `package.json`
+
+- [ ] **Step 1: Edit `package.json`**
+
+In `package.json`, add the new export after `./hono-stream` (which is still present — Phase 6 deletes it). Add this entry inside the `exports` object:
+
+```json
+"./hono": {
+  "types": "./build/implementations/http/hono/index.d.ts",
+  "import": "./build/implementations/http/hono/index.js"
+},
+```
+
+- [ ] **Step 2: Verify build**
+
+Run: `npm run build`
+Expected: PASS — TypeScript compiles `src/implementations/http/hono/` into `build/implementations/http/hono/`.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add package.json
+git commit -m "chore(pkg): add ts-procedures/hono subpath export
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+## Phase 6 — Migrate Shared Tests
+
+These four files at `src/implementations/http/` import from the soon-to-be-deleted directories. Retarget them at `HonoAppBuilder` BEFORE deleting the old directories so the test suite stays green throughout.
+
+### Task 16: Retarget `on-request-error.test.ts`
+
+**Files:**
+- Modify: `src/implementations/http/on-request-error.test.ts`
+
+The current file has three `describe` blocks, one per old builder. Collapse to one `describe('onRequestError — HonoAppBuilder')` covering all kinds.
+
+- [ ] **Step 1: Read the current file**
+
+Run: `cat src/implementations/http/on-request-error.test.ts`
+Note the existing test cases — three describe blocks with similar shapes (rpc, api, stream).
+
+- [ ] **Step 2: Rewrite imports and `boomApp` helpers**
+
+Replace the imports section (currently importing from `./hono-rpc/index.js`, `./hono-api/index.js`, `./hono-stream/index.js`) with a single import:
+
+```ts
+import { HonoAppBuilder } from './hono/index.js'
+```
+
+Replace the three `boomApp` helpers with one parameterized helper that mounts a procedure of any kind:
+
+```ts
+function boomApp(
+  kind: 'rpc' | 'rpc-stream' | 'http' | 'http-stream',
+  config: ConstructorParameters<typeof HonoAppBuilder>[0],
+) {
+  const P = Procedures<{}, RPCConfig>()
+  switch (kind) {
+    case 'rpc':
+      P.Create('Boom', { scope: 'b', version: 1 }, async () => { throw new Error('boom') })
+      break
+    case 'rpc-stream':
+      P.CreateStream('Boom', { scope: 'b', version: 1 }, async function* () {
+        throw new Error('boom')
+      })
+      break
+    case 'http':
+      P.CreateHttp('Boom', { path: '/boom', method: 'get' }, async () => { throw new Error('boom') })
+      break
+    case 'http-stream':
+      P.CreateHttpStream('Boom', { path: '/boom', method: 'get' }, async () => { throw new Error('boom') })
+      break
+  }
+  return new HonoAppBuilder(config).register(P, () => ({})).build()
+}
+```
+
+Update each `describe` block to call `boomApp` with its kind parameter. The assertions stay the same — `onRequestError` should fire once per request, observer throws should be swallowed, etc.
+
+- [ ] **Step 3: Run tests**
+
+Run: `npx vitest run src/implementations/http/on-request-error.test.ts`
+Expected: PASS — all converted tests green.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/implementations/http/on-request-error.test.ts
+git commit -m "test(http): retarget on-request-error.test.ts at HonoAppBuilder
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 17: Retarget `doc-registry.test.ts`
+
+**Files:**
+- Modify: `src/implementations/http/doc-registry.test.ts`
+
+- [ ] **Step 1: Update imports and instantiations**
+
+Replace `import { HonoRPCAppBuilder } from './hono-rpc/index.js'` and `import { HonoAPIAppBuilder } from './hono-api/index.js'` with:
+
+```ts
+import { HonoAppBuilder } from './hono/index.js'
+```
+
+Replace every `new HonoRPCAppBuilder()` and `new HonoAPIAppBuilder()` with `new HonoAppBuilder()`. The assertions don't need to change — both produce `DocSource`.
+
+- [ ] **Step 2: Run tests**
+
+Run: `npx vitest run src/implementations/http/doc-registry.test.ts`
+Expected: PASS — all tests still green.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/implementations/http/doc-registry.test.ts
+git commit -m "test(http): retarget doc-registry.test.ts at HonoAppBuilder
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 18: Retarget `route-errors.test.ts` and top-level `error-taxonomy.test.ts`
+
+**Files:**
+- Modify: `src/implementations/http/route-errors.test.ts`
+- Modify: `src/implementations/http/error-taxonomy.test.ts`
+
+- [ ] **Step 1: Inspect both files**
+
+Run: `grep -nE "Hono(RPC|API|Stream)AppBuilder" src/implementations/http/route-errors.test.ts src/implementations/http/error-taxonomy.test.ts`
+Note every reference site.
+
+- [ ] **Step 2: Retarget imports and instantiations**
+
+In each file, replace old builder imports with `import { HonoAppBuilder } from './hono/index.js'` and update each `new HonoXAppBuilder()` to `new HonoAppBuilder()`. For tests using `onSuccess` flat at the constructor (rpc/api), wrap into `rpc: { onSuccess }` or `api: { onSuccess }` per kind. For tests using `onMidStreamError` flat at the constructor, wrap into `stream: { onMidStreamError }`.
+
+- [ ] **Step 3: Run tests**
+
+Run: `npx vitest run src/implementations/http/route-errors.test.ts src/implementations/http/error-taxonomy.test.ts`
+Expected: PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/implementations/http/route-errors.test.ts src/implementations/http/error-taxonomy.test.ts
+git commit -m "test(http): retarget route-errors and error-taxonomy tests
+
+Wrap flat builder hooks in stratified blocks (rpc.onSuccess,
+stream.onMidStreamError) to match the converged config shape.
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+## Phase 7 — Port Deep Test Suites
+
+The three old test files (`hono-rpc/index.test.ts` 1129 lines, `hono-api/index.test.ts` 1070 lines, `hono-stream/index.test.ts` 1836 lines) cover hundreds of behaviors that the per-handler test files (Tasks 9–12) don't fully replicate. Port their distinctive cases into the per-handler test files before deletion so coverage is preserved.
+
+### Task 19: Port `hono-rpc/index.test.ts` cases into `hono/handlers/rpc.test.ts`
+
+**Files:**
+- Modify: `src/implementations/http/hono/handlers/rpc.test.ts`
+- Reference (read, do not modify): `src/implementations/http/hono-rpc/index.test.ts`
+- Reference: `src/implementations/http/hono-rpc/error-taxonomy.test.ts`
+
+- [ ] **Step 1: Inventory cases worth porting**
+
+Run: `grep -nE "test\(|it\(" src/implementations/http/hono-rpc/index.test.ts src/implementations/http/hono-rpc/error-taxonomy.test.ts | head -80`
+
+Identify cases not already covered by the four base tests in `hono/handlers/rpc.test.ts`. Look for: pathPrefix variations, factoryContext variations (sync/async/static object), `extendProcedureDoc` callback, error taxonomy with user entries, `unknownError` fallback, observer-then-taxonomy ordering, validation errors, registration of multiple factories, and tests where `kind !== 'rpc'` procedures should be passed-through (no longer skipped under the unified builder).
+
+- [ ] **Step 2: Port the missing cases**
+
+For each case not yet covered, add a test in `hono/handlers/rpc.test.ts` using the existing `buildApp` helper. Wrap any constructor-flat hooks (`onSuccess`, `errors`, `onError`, `onRequestError`, `onRequestStart`, `onRequestEnd`) — `onSuccess` goes under `rpc: { onSuccess }`; the rest stay top-level.
+
+For the "non-rpc procedures get skipped" tests (e.g., registering a stream procedure with the rpc builder), DELETE them — under the unified builder, mixed-kind factories work natively, so the skip behavior no longer applies. The `index.test.ts` mixed-kind dispatch test (Task 14) covers the new behavior.
+
+For tests asserting on `builder.skippedProcedures`, retarget them to assert that the array is empty for known kinds — only "unknown future kind" entries should appear.
+
+- [ ] **Step 3: Run the consolidated test file**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/rpc.test.ts`
+Expected: PASS — all ported tests green.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/implementations/http/hono/handlers/rpc.test.ts
+git commit -m "test(hono): port hono-rpc test coverage into handlers/rpc.test.ts
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 20: Port `hono-api/index.test.ts` cases into `hono/handlers/http.test.ts`
+
+**Files:**
+- Modify: `src/implementations/http/hono/handlers/http.test.ts`
+- Reference: `src/implementations/http/hono-api/index.test.ts`
+- Reference: `src/implementations/http/hono-api/error-taxonomy.test.ts`
+
+Same approach as Task 19. The hono-api file also covers the http-stream branch (since hono-api today serves both http and http-stream procedures); split those cases between `handlers/http.test.ts` and `handlers/http-stream.test.ts` based on the procedure kind under test.
+
+- [ ] **Step 1: Inventory and port to `handlers/http.test.ts`**
+
+`grep -nE "test\(|it\(" src/implementations/http/hono-api/index.test.ts | head -60` — identify cases for `kind: 'http'` (developer paths, queryParser variants, all six HTTP methods, headers handling, `successStatus` overrides, response shape detection { body, headers } / bare body / headers-only, `extendProcedureDoc`, error taxonomy).
+
+Wrap flat constructor knobs: `onSuccess` → `api.onSuccess`, `queryParser` → `api.queryParser`.
+
+- [ ] **Step 2: Inventory and port to `handlers/http-stream.test.ts`**
+
+In the same `hono-api` file, the http-stream cases are mixed into the same `describe('HonoAPIAppBuilder')`. Identify them by the procedure created via `CreateHttpStream` and port them into `handlers/http-stream.test.ts`.
+
+- [ ] **Step 3: Run both files**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/http.test.ts src/implementations/http/hono/handlers/http-stream.test.ts`
+Expected: PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/implementations/http/hono/handlers/http.test.ts src/implementations/http/hono/handlers/http-stream.test.ts
+git commit -m "test(hono): port hono-api test coverage into handlers/http and handlers/http-stream
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 21: Port `hono-stream/index.test.ts` cases into `hono/handlers/stream.test.ts`
+
+**Files:**
+- Modify: `src/implementations/http/hono/handlers/stream.test.ts`
+- Reference: `src/implementations/http/hono-stream/index.test.ts`
+- Reference: `src/implementations/http/hono-stream/error-taxonomy.test.ts`
+
+Same approach. Cover: SSE vs text mode, `defaultStreamMode` global default vs per-register override (`register(F, ctx, { streamMode: 'text' })`), `sse(data, options)` helper for custom event/id/retry, mid-stream error variants, `onMidStreamError` returning custom data, abort signal propagation when client disconnects, `validateYields: true` behavior.
+
+Wrap flat constructor knobs: `onMidStreamError` → `stream.onMidStreamError`, `defaultStreamMode` → `stream.defaultStreamMode`, `onStreamStart`/`onStreamEnd` → `stream.onStreamStart`/`stream.onStreamEnd`.
+
+- [ ] **Step 1: Inventory and port**
+
+Run the same inventory as Tasks 19–20.
+
+- [ ] **Step 2: Add a test for the `register(F, ctx, { streamMode: 'text' })` per-factory override**
+
+This is the converged shape's replacement for the old `register(F, ctx, { streamMode: 'text' })` on `HonoStreamAppBuilder`. Port the equivalent cases.
+
+- [ ] **Step 3: Run**
+
+Run: `npx vitest run src/implementations/http/hono/handlers/stream.test.ts`
+Expected: PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/implementations/http/hono/handlers/stream.test.ts
+git commit -m "test(hono): port hono-stream test coverage into handlers/stream.test.ts
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+## Phase 8 — Delete Old + Cleanup
+
+### Task 22: Delete the three old builder directories + remove from `package.json#exports`
+
+**Files:**
+- Delete: `src/implementations/http/hono-rpc/`
+- Delete: `src/implementations/http/hono-api/`
+- Delete: `src/implementations/http/hono-stream/`
+- Modify: `package.json`
+
+- [ ] **Step 1: Confirm no remaining references**
+
+Run: `grep -rEn "hono-rpc|hono-api|hono-stream" src/ docs/ agent_config/ CLAUDE.md README.md package.json 2>/dev/null | grep -v "build/" | grep -v "docs/superpowers/"`
+
+Expected: only `package.json` (entries we're about to delete), comments in source files (Task 27 fixes those), and docs/agent_config files (Tasks 24–26 fix those). No imports.
+
+If any imports remain, retarget them at `./hono/index.js` before proceeding.
+
+- [ ] **Step 2: Delete the directories**
+
+```bash
+rm -rf src/implementations/http/hono-rpc/
+rm -rf src/implementations/http/hono-api/
+rm -rf src/implementations/http/hono-stream/
+```
+
+- [ ] **Step 3: Remove old subpath exports from `package.json`**
+
+Open `package.json` and delete these three blocks from the `exports` object:
+
+```json
+"./hono-rpc": {
+  "types": "./build/implementations/http/hono-rpc/index.d.ts",
+  "import": "./build/implementations/http/hono-rpc/index.js"
+},
+"./hono-stream": {
+  "types": "./build/implementations/http/hono-stream/index.d.ts",
+  "import": "./build/implementations/http/hono-stream/index.js"
+},
+"./hono-api": {
+  "types": "./build/implementations/http/hono-api/index.d.ts",
+  "import": "./build/implementations/http/hono-api/index.js"
+},
+```
+
+- [ ] **Step 4: Run full suite + lint + build**
+
+Run these in parallel:
+
+```bash
+npm run test
+npm run lint
+npm run build
+```
+
+Expected: all pass. If anything fails, the most likely cause is a forgotten import that wasn't caught in step 1 — fix it and re-run.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add -A
+git commit -m "$(cat <<'EOF'
+refactor(hono): remove old hono-rpc, hono-api, hono-stream builders
+
+The three specialized builders are replaced by HonoAppBuilder which
+dispatches all four procedure kinds (rpc, rpc-stream, http,
+http-stream) by procedure.kind from a single register() call.
+
+Removes ~1,580 lines of near-parallel dispatch/error/lifecycle code
+from src/implementations/http/.
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
+EOF
+)"
+```
+
+---
+
+### Task 23: Update source-comment references to old builder names
+
+**Files:**
+- Modify: `src/types.ts` (lines around the `ProcedureKind` JSDoc)
+- Modify: `src/create-stream.ts` (comments referring to `HonoStreamAppBuilder`)
+- Modify: `src/implementations/http/doc-registry.ts` (comment about `HonoRPCAppBuilder`)
+
+- [ ] **Step 1: Update `src/types.ts`**
+
+In `src/types.ts`, find the `ProcedureKind` JSDoc block (around line 17–28) and replace the four "served by Hono*AppBuilder" lines with a single line:
+
+```ts
+/**
+ * Discriminant on every procedure registration that drives builder routing.
+ *
+ * - `'rpc'` — Create() registration
+ * - `'rpc-stream'` — CreateStream() registration
+ * - `'http'` — CreateHttp() registration
+ * - `'http-stream'` — CreateHttpStream() registration
+ *
+ * `HonoAppBuilder` dispatches all four kinds from a single registration.
+ * Use `kind` for any logic that needs to distinguish procedure shape; the
+ * legacy `isStream` field on TStreamProcedureRegistration is kept for
+ * back-compat but new code should branch on `kind`.
+ */
+```
+
+- [ ] **Step 2: Update `src/create-stream.ts`**
+
+In `src/create-stream.ts`, find the two comments referencing `HonoStreamAppBuilder` (around lines 97 and 160) and replace `HonoStreamAppBuilder` with `HonoAppBuilder`.
+
+- [ ] **Step 3: Update `src/implementations/http/doc-registry.ts`**
+
+In `src/implementations/http/doc-registry.ts`, find the comment around line 92 (`// streaming procedure registered with HonoRPCAppBuilder`) and replace `HonoRPCAppBuilder` with `HonoAppBuilder`. Update the surrounding sentence to reflect that under the unified builder, mismatches are now "unknown procedure kind" rather than "registered with the wrong builder".
+
+- [ ] **Step 4: Verify build + lint**
+
+Run: `npm run lint && npm run build`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/types.ts src/create-stream.ts src/implementations/http/doc-registry.ts
+git commit -m "docs(types): update JSDoc references from old builder names
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 24: Update `src/implementations/http/README.md`
+
+**Files:**
+- Modify: `src/implementations/http/README.md`
+
+This README currently documents three separate builders. Rewrite around the single `HonoAppBuilder`.
+
+- [ ] **Step 1: Read the current README**
+
+Run: `cat src/implementations/http/README.md`
+Reference structure (sections to keep, sections to drop, sections to rewrite).
+
+- [ ] **Step 2: Rewrite the README**
+
+Replace the file's content with the structure below. The sections "Procedure Types," "Path Generation," "Context Resolution," "Abort Signal," "Error Handling," "Lifecycle Hooks," "Route Documentation," "DocRegistry," and "Client Code Generation" stay (with internal references updated). The sections "Available Implementations" and "Builder Pattern" (which currently enumerate three builders) collapse into one "HonoAppBuilder" section. The "One Hono Server, Multiple Builders" reference at the bottom is removed.
+
+The Hono section's example should mirror the spec's Public API code block.
+
+Update the table at the bottom mapping kind → params source → generated callable so it lists all four kinds (rpc, rpc-stream, http, http-stream) under HonoAppBuilder.
+
+- [ ] **Step 3: Run docs-consistency check (if it exists)**
+
+Run: `npm run check-docs`
+Expected: PASS — or note any issues for follow-up.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/implementations/http/README.md
+git commit -m "docs(http): rewrite README around HonoAppBuilder
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 25: Update `docs/http-integrations.md`
+
+**Files:**
+- Modify: `docs/http-integrations.md`
+
+- [ ] **Step 1: Inspect the current doc**
+
+Run: `head -200 docs/http-integrations.md` and `grep -nE "Hono(RPC|API|Stream)AppBuilder|One Hono Server" docs/http-integrations.md`
+
+- [ ] **Step 2: Rewrite the doc**
+
+- Replace every `HonoRPCAppBuilder`, `HonoAPIAppBuilder`, `HonoStreamAppBuilder` reference with `HonoAppBuilder`.
+- Rewrite all example code to use the unified builder + stratified config.
+- Delete the section `## One Hono Server, Multiple Builders` entirely (it's no longer relevant).
+- Update the error-handling section: keep the spec narrative (declarative + imperative peers, observer); update the "Hono-stream coverage: pre-stream path only" note to reflect that mid-stream errors now also dispatch through the taxonomy in http-stream (not just rpc-stream).
+
+- [ ] **Step 3: Run docs-consistency check**
+
+Run: `npm run check-docs`
+Expected: PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add docs/http-integrations.md
+git commit -m "docs: rewrite http-integrations around HonoAppBuilder
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+### Task 26: Update agent_config templates and skills
+
+**Files:**
+- Delete: `agent_config/claude-code/skills/ts-procedures-scaffold/templates/hono-rpc.ts`
+- Delete: `agent_config/claude-code/skills/ts-procedures-scaffold/templates/hono-stream.ts`
+- Modify (rename): `agent_config/claude-code/skills/ts-procedures-scaffold/templates/hono-api.ts` → `hono.ts`
+- Modify: `agent_config/claude-code/skills/ts-procedures-scaffold/SKILL.md`
+- Modify: `agent_config/claude-code/skills/ts-procedures/SKILL.md`
+- Modify: `agent_config/claude-code/skills/ts-procedures/patterns.md`
+- Modify: `agent_config/claude-code/skills/ts-procedures/anti-patterns.md`
+- Modify: `agent_config/claude-code/skills/ts-procedures/api-reference.md`
+- Modify: `agent_config/copilot/copilot-instructions.md`
+- Modify: `agent_config/cursor/cursorrules`
+
+- [ ] **Step 1: Inspect existing templates and skills**
+
+```bash
+ls agent_config/claude-code/skills/ts-procedures-scaffold/templates/
+grep -lE "Hono(RPC|API|Stream)AppBuilder" agent_config/
+```
+
+- [ ] **Step 2: Replace the templates**
+
+Delete `hono-rpc.ts` and `hono-stream.ts`. Rename `hono-api.ts` to `hono.ts` and rewrite it to demonstrate one builder serving all four kinds — pattern from the spec's Public API block. Keep the `Procedures<Ctx>()` factory + `Create`/`CreateStream`/`CreateHttp`/`CreateHttpStream` examples + a single `new HonoAppBuilder(...)` registration.
+
+- [ ] **Step 3: Update skill docs**
+
+In each of the listed skill / instruction files, replace every reference to `HonoRPCAppBuilder` / `HonoAPIAppBuilder` / `HonoStreamAppBuilder` with `HonoAppBuilder`, and rewrite any code examples to use the stratified config shape. Remove any "use this builder for this kind" stratification — replace with a "which procedure kind to use" decision tree.
+
+- [ ] **Step 4: Verify scaffolding still works**
+
+Run: `node ./agent_config/bin/setup.mjs --dry-run`
+Expected: PASS — dry run reports the new file structure with no missing template references.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add agent_config/
+git commit -m "$(cat <<'EOF'
+docs(agent_config): consolidate hono templates around HonoAppBuilder
+
+Delete hono-rpc.ts and hono-stream.ts templates; rename hono-api.ts to
+hono.ts and rewrite around one builder serving all four kinds. Update
+skills, patterns, copilot instructions, and cursor rules to match.
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
+EOF
+)"
+```
+
+---
+
+### Task 27: Update `CLAUDE.md` and `README.md`
+
+**Files:**
+- Modify: `CLAUDE.md`
+- Modify: `README.md`
+
+- [ ] **Step 1: Update `CLAUDE.md`**
+
+In the "Key Files" section (around the `src/implementations/http/` entries), replace the three separate hono builder lines with a single line:
+
+```
+- `src/implementations/http/hono/` - Unified Hono builder (`HonoAppBuilder`) — dispatches all four procedure kinds from one register() call. Subpath: `ts-procedures/hono`.
+- `src/implementations/http/error-dispatch.ts` - Shared dispatchPreStreamError + dispatchMidStreamError helpers used by HonoAppBuilder.
+```
+
+In the "Builder Pattern" section, update text to describe one builder; remove the "Single Hono server across builders" callout (now built-in).
+
+In the "Generated client code" sections, update any references to old builder names.
+
+- [ ] **Step 2: Update `README.md`**
+
+Find the v8 changelog/migration section and add an entry summarizing the convergence:
+
+```
+### Hono builders converged into HonoAppBuilder (v8)
+
+The three Hono builders — `HonoRPCAppBuilder`, `HonoAPIAppBuilder`,
+`HonoStreamAppBuilder` — are replaced by a single `HonoAppBuilder` that
+accepts any `Procedures<>()` factory and dispatches all four procedure
+kinds (`rpc`, `rpc-stream`, `http`, `http-stream`) from one
+registration call.
+
+Migration:
+- `import { HonoAppBuilder } from 'ts-procedures/hono'`
+- Wrap kind-specific knobs in stratified blocks: `rpc.onSuccess`,
+  `api.queryParser`, `api.onSuccess`, `stream.defaultStreamMode`,
+  `stream.onMidStreamError`, `stream.onStreamStart`, `stream.onStreamEnd`.
+- Single-app users can call `builder.toDocEnvelope()` instead of going
+  through `DocRegistry`. Multi-app users keep using `DocRegistry`.
+```
+
+- [ ] **Step 3: Verify check-docs**
+
+Run: `npm run check-docs`
+Expected: PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add CLAUDE.md README.md
+git commit -m "docs: update CLAUDE.md and README.md for HonoAppBuilder convergence
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>"
+```
+
+---
+
+## Phase 9 — Final Verification
+
+### Task 28: Codegen end-to-end + full suite
+
+**Files:** none — verification only
+
+- [ ] **Step 1: Run full test suite, lint, build**
+
+```bash
+npm run test
+npm run lint
+npm run build
+```
+
+Expected: all PASS.
+
+- [ ] **Step 2: Verify codegen against the new builder**
+
+The codegen e2e fixtures consume `DocEnvelope` JSON. Build a small inline harness that:
+1. Sets up a `HonoAppBuilder` with one factory containing all four kinds.
+2. Calls `builder.toDocEnvelope({ basePath: '/api' })`.
+3. Passes the envelope to `generateClient({ envelope, outDir, dryRun: true, target: 'ts' })`.
+4. Asserts the dry-run output includes scope files for each kind.
+
+If a similar test already exists in `src/codegen/`, run it: `npx vitest run src/codegen/` and confirm all green.
+
+- [ ] **Step 3: Build typecheck of generated output (optional sanity check)**
+
+If the existing codegen e2e test (e.g., `src/codegen/e2e-compile.test.ts`) compiles generated TypeScript via `tsc`, run it and confirm green. This validates that the new builder's `toDocEnvelope()` produces a codegen-compatible envelope.
+
+```bash
+grep -lE "e2e|compile" src/codegen/*.test.ts
+```
+
+If found: `npx vitest run <path>` and confirm pass.
+
+- [ ] **Step 4: Final smoke summary**
+
+Verify the work is complete by checking:
+- `src/implementations/http/hono-rpc/`, `hono-api/`, `hono-stream/` no longer exist
+- `src/implementations/http/hono/` exists with the layout from the File Structure section
+- `src/implementations/http/error-dispatch.ts` exists with both dispatchers
+- `package.json#exports` has `./hono` and lacks `./hono-rpc`, `./hono-api`, `./hono-stream`
+- `npm run test` passes
+- `npm run lint` passes
+- `npm run build` passes
+- `npm run check-docs` passes (if available)
+- `grep -rEn "Hono(RPC|API|Stream)AppBuilder" src/ docs/ agent_config/ CLAUDE.md README.md` returns zero hits in non-build files
+
+If all eight checks pass, the convergence is complete.
+
+- [ ] **Step 5: Optional — final summary commit (only if there are stray artifacts)**
+
+If the verification surfaced any small fixes (typo, leftover reference), commit them in a single `chore(convergence): final cleanup` commit. Otherwise, no commit needed for verification.
+
+---
+
+## Self-Review Notes
+
+**Spec coverage check (run before submitting):**
+
+| Spec section | Plan task(s) |
+|---|---|
+| Public API surface (HonoAppBuilder, register, build, docs, toDocEnvelope) | Tasks 13–14 |
+| Stratified config (rpc, api, stream blocks) | Tasks 8, 13 |
+| Internal architecture (handler/doc layout) | Tasks 4–12 |
+| Shared error-dispatch | Tasks 2–3 |
+| Lazy doc computation | Task 13 |
+| Mixed-kind factories work natively | Task 14 (mixed-kind dispatch test) |
+| `pathPrefix` global | Task 1 (path test cases) |
+| `extendProcedureDoc` discriminated union | Task 8 (types), Task 19 (port test) |
+| Per-factory `streamMode` override | Task 21 (stream test cases) |
+| `AbortSignal` injection preserved | Task 9 (rpc test) — applies to all handlers |
+| `event: 'return'` SSE return value | Tasks 11, 12 (stream + http-stream tests) |
+| `isPrevalidated` short-circuit | Task 11 (stream handler) |
+| `skippedProcedures` near-empty after convergence | Task 13 + Task 19 (retargeted test) |
+| Tests consolidated under `hono/` | Tasks 19–21 |
+| Templates/docs/CLAUDE.md/README.md updated | Tasks 24–27 |
+| Codegen e2e verification | Task 28 |
+
+No placeholders, no TBDs. Code blocks are concrete. Each task ends in a commit.