ts-procedures 8.6.0 → 9.1.0

package/src/adapters/hono/handlers/http-stream.ts

@@ -0,0 +1,73 @@
+import type { Context, Hono } from 'hono'
+import { streamSSE } from 'hono/streaming'
+import type { THttpStreamProcedureRegistration } from '../../../core/types.js'
+import { dispatchMidStreamError, dispatchPreStreamError } from '../../../server/errors/dispatch.js'
+import { buildHttpStreamRouteDoc } from '../../../server/docs/http-stream-doc.js'
+import { resolveFactoryContext } from '../../../server/context.js'
+import { extractReqChannels } from '../../../server/request/params.js'
+import { parseQueryNative } from '../../../server/request/query.js'
+import { SseEventSequencer } from '../../../server/sse.js'
+import { honoRequestSource, respondToDispatch } from '../request.js'
+import { midStreamErrorConfig, preStreamErrorConfig } from '../types.js'
+import type { DocAccumulator, HonoAppBuilderConfig, HonoFactoryItem } from '../types.js'
+
+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 = await resolveFactoryContext(factoryItem.factoryContext, c)
+
+      const reqParams = reqSchema
+        ? await extractReqChannels(honoRequestSource(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) => {
+        const events = new SseEventSequencer((e) => stream.writeSSE(e), procedure.name)
+        try {
+          await events.pump(gen)
+        } catch (error) {
+          const dispatched = await dispatchMidStreamError({
+            err: error,
+            procedure,
+            raw: c,
+            cfg: midStreamErrorConfig(cfg),
+          })
+          await events.writeError(dispatched)
+          if (dispatched.runOnCatch) await dispatched.runOnCatch()
+        } finally {
+          cfg.stream?.onStreamEnd?.(procedure, c, 'sse')
+          cfg.onRequestEnd?.(c)
+        }
+      })
+    } catch (error) {
+      return respondToDispatch(
+        c,
+        await dispatchPreStreamError({ err: error, procedure, raw: c, cfg: preStreamErrorConfig(cfg) }),
+      )
+    }
+  })
+}

package/src/{implementations/http → adapters}/hono/handlers/http.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test, vi } from 'vitest'
 import { Hono } from 'hono'
 import { Type } from 'typebox'
-import { Procedures } from '../../../../index.js'
+import { Procedures } from '../../../core/procedures.js'
 import { installHttpRoute } from './http.js'
 
 function buildApp(setup: (P: ReturnType<typeof Procedures<{ uid: string }>>) => void, cfg: any = {}) {

package/src/adapters/hono/handlers/http.ts

@@ -0,0 +1,70 @@
+import type { Context, Hono } from 'hono'
+import type { THttpProcedureRegistration } from '../../../core/types.js'
+import { dispatchPreStreamError } from '../../../server/errors/dispatch.js'
+import { buildHttpRouteDoc } from '../../../server/docs/http-doc.js'
+import { resolveFactoryContext } from '../../../server/context.js'
+import { defaultSuccessStatus, extractReqChannels } from '../../../server/request/params.js'
+import { parseQueryNative } from '../../../server/request/query.js'
+import { honoRequestSource, respondToDispatch } from '../request.js'
+import { preStreamErrorConfig } from '../types.js'
+import type { DocAccumulator, HonoAppBuilderConfig, HonoFactoryItem } from '../types.js'
+
+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 = await resolveFactoryContext(factoryItem.factoryContext, c)
+
+      const reqParams = reqSchema
+        ? await extractReqChannels(honoRequestSource(c), procedure.config.method, reqSchema, queryParser)
+        : undefined
+
+      const result = await procedure.handler({ ...context, signal: c.req.raw.signal }, reqParams)
+
+      cfg.api?.onSuccess?.(procedure, c)
+
+      // The `{ body, headers }` envelope is OPT-IN via `schema.res.headers`: when
+      // the route declares response headers, the handler returns `{ body, headers }`;
+      // otherwise its return value IS the body. Gating on the schema (rather than
+      // duck-typing the result for a `body`/`headers` key) lets a domain object
+      // safely carry its own `body`/`headers` field without being unwrapped.
+      const hasResHeaders = procedure.config.schema?.res?.headers != null
+      const { body, headers } = hasResHeaders
+        ? ((result ?? {}) as { body?: unknown; headers?: unknown })
+        : { body: result, headers: undefined }
+
+      if (headers && typeof headers === 'object') {
+        for (const [k, v] of Object.entries(headers as Record<string, string>)) c.header(k, v)
+      }
+
+      // No body to send — a 204 status, or an `undefined` return (a `void`
+      // handler, or a headers-only `res: { headers }` envelope). Emit a clean
+      // bodyless response instead of `c.json(undefined)`, which would send an
+      // empty, unparseable body under an `application/json` content-type.
+      if (successStatus === 204 || body === undefined) {
+        return c.body(null, successStatus as any)
+      }
+
+      return c.json(body, successStatus as any)
+    } catch (error) {
+      return respondToDispatch(
+        c,
+        await dispatchPreStreamError({ err: error, procedure, raw: c, cfg: preStreamErrorConfig(cfg) }),
+      )
+    }
+  })
+}

