ts-procedures 7.2.0 → 8.0.0

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

@@ -0,0 +1,147 @@
+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,
+        },
+      })
+    }
+  })
+}

package/src/implementations/http/hono/handlers/rpc.test.ts

@@ -0,0 +1,81 @@
+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<{ userId: string }, 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)
+    const body = await res.json()
+    expect(body.error).toContain('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)
+  })
+})

package/src/implementations/http/hono/handlers/rpc.ts

@@ -0,0 +1,54 @@
+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,
+        },
+      })
+    }
+  })
+}

package/src/implementations/http/hono/handlers/stream.test.ts

@@ -0,0 +1,198 @@
+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'
+
+function buildApp(setup: (P: ReturnType<typeof Procedures<{ uid: string }, 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 } })
+
+    const res = await app.request('/e/ev/1', { method: 'POST', body: '{}', headers: { 'Content-Type': 'application/json' } })
+    // Consume the stream body so the SSE writer's finally block runs
+    await res.text()
+    expect(onStreamStart).toHaveBeenCalled()
+    expect(onStreamEnd).toHaveBeenCalled()
+  })
+
+  test('validateYields: true → invalid yield surfaces ProcedureYieldValidationError on the wire', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateStream(
+        'BadYield',
+        {
+          scope: 'y', version: 1,
+          schema: { yieldType: Type.Object({ id: Type.Number() }) },
+          validateYields: true,
+        },
+        async function* () {
+          yield { id: 1 } // valid
+          yield { id: 'not-a-number' } as any // invalid → throws ProcedureYieldValidationError
+        },
+      )
+    })
+
+    const res = await app.request('/y/bad-yield/1', {
+      method: 'POST',
+      body: '{}',
+      headers: { 'Content-Type': 'application/json' },
+    })
+    // Stream is already open by the time validation fails on the second yield;
+    // status is committed at 200 and the error shows up as an SSE error event.
+    expect(res.status).toBe(200)
+    const text = await res.text()
+    expect(text).toContain('event: error')
+    expect(text).toContain('"name":"ProcedureYieldValidationError"')
+    expect(text).toContain('"procedureName":"BadYield"')
+    // First valid yield still made it onto the wire.
+    expect(text).toContain('data: {"id":1}')
+  })
+
+  test('sse() helper propagates event/id/retry into SSE wire output', async () => {
+    const { app } = buildApp((P) => {
+      P.CreateStream('Tagged', { scope: 'tagged', version: 1 }, async function* () {
+        yield sse({ count: 1 }, { event: 'tick', id: 'evt-1', retry: 5000 })
+      })
+    })
+
+    const res = await app.request('/tagged/tagged/1', {
+      method: 'POST',
+      body: '{}',
+      headers: { 'Content-Type': 'application/json' },
+    })
+    const text = await res.text()
+    expect(text).toContain('event: tick')
+    expect(text).toContain('id: evt-1')
+    expect(text).toContain('retry: 5000')
+    expect(text).toContain('data: {"count":1}')
+  })
+
+  test('AbortSignal: natural completion → ctx.signal.reason === "stream-completed"', async () => {
+    let capturedSignal: AbortSignal | undefined
+    const { app } = buildApp((P) => {
+      P.CreateStream('Natural', { scope: 'sig', version: 1 }, async function* (ctx) {
+        capturedSignal = ctx.signal
+        yield 'a'
+        yield 'b'
+        return 'done'
+      })
+    })
+
+    const res = await app.request('/sig/natural/1', {
+      method: 'POST',
+      body: '{}',
+      headers: { 'Content-Type': 'application/json' },
+    })
+    // Drain the body so the wrappedHandler's finally block runs.
+    await res.text()
+
+    expect(capturedSignal).toBeInstanceOf(AbortSignal)
+    expect(capturedSignal!.aborted).toBe(true)
+    expect(capturedSignal!.reason).toBe('stream-completed')
+  })
+
+  test('AbortSignal: client disconnect (request signal aborted) → ctx.signal.reason !== "stream-completed"', async () => {
+    // NOTE: We can't directly simulate a real socket disconnect through
+    // `app.request()`. The closest test-friendly proxy: pre-abort the request
+    // signal so `c.req.raw.signal` is already aborted by the time the
+    // wrappedHandler in create-stream.ts builds the combined signal via
+    // `AbortSignal.any([incomingSignal, internalController.signal])`. The
+    // pre-existing reason wins over the internal 'stream-completed' that fires
+    // later in the wrappedHandler's finally clause.
+    let capturedSignal: AbortSignal | undefined
+    const { app } = buildApp((P) => {
+      P.CreateStream('Disconnect', { scope: 'sig', version: 1 }, async function* (ctx) {
+        capturedSignal = ctx.signal
+        yield 'first'
+      })
+    })
+
+    const ac = new AbortController()
+    ac.abort('client-gone')
+
+    const req = new Request('http://localhost/sig/disconnect/1', {
+      method: 'POST',
+      body: '{}',
+      headers: { 'Content-Type': 'application/json' },
+      signal: ac.signal,
+    })
+    const res = await app.request(req)
+    // Drain the body in case anything was emitted before the abort propagated.
+    await res.text().catch(() => '')
+
+    expect(capturedSignal).toBeInstanceOf(AbortSignal)
+    expect(capturedSignal!.aborted).toBe(true)
+    // The disconnect reason wins over the internal 'stream-completed' signal,
+    // so handlers can distinguish "client gave up" from "we finished normally".
+    expect(capturedSignal!.reason).not.toBe('stream-completed')
+  })
+})

package/src/implementations/http/hono/handlers/stream.ts

@@ -0,0 +1,208 @@
+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 type { MidStreamErrorResult } from '../../error-dispatch.js'
+
+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 ?? String(eventId++),
+        ...(meta?.retry !== undefined && { retry: meta.retry }),
+      })
+
+      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)
+    }
+  })
+}