ts-procedures 8.5.0 → 9.0.0

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) {

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

@@ -1,11 +1,14 @@
 import type { Context, Hono } from 'hono'
-import type { ErrorTaxonomy, UnknownErrorConfig } from '../error-taxonomy.js'
+import type { ErrorTaxonomy, UnknownErrorConfig } from '../../server/errors/taxonomy.js'
 import type {
-  AnyProcedureRegistration,
   OnRequestErrorObserver,
   OnMidStreamError,
   PreStreamOnError,
-} from '../error-dispatch.js'
+  PreStreamErrorConfig,
+  MidStreamErrorConfig,
+} from '../../server/errors/dispatch.js'
+import type { QueryParser } from '../../server/request/query.js'
+import type { FactoryContextInit } from '../../server/context.js'
 import type {
   ProceduresFactory,
   ExtractContext,
@@ -15,35 +18,31 @@ import type {
   APIHttpRouteDoc,
   StreamHttpRouteDoc,
   HttpStreamRouteDoc,
-} from '../../types.js'
+} from '../../server/types.js'
 import type {
+  AnyProcedureRegistration,
   TProcedureRegistration,
   TStreamProcedureRegistration,
   THttpProcedureRegistration,
   THttpStreamProcedureRegistration,
-} from '../../../types.js'
-
-export type { AnyProcedureRegistration } from '../error-dispatch.js'
+} from '../../core/types.js'
 
-/** Default query parser using URLSearchParams. */
-export type QueryParser = (queryString: string) => Record<string, unknown>
+export type { QueryParser } from '../../server/request/query.js'
 
 export type OnRequestErrorContext = {
   err: unknown
-  procedure: AnyProcedureRegistration
+  procedure: AnyProcedureRegistration<any, any>
   raw: Context
 }
 
 export type ExtendProcedureDoc = (params: {
   base: RPCHttpRouteDoc | APIHttpRouteDoc | StreamHttpRouteDoc | HttpStreamRouteDoc
-  procedure: AnyProcedureRegistration
+  procedure: AnyProcedureRegistration<any, any>
 }) => Record<string, unknown>
 
 export type HonoFactoryItem<TFactory extends ProceduresFactory = ProceduresFactory> = {
   factory: TFactory
-  factoryContext:
-    | ExtractContext<TFactory>
-    | ((c: Context) => ExtractContext<TFactory> | Promise<ExtractContext<TFactory>>)
+  factoryContext: FactoryContextInit<ExtractContext<TFactory>, Context>
   streamMode?: StreamMode
   extendProcedureDoc?: ExtendProcedureDoc
 }