package/src/{implementations/http → adapters}/hono/handlers/rpc.test.ts

@@ -1,8 +1,8 @@
 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 { Procedures } from '../../../core/procedures.js'
+import type { RPCConfig } from '../../../server/types.js'
 import { installRpcRoute } from './rpc.js'
 
 function buildApp(register: (factory: ReturnType<typeof Procedures<{ userId: string }, RPCConfig>>) => void, cfg: any = {}) {

package/src/adapters/hono/handlers/rpc.ts

@@ -0,0 +1,39 @@
+import type { Context, Hono } from 'hono'
+import type { TProcedureRegistration } from '../../../core/types.js'
+import type { RPCConfig } from '../../../server/types.js'
+import { dispatchPreStreamError } from '../../../server/errors/dispatch.js'
+import { buildRpcRouteDoc } from '../../../server/docs/rpc-doc.js'
+import { resolveFactoryContext } from '../../../server/context.js'
+import { respondToDispatch } from '../request.js'
+import { preStreamErrorConfig } from '../types.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 = await resolveFactoryContext(factoryItem.factoryContext, c)
+      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 respondToDispatch(
+        c,
+        await dispatchPreStreamError({ err: error, procedure, raw: c, cfg: preStreamErrorConfig(cfg) }),
+      )
+    }
+  })
+}

package/src/{implementations/http → adapters}/hono/handlers/stream.test.ts

@@ -1,9 +1,10 @@
 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, sse } from './stream.js'
+import { Procedures } from '../../../core/procedures.js'
+import type { RPCConfig } from '../../../server/types.js'
+import { sse } from '../../../server/sse.js'
+import { installRpcStreamRoute } from './stream.js'
 
 function buildApp(setup: (P: ReturnType<typeof Procedures<{ uid: string }, RPCConfig>>) => void, cfg: any = {}) {
   const P = Procedures<{ uid: string }, RPCConfig>()

package/src/{implementations/http → adapters}/hono/handlers/stream.ts

@@ -1,38 +1,16 @@
 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 { TStreamProcedureRegistration } from '../../../core/types.js'
+import type { RPCConfig, StreamMode } from '../../../server/types.js'
+import { ProcedureValidationError } from '../../../core/errors.js'
+import { dispatchMidStreamError, dispatchPreStreamError } from '../../../server/errors/dispatch.js'
+import { buildStreamRouteDoc } from '../../../server/docs/stream-doc.js'
+import { resolveFactoryContext } from '../../../server/context.js'
+import { SseEventSequencer } from '../../../server/sse.js'
+import { respondToDispatch } from '../request.js'
+import { midStreamErrorConfig, preStreamErrorConfig } from '../types.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 type { MidStreamErrorResult } from '../../error-dispatch.js'
-
 export function installRpcStreamRoute(params: {
   app: Hono
   procedure: TStreamProcedureRegistration<any, RPCConfig>
@@ -53,10 +31,7 @@ export function installRpcStreamRoute(params: {
 
   const handler = async (c: Context) => {
     try {
-      const context =
-        typeof factoryItem.factoryContext === 'function'
-          ? await (factoryItem.factoryContext as (c: Context) => any)(c)
-          : factoryItem.factoryContext
+      const context = await resolveFactoryContext(factoryItem.factoryContext, c)
 
       const reqParams =
         c.req.method === 'GET'
@@ -81,17 +56,10 @@ export function installRpcStreamRoute(params: {
         ? 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,
-        },
-      })
+      return respondToDispatch(
+        c,
+        await dispatchPreStreamError({ err: error, procedure, raw: c, cfg: preStreamErrorConfig(cfg) }),
+      )
     }
   }
 
@@ -113,53 +81,17 @@ function handleSSE(
     )
     stream.onAbort(async () => { await generator.return(undefined) })
 
-    let eventId = 0
+    const events = new SseEventSequencer((e) => stream.writeSSE(e), procedure.name)
     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++) })
-      }
+      await events.pump(generator[Symbol.asyncIterator]())
     } 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,
