ts-procedures 7.3.0 → 8.0.0

package/src/implementations/http/astro/index.test.ts

@@ -5,9 +5,8 @@ import { stripPrefix } from './rewrite-request.js'
 import { setAstroContext, getAstroContext } from './astro-context.js'
 import { createAstroHandler } from './create-handler.js'
 import { Procedures } from '../../../index.js'
-import { HonoAPIAppBuilder } from '../hono-api/index.js'
-import { HonoStreamAppBuilder } from '../hono-stream/index.js'
-import type { APIConfig, RPCConfig } from '../../types.js'
+import { HonoAppBuilder } from '../hono/index.js'
+import type { RPCConfig } from '../../types.js'
 
 // Minimal stand-in for Astro's APIContext for unit tests.
 function fakeApiContext(overrides: Record<string, unknown> = {}) {
@@ -23,15 +22,15 @@ function fakeApiContext(overrides: Record<string, unknown> = {}) {
 }
 
 function buildSimpleUserApi() {
-  const API = Procedures<{ db: Map<string, { id: string; name: string }> }, APIConfig>()
-  API.Create(
+  const API = Procedures<{ db: Map<string, { id: string; name: string }> }>()
+  API.CreateHttp(
     'GetUser',
     {
       path: '/users/:id',
       method: 'get',
       schema: {
-        input: { pathParams: Type.Object({ id: Type.String() }) },
-        returnType: Type.Object({ id: Type.String(), name: Type.String() }),
+        req: { pathParams: Type.Object({ id: Type.String() }) },
+        res: { body: Type.Object({ id: Type.String(), name: Type.String() }) },
       },
     },
     async (ctx, { pathParams }) => {
@@ -41,7 +40,7 @@ function buildSimpleUserApi() {
     }
   )
   const db = new Map([['1', { id: '1', name: 'Ada' }]])
-  return new HonoAPIAppBuilder().register(API, () => ({ db })).build()
+  return new HonoAppBuilder().register(API, () => ({ db })).build()
 }
 
 describe('stripPrefix', () => {
@@ -199,14 +198,18 @@ describe('createAstroHandler — pathPrefix + getAstroContext', () => {
   })
 
   test('factory closure can read APIContext via getAstroContext', async () => {
-    const API = Procedures<{ user: { id: string } | null }, APIConfig>()
-    API.Create(
+    const API = Procedures<{ user: { id: string } | null }>()
+    API.CreateHttp(
       'WhoAmI',
-      { path: '/whoami', method: 'get', schema: { returnType: Type.Object({ userId: Type.Union([Type.String(), Type.Null()]) }) } },
+      {
+        path: '/whoami',
+        method: 'get',
+        schema: { res: { body: Type.Object({ userId: Type.Union([Type.String(), Type.Null()]) }) } },
+      },
       async (ctx) => ({ userId: ctx.user?.id ?? null })
     )
 
-    const app = new HonoAPIAppBuilder()
+    const app = new HonoAppBuilder()
       .register(API, (c) => {
         const astro = getAstroContext(c)
         return { user: (astro.locals as { user?: { id: string } }).user ?? null }
@@ -294,7 +297,7 @@ describe('createAstroHandler — streams', () => {
       }
     )
 
-    const streamApp = new HonoStreamAppBuilder().register(STREAM, () => ({})).build()
+    const streamApp = new HonoAppBuilder().register(STREAM, () => ({})).build()
     const { ALL } = createAstroHandler({ apps: streamApp })
 
     const apiContext = fakeApiContext({
@@ -318,10 +321,14 @@ describe('createAstroHandler — abort signal', () => {
   test("aborting the incoming request aborts the procedure handler's ctx.signal", async () => {
     let observedSignal: AbortSignal | undefined
     const aborted = new Promise<void>((resolve) => {
-      const API = Procedures<{}, APIConfig>()
-      API.Create(
+      const API = Procedures<{}>()
+      API.CreateHttp(
         'Hang',
-        { path: '/hang', method: 'get', schema: { returnType: Type.Object({ ok: Type.Boolean() }) } },
+        {
+          path: '/hang',
+          method: 'get',
+          schema: { res: { body: Type.Object({ ok: Type.Boolean() }) } },
+        },
         async (ctx) => {
           observedSignal = ctx.signal
           ctx.signal?.addEventListener('abort', () => resolve(), { once: true })
@@ -330,7 +337,7 @@ describe('createAstroHandler — abort signal', () => {
           return { ok: true }
         }
       )
-      const app = new HonoAPIAppBuilder().register(API, () => ({})).build()
+      const app = new HonoAppBuilder().register(API, () => ({})).build()
       const { ALL } = createAstroHandler({ apps: app })
 
       const controller = new AbortController()
@@ -340,7 +347,7 @@ describe('createAstroHandler — abort signal', () => {
       })
 
       // Fire ALL but don't await — abort while the handler is still running.
-      ;(ALL(apiContext) as Promise<Response>).catch(() => {})
+      Promise.resolve(ALL(apiContext)).catch(() => {})
       setTimeout(() => controller.abort(), 20)
     })
 

package/src/implementations/http/doc-registry.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it, test, vi, afterEach } from 'vitest'
 import { v } from 'suretype'
+import { Type } from 'typebox'
 import { Procedures } from '../../index.js'
-import { HonoRPCAppBuilder } from './hono-rpc/index.js'
+import { HonoAppBuilder } from './hono/index.js'
 import { DocRegistry } from './doc-registry.js'
 import { defineErrorTaxonomy } from './error-taxonomy.js'
 import type {
@@ -10,6 +11,7 @@ import type {
   RPCConfig,
   APIHttpRouteDoc,
   StreamHttpRouteDoc,
+  HttpStreamRouteDoc,
   DocSource,
   DocEnvelope,
   ErrorDoc,
@@ -35,7 +37,7 @@ const apiDoc: APIHttpRouteDoc = {
   path: '/users/:id',
   method: 'get',
   fullPath: '/api/users/:id',
-  jsonSchema: { pathParams: { type: 'object' } },
+  jsonSchema: { req: { pathParams: { type: 'object' } } },
 }
 
 const streamDoc: StreamHttpRouteDoc = {
@@ -49,6 +51,16 @@ const streamDoc: StreamHttpRouteDoc = {
   jsonSchema: { yieldType: { type: 'object' } },
 }
 
+const httpStreamDoc: HttpStreamRouteDoc = {
+  kind: 'http-stream',
+  name: 'Tail',
+  path: '/streams/logs',
+  method: 'get',
+  fullPath: '/streams/logs',
+  streamMode: 'sse',
+  jsonSchema: { yield: { type: 'object' } },
+}
+
 function makeSource<T extends AnyHttpRouteDoc>(docs: T[]): DocSource<T> {
   return { docs }
 }
@@ -466,8 +478,13 @@ describe('DocRegistry', () => {
       expect(doc.kind).toBe('stream')
     })
 
+    it('httpStreamDoc fixture requires kind field', () => {
+      const doc = httpStreamDoc
+      expect(doc.kind).toBe('http-stream')
+    })
+
     it('narrows AnyHttpRouteDoc union via kind', () => {
-      const routes: AnyHttpRouteDoc[] = [rpcDoc, apiDoc, streamDoc]
+      const routes: AnyHttpRouteDoc[] = [rpcDoc, apiDoc, streamDoc, httpStreamDoc]
       for (const route of routes) {
         expect(route.kind).toBeDefined()
       }
@@ -580,7 +597,27 @@ describe('DocRegistry', () => {
       })
     })
 
-    test('accepts a real HonoRPCAppBuilder as source', () => {
+    it('aggregates http-stream routes from HonoAppBuilder', () => {
+      const procs = Procedures()
+      procs.CreateHttpStream('Tail', {
+        path: '/streams/logs',
+        method: 'get',
+        schema: {
+          req: { query: Type.Object({ source: Type.String() }) },
+          yield: Type.Object({ line: Type.String() }),
+        },
+      }, async function* () {})
+
+      const builder = new HonoAppBuilder().register(procs, {})
+      builder.build()
+
+      const registry = new DocRegistry().from(builder)
+      const envelope = registry.toJSON()
+      const route = envelope.routes.find((r) => r.name === 'Tail')
+      expect(route?.kind).toBe('http-stream')
+    })
+
+    test('accepts a real HonoAppBuilder as source', () => {
       const RPC = Procedures<{ userId: string }, RPCConfig>()
 
       RPC.Create(
@@ -589,7 +626,7 @@ describe('DocRegistry', () => {
         async (_ctx, params) => params,
       )
 
-      const builder = new HonoRPCAppBuilder()
+      const builder = new HonoAppBuilder()
       builder.register(RPC, () => ({ userId: '123' }))
       builder.build()
 

package/src/implementations/http/doc-registry.ts

@@ -89,7 +89,7 @@ export class DocRegistry {
     }
 
     // Surface coverage gaps — when a builder skipped procedures (e.g. a
-    // streaming procedure registered with HonoRPCAppBuilder), the per-builder
+    // streaming procedure registered with HonoAppBuilder), the per-builder
     // warning fires once at `build()` time, but consumers who only call
     // `registry.toJSON()` (e.g. to dump the envelope to disk for codegen)
     // wouldn't see it without this aggregate. Single warning per call,

package/src/implementations/http/error-dispatch.test.ts

@@ -0,0 +1,283 @@
+import { describe, expect, test, vi } from 'vitest'
+import { Hono } from 'hono'
+import { dispatchMidStreamError, dispatchPreStreamError } from './error-dispatch.js'
+import { defineErrorTaxonomy } from './error-taxonomy.js'
+import { ProcedureValidationError } from '../../errors.js'
+
+function makeContext() {
+  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()
+  })
+
+  test('taxonomy onCatch is fully awaited before the response body is written', async () => {
+    const c = await makeContext()
+    const calls: string[] = []
+    class HookedError extends Error {}
+    const errors = defineErrorTaxonomy({
+      HookedError: {
+        class: HookedError,
+        statusCode: 500,
+        toResponse: () => ({ name: 'HookedError' }),
+        onCatch: async () => {
+          // Awaiting an async setTimeout here means a non-awaiting dispatcher
+          // would write the response BEFORE this push runs. The order we capture
+          // in `calls` reveals which branch happened.
+          await new Promise<void>((resolve) => setTimeout(resolve, 5))
+          calls.push('oncatch-done')
+        },
+      },
+    })
+
+    // Spy on c.json: when the dispatcher writes the response, record where in
+    // the timeline it happened relative to onCatch's push.
+    const originalJson = c.json.bind(c) as (...args: any[]) => Response
+    const jsonSpy = vi.fn((...args: any[]) => {
+      calls.push('response-write')
+      return originalJson(...args)
+    })
+    ;(c as any).json = jsonSpy
+
+    const res = await dispatchPreStreamError({
+      err: new HookedError('boom'),
+      procedure: dummyProcedure,
+      raw: c,
+      cfg: { errors },
+    })
+
+    expect(res.status).toBe(500)
+    expect(jsonSpy).toHaveBeenCalledTimes(1)
+    // If the dispatcher awaits onCatch first, 'oncatch-done' precedes
+    // 'response-write'. Without the await, the order would be reversed
+    // (or 'oncatch-done' would land after the dispatcher returns).
+    expect(calls).toEqual(['oncatch-done', 'response-write'])
+  })
+})
+
+const streamProcedure = {
+  name: 'Tail',
+  kind: 'rpc-stream',
+  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()
+  })
+
+  test('returns a runOnCatch function that is invokable and awaits the taxonomy hook', async () => {
+    const c = await makeContext()
+    const calls: string[] = []
+    class StreamErr extends Error {}
+    const errors = defineErrorTaxonomy({
+      StreamErr: {
+        class: StreamErr,
+        statusCode: 500,
+        toResponse: () => ({ name: 'StreamErr' }),
+        onCatch: async () => {
+          await new Promise<void>((resolve) => setTimeout(resolve, 5))
+          calls.push('oncatch-done')
+        },
+      },
+    })
+
+    // Mid-stream contract: the dispatcher does NOT call runOnCatch itself —
+    // the caller (stream handler) decides when to invoke it. Verify the shape
+    // and that awaiting it actually awaits the hook.
+    const result = await dispatchMidStreamError({
+      err: new StreamErr('mid'),
+      procedure: streamProcedure,
+      raw: c,
+      cfg: { errors },
+    })
+
+    expect(result.runOnCatch).toBeTypeOf('function')
+    // Hook has not yet run — caller hasn't invoked it.
+    expect(calls).toEqual([])
+
+    await result.runOnCatch!()
+    expect(calls).toEqual(['oncatch-done'])
+  })
+})

package/src/implementations/http/error-dispatch.ts

@@ -0,0 +1,176 @@
+import type { Context } from 'hono'
+import {
+  resolveErrorResponse,
+  type ErrorTaxonomy,
+  type TAnyProcedureRegistration,
+  type UnknownErrorConfig,
+} from './error-taxonomy.js'
+import type { TStreamProcedureRegistration, THttpStreamProcedureRegistration } from '../../types.js'
+
+/**
+ * Public alias of {@link TAnyProcedureRegistration} — re-exported here so the
+ * hono/ module can import it from one place without taking a direct dependency
+ * on error-taxonomy internals. Single source of truth lives in
+ * error-taxonomy.ts.
+ */
+export type AnyProcedureRegistration = TAnyProcedureRegistration
+
+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,
+      )
+    }
+  }
+
+  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)
+}
+
+/**
+ * Return shape of an `onMidStreamError` callback.
+ *
+ * - `data`: the value to write to the open stream as the error payload.
+ *   Decorate with the `sse(data, { event, id, retry })` helper from
+ *   `hono/handlers/stream` to attach SSE metadata; the stream handler
+ *   reads that metadata via `getSSEMeta` after dispatch.
+ * - `closeStream`: reserved for future use. The stream currently always
+ *   closes naturally after the catch block returns; this flag is kept on
+ *   the public type for forward compatibility but the dispatcher does not
+ *   read it.
+ */
+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,
+      )
+    }
+  }
+
+  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',
+  }
+}

package/src/implementations/http/error-taxonomy.ts

@@ -3,11 +3,11 @@ import {
   ProcedureValidationError,
   ProcedureYieldValidationError,
 } from '../../errors.js'
-import type { TProcedureRegistration, TStreamProcedureRegistration } from '../../index.js'
+import type { TProcedureRegistration, TStreamProcedureRegistration, THttpProcedureRegistration, THttpStreamProcedureRegistration } from '../../index.js'
 import type { ErrorDoc } from '../types.js'
 
-/** Either a regular or stream procedure registration — accepted by taxonomy callbacks. */
-export type TAnyProcedureRegistration = TProcedureRegistration | TStreamProcedureRegistration
+/** Any procedure registration — accepted by taxonomy callbacks. */
+export type TAnyProcedureRegistration = TProcedureRegistration | TStreamProcedureRegistration | THttpProcedureRegistration<any> | THttpStreamProcedureRegistration<any>
 
 /**
  * An entry in an {@link ErrorTaxonomy}. Describes how to recognize a thrown
@@ -35,8 +35,8 @@ export type ErrorTaxonomyEntry<TError = any, TBody = unknown> = {
   toResponse?: (err: TError, meta: { key: string }) => TBody
   /**
    * Side effect on catch (logging, metrics). Awaited before the response is sent.
-   * `raw` is the framework-specific request context (Hono `Context` /
-   * `{ req, res }` for Express) — cast as needed.
+   * `raw` is the framework-specific request context (e.g., Hono `Context`) —
+   * cast as needed.
    */
   onCatch?: (
     err: TError,