@@ -57,9 +56,9 @@ export type HonoAppBuilderConfig<TStreamErrorData = unknown> = {
   // Error handling — peers
   errors?: ErrorTaxonomy
   unknownError?: UnknownErrorConfig
-  onError?: PreStreamOnError
+  onError?: PreStreamOnError<Context, Response>
   /** Cross-cutting observer — fires for every caught error before dispatch. */
-  onRequestError?: OnRequestErrorObserver
+  onRequestError?: OnRequestErrorObserver<Context>
 
   // Lifecycle (every kind)
   onRequestStart?: (c: Context) => void
@@ -67,7 +66,7 @@ export type HonoAppBuilderConfig<TStreamErrorData = unknown> = {
 
   // Kind-specific blocks
   rpc?: {
-    onSuccess?: (procedure: TProcedureRegistration, c: Context) => void
+    onSuccess?: (procedure: TProcedureRegistration<any, any>, c: Context) => void
   }
   api?: {
     queryParser?: QueryParser
@@ -77,17 +76,41 @@ export type HonoAppBuilderConfig<TStreamErrorData = unknown> = {
     /** Default for both rpc-stream and http-stream. */
     defaultStreamMode?: StreamMode
     onStreamStart?: (
-      procedure: TStreamProcedureRegistration | THttpStreamProcedureRegistration<any>,
+      procedure: TStreamProcedureRegistration<any, any> | THttpStreamProcedureRegistration<any>,
       c: Context,
       streamMode: StreamMode,
     ) => void
     onStreamEnd?: (
-      procedure: TStreamProcedureRegistration | THttpStreamProcedureRegistration<any>,
+      procedure: TStreamProcedureRegistration<any, any> | THttpStreamProcedureRegistration<any>,
       c: Context,
       streamMode: StreamMode,
     ) => void
-    onMidStreamError?: OnMidStreamError<TStreamErrorData>
+    onMidStreamError?: OnMidStreamError<TStreamErrorData, Context>
   }
 }
 
 export type DocAccumulator = AnyHttpRouteDoc[]
+
+/** The pre-stream slice of the builder config, passed to dispatch. */
+export function preStreamErrorConfig(
+  cfg: HonoAppBuilderConfig<any>,
+): PreStreamErrorConfig<Context, Response> {
+  return {
+    errors: cfg.errors,
+    unknownError: cfg.unknownError,
+    onError: cfg.onError,
+    onRequestError: cfg.onRequestError,
+  }
+}
+
+/** The mid-stream slice of the builder config, passed to dispatch. */
+export function midStreamErrorConfig<TStreamErrorData>(
+  cfg: HonoAppBuilderConfig<TStreamErrorData>,
+): MidStreamErrorConfig<TStreamErrorData, Context> {
+  return {
+    errors: cfg.errors,
+    unknownError: cfg.unknownError,
+    onMidStreamError: cfg.stream?.onMidStreamError,
+    onRequestError: cfg.onRequestError,
+  }
+}

package/src/client/freeze.test.ts

@@ -0,0 +1,41 @@
+import { createHash } from 'node:crypto'
+import { readFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+
+/**
+ * The client runtime is CONTENT-FROZEN for v9.
+ *
+ * Self-contained codegen (the default) bundles these source files verbatim
+ * (imports stripped) into the generated `_client.ts` / `_types.ts`. The v9
+ * hard requirement is byte-identical generated output vs v8.6.0, so these
+ * files must not change. If you intentionally change one, you are changing
+ * generated output for every downstream app: re-capture the codegen goldens,
+ * verify the diff is wanted, and update the hash here.
+ *
+ * Hashes recorded from v8.6.0 `src/client/*.ts`.
+ */
+const FROZEN_FILES: ReadonlyArray<readonly [file: string, sha256: string]> = [
+  ['errors.ts', 'abcdee64e22e748d870efdac68f03a05cd0666c65ec3f3b5217acd9c22f72a4d'],
+  ['classify-error.ts', '28062fdc3be39461eeec4cc96e3edcf46377922bac6fb3cc7b54111b42199773'],
+  ['error-dispatch.ts', '1bdd89319239e8aca0f186714c15b77ae5f4a9ac2c257416ddaf36d965dbe141'],
+  ['request-builder.ts', 'ac15485e6786de00386e6c4a425dbab503589bc012af6ef6515b1c3e4176a51e'],
+  ['resolve-options.ts', 'a0e6d745a630176696c0221f5166958bfc5255e50168e5f3cf021bbf4a8aaffc'],
+  ['hooks.ts', '15d67ba827dbb6e38407af606c05a459ec27e3b1e738aac868233d0f10478aa7'],
+  ['call.ts', 'b7afeadb3b338cb45ab09273a1729c25ea0f6429670664d197d91ee47cc0a3dc'],
+  ['stream.ts', '655af96f789150e3fedb7b345aae70d58b1d3b3cad9eb8b341d5a4780d5760ce'],
+  ['fetch-adapter.ts', 'c5a6ebdeecac3a5efc3d77f346135609e23c5eebc671a08456175901106655a2'],
+  ['index.ts', '8e33080aba85ba9af52f8b7232c01c82fae167742facb250f5d6800d51544d65'],
+  ['types.ts', 'e236213020290fd187a80cdf060fcb3d67e734e94aa060c736f142cbefd4ced7'],
+]
+
+const clientDir = dirname(fileURLToPath(import.meta.url))
+
+describe('client runtime freeze (codegen bundling contract)', () => {
+  it.each(FROZEN_FILES)('%s matches its v8.6.0 content hash', async (file, expected) => {
+    const content = await readFile(resolve(clientDir, file), 'utf-8')
+    const actual = createHash('sha256').update(content).digest('hex')
+    expect(actual, `${file} diverged from the frozen v8.6.0 content — this changes generated _client.ts/_types.ts output`).toBe(expected)
+  })
+})