-        },
+        cfg: midStreamErrorConfig(cfg),
       })
-
-      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 ?? String(eventId++),
-        ...(meta?.retry !== undefined && { retry: meta.retry }),
-      })
-
+      await events.writeError(dispatched)
       if (dispatched.runOnCatch) await dispatched.runOnCatch()
     } finally {
       cfg.stream?.onStreamEnd?.(procedure, c, 'sse')
@@ -191,12 +123,7 @@ function handleText(
         err: error,
         procedure,
         raw: c,
-        cfg: {
-          errors: cfg.errors,
-          unknownError: cfg.unknownError,
-          onMidStreamError: cfg.stream?.onMidStreamError,
-          onRequestError: cfg.onRequestError,
-        },
+        cfg: midStreamErrorConfig(cfg),
       })
       await stream.writeln(JSON.stringify(dispatched.data))
       if (dispatched.runOnCatch) await dispatched.runOnCatch()

package/src/{implementations/http → adapters}/hono/index.test.ts

@@ -1,11 +1,9 @@
 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 { HonoAppBuilder } from './index.js'
-import { defineErrorTaxonomy } from '../error-taxonomy.js'
-import { DocRegistry } from '../doc-registry.js'
+import { Procedures } from '../../core/procedures.js'
+import type { RPCConfig } from '../../server/types.js'
+import { HonoAppBuilder, defineErrorTaxonomy, DocRegistry } from './index.js'
 
 describe('HonoAppBuilder — public surface', () => {
   test('constructor with no args', () => {
@@ -23,14 +21,14 @@ describe('HonoAppBuilder — public surface', () => {
 
   test('register is chainable', () => {
     const b = new HonoAppBuilder()
-    const P = Procedures<{}, RPCConfig>()
+    const P = Procedures<object, 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>()
+    const P = Procedures<object, RPCConfig>()
     P.Create('A', { scope: 's', version: 1 }, async () => ({}))
     b.register(P, () => ({}))
 
@@ -43,7 +41,7 @@ describe('HonoAppBuilder — public surface', () => {
 
   test('docs reads after build() return the same content', () => {
     const b = new HonoAppBuilder()
-    const P = Procedures<{}, RPCConfig>()
+    const P = Procedures<object, RPCConfig>()
     P.Create('A', { scope: 's', version: 1 }, async () => ({}))
     b.register(P, () => ({}))
     b.build()
@@ -89,7 +87,7 @@ describe('HonoAppBuilder — mixed-kind dispatch', () => {
   })
 
   test('toDocEnvelope produces same shape as DocRegistry.toJSON', () => {
-    const P = Procedures<{}, RPCConfig>()
+    const P = Procedures<object, RPCConfig>()
     P.Create('Echo', { scope: 'e', version: 1 }, async () => ({}))
 
     const errors = defineErrorTaxonomy({})
@@ -106,7 +104,7 @@ describe('HonoAppBuilder — mixed-kind dispatch', () => {
   })
 
   test('toDocEnvelope filter and transform options work', () => {
-    const P = Procedures<{}, RPCConfig>()
+    const P = Procedures<object, RPCConfig>()
     P.Create('A', { scope: 's', version: 1 }, async () => ({}))
     P.Create('B', { scope: 's', version: 1 }, async () => ({}))
 
@@ -122,7 +120,7 @@ describe('HonoAppBuilder — mixed-kind dispatch', () => {
   })
 
   test('makeRoutePath static is exposed', () => {
-    const P = Procedures<{}, RPCConfig>()
+    const P = Procedures<object, RPCConfig>()
     P.Create('GetUser', { scope: 'users', version: 1 }, async () => ({}))
     const proc = P.getProcedure('GetUser')!
     expect(HonoAppBuilder.makeRoutePath({ procedure: proc as any })).toBe('/users/get-user/1')
@@ -219,7 +217,7 @@ describe('HonoAppBuilder — extendProcedureDoc discriminated union per kind', (
       summary: `RPC: ${base.kind}`,
       tags: ['rpc'],
     }))
-    const P = Procedures<{}, RPCConfig>()
+    const P = Procedures<object, RPCConfig>()
     P.Create('GetUser', { scope: 'users', version: 1 }, async () => ({}))
 
     const builder = new HonoAppBuilder().register(P, () => ({}), { extendProcedureDoc: extend })
@@ -237,7 +235,7 @@ describe('HonoAppBuilder — extendProcedureDoc discriminated union per kind', (
       summary: `API: ${base.kind}`,
       tags: ['api'],
     }))
-    const P = Procedures<{}>()
+    const P = Procedures<object>()
     P.CreateHttp(
       'GetUser',
       {
@@ -266,7 +264,7 @@ describe('HonoAppBuilder — extendProcedureDoc discriminated union per kind', (
       summary: `Stream: ${base.kind}`,
       tags: ['stream'],
     }))
-    const P = Procedures<{}, RPCConfig>()
+    const P = Procedures<object, RPCConfig>()
     P.CreateStream('Tail', { scope: 'rpc', version: 1 }, async function* () {
       yield 1
     })
@@ -286,7 +284,7 @@ describe('HonoAppBuilder — extendProcedureDoc discriminated union per kind', (
       summary: `HTTP-Stream: ${base.kind}`,
       tags: ['http-stream'],
     }))
-    const P = Procedures<{}>()
+    const P = Procedures<object>()
     P.CreateHttpStream(
       'Watch',
       { path: '/watch', method: 'get', schema: { yield: Type.String() } },
@@ -308,7 +306,7 @@ describe('HonoAppBuilder — extendProcedureDoc discriminated union per kind', (
 
 describe('HonoAppBuilder — per-factory streamMode override', () => {
   test('register options.streamMode overrides stream.defaultStreamMode', async () => {
-    const P = Procedures<{}, RPCConfig>()
+    const P = Procedures<object, RPCConfig>()
     P.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
       yield { ok: true }
     })

package/src/{implementations/http → adapters}/hono/index.ts

@@ -1,4 +1,3 @@
-import type { Context} from 'hono';
 import { Hono } from 'hono'
 import type {
   AnyHttpRouteDoc,
@@ -8,34 +7,42 @@ import type {
   DocEnvelope,
   ErrorDoc,
   HeaderDoc,
-} from '../../types.js'
-import { DocRegistry } from '../doc-registry.js'
-import type { ErrorTaxonomy } from '../error-taxonomy.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'
+} from '../../server/types.js'
+import type { AnyProcedureRegistration } from '../../core/types.js'
+import { DocRegistry } from '../../server/doc-registry.js'
+import type { ErrorTaxonomy } from '../../server/errors/taxonomy.js'
+import type { FactoryContextInit } from '../../server/context.js'
+import { buildRpcRouteDoc } from '../../server/docs/rpc-doc.js'
+import { buildStreamRouteDoc } from '../../server/docs/stream-doc.js'
+import { buildHttpRouteDoc } from '../../server/docs/http-doc.js'
+import { buildHttpStreamRouteDoc } from '../../server/docs/http-stream-doc.js'
+import { makeRoutePath as _makeRoutePath } from '../../server/paths.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'
-
+import type { Context } from 'hono'
+import type { HonoAppBuilderConfig, HonoFactoryItem, ExtendProcedureDoc } from './types.js'
+
+export type { HonoAppBuilderConfig, ExtendProcedureDoc, QueryParser } from './types.js'
+export type { OnRequestErrorContext } from './types.js'
+export { sse } from '../../server/sse.js'
+export type { SSEOptions } from '../../server/sse.js'
+export type { MidStreamErrorResult } from '../../server/errors/dispatch.js'
+export { defineErrorTaxonomy } from '../../server/errors/taxonomy.js'
+export type { ErrorTaxonomy, ErrorTaxonomyEntry, UnknownErrorConfig } from '../../server/errors/taxonomy.js'
+export { DocRegistry } from '../../server/doc-registry.js'
+
+/**
+ * Serves every procedure kind (`rpc`, `rpc-stream`, `http`, `http-stream`)
+ * from registered factories on a single Hono app.
+ *
+ * This adapter is deliberately thin: route docs, error taxonomy dispatch,
+ * request channel extraction, and SSE semantics all live in the
+ * transport-agnostic `ts-procedures/server` layer; the handlers here only
+ * translate between Hono's request/response/streaming primitives and that
+ * layer. Use it as the blueprint for adapters to other frameworks.
+ */
 export class HonoAppBuilder<TStreamErrorData = unknown> {
   private readonly _app: Hono
   private readonly factories: HonoFactoryItem<any>[] = []
@@ -81,9 +88,7 @@ export class HonoAppBuilder<TStreamErrorData = unknown> {
 
   register<TFactory extends ProceduresFactory>(
     factory: TFactory,
-    factoryContext:
-      | ExtractContext<TFactory>
-      | ((c: Context) => ExtractContext<TFactory> | Promise<ExtractContext<TFactory>>),
+    factoryContext: FactoryContextInit<ExtractContext<TFactory>, Context>,
     options?: {
       streamMode?: StreamMode
       extendProcedureDoc?: ExtendProcedureDoc
@@ -105,7 +110,7 @@ export class HonoAppBuilder<TStreamErrorData = unknown> {
     const skipped: { name: string; reason: string }[] = []
 
     for (const item of this.factories) {
-      for (const procedure of item.factory.getProcedures().values() as Iterable<AnyProcedureRegistration>) {
+      for (const procedure of item.factory.getProcedures().values() as Iterable<AnyProcedureRegistration<any, any>>) {
         const prefix = this.config?.pathPrefix
         switch (procedure.kind) {
           case 'rpc':
@@ -150,7 +155,7 @@ export class HonoAppBuilder<TStreamErrorData = unknown> {
     const cfg = this.config ?? {}
 
     for (const item of this.factories) {
-      for (const procedure of item.factory.getProcedures().values() as Iterable<AnyProcedureRegistration>) {
+      for (const procedure of item.factory.getProcedures().values() as Iterable<AnyProcedureRegistration<any, any>>) {
         switch (procedure.kind) {
           case 'rpc':
             installRpcRoute({ app: this._app, procedure: procedure as any, factoryItem: item, cfg, docs })

package/src/{implementations/http → adapters/hono}/on-request-error.test.ts

@@ -13,9 +13,9 @@
  */
 import { describe, expect, test, vi } from 'vitest'
 import { Type } from 'typebox'
-import { Procedures } from '../../index.js'
-import type { RPCConfig } from '../types.js'
-import { HonoAppBuilder } from './hono/index.js'
+import { Procedures } from '../../core/procedures.js'
+import type { RPCConfig } from '../../server/types.js'
+import { HonoAppBuilder } from './index.js'
 
 describe('onRequestError — HonoAppBuilder (rpc kind)', () => {
   function boomApp(config: ConstructorParameters<typeof HonoAppBuilder>[0]) {

package/src/adapters/hono/request.ts

@@ -0,0 +1,28 @@
+import type { Context } from 'hono'
+import type { RequestSource } from '../../server/request/params.js'
+import type { PreStreamDispatchResult } from '../../server/errors/dispatch.js'
+
+/** Adapts a Hono `Context` to the server layer's {@link RequestSource}. */
+export function honoRequestSource(c: Context): RequestSource {
+  return {
+    pathParams: () => c.req.param(),
+    url: () => c.req.url,
+    json: () => c.req.json(),
+    headers: () => {
+      const obj: Record<string, string> = {}
+      c.req.raw.headers.forEach((v, k) => {
+        obj[k] = v
+      })
+      return obj
+    },
+  }
+}
+
+/** Translates a pre-stream dispatch result into a Hono response. */
+export function respondToDispatch(
+  c: Context,
+  result: PreStreamDispatchResult<Response>,
+): Response {
+  if (result.type === 'response') return result.response
+  return c.json(result.body, result.statusCode as never)
+}

package/src/{implementations/http → adapters/hono}/route-errors.test.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 import { describe, expect, test } from 'vitest'
 import { Type } from 'typebox'
-import { Procedures } from '../../index.js'
-import type { APIConfig, RPCConfig } from '../types.js'
-import { HonoAppBuilder } from './hono/index.js'
-import { DocRegistry } from './doc-registry.js'
-import { defineErrorTaxonomy } from './error-taxonomy.js'
+import { Procedures } from '../../core/procedures.js'
+import type { APIConfig, RPCConfig } from '../../server/types.js'
+import { HonoAppBuilder } from './index.js'
+import { DocRegistry } from '../../server/doc-registry.js'
+import { defineErrorTaxonomy } from '../../server/errors/taxonomy.js'
 
 class UseCaseError extends Error {
   constructor(readonly externalMsg: string) {