ts-procedures 4.0.1 → 5.1.0

package/src/implementations/http/hono-stream/index.test.ts

@@ -3,8 +3,9 @@ import { describe, expect, test, vi, beforeEach } from 'vitest'
 import { Hono } from 'hono'
 import { v } from 'suretype'
 import { Procedures } from '../../../index.js'
-import { HonoStreamAppBuilder } from './index.js'
-import { RPCConfig } from '../../types.js'
+import { HonoStreamAppBuilder, sse, MidStreamErrorResult } from './index.js'
+import { RPCConfig, StreamMode } from '../../types.js'
+import { ProcedureValidationError } from '../../../errors.js'
 
 /**
  * HonoStreamAppBuilder Test Suite
@@ -23,7 +24,7 @@ describe('HonoStreamAppBuilder', () => {
 
       RPC.CreateStream('StreamMessages', { scope: 'messages', version: 1 }, async function* () {
         yield { message: 'hello' }
-        yield { data: { message: 'world' } }
+        yield { message: 'world' }
       })
 
       builder.register(RPC, () => ({ userId: '123' }))
@@ -45,7 +46,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{ userId: string }, RPCConfig>()
 
       RPC.CreateStream('StreamData', { scope: 'data', version: 1 }, async function* () {
-        yield { data: { data: 1 } }
+        yield { data: 1 }
       })
 
       builder.register(RPC, () => ({ userId: '123' }))
@@ -84,9 +85,9 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Counter', { scope: 'counter', version: 1 }, async function* () {
-        yield { data: { count: 1 } }
-        yield { data: { count: 2 } }
-        yield { data: { count: 3 } }
+        yield { count: 1 }
+        yield { count: 2 }
+        yield { count: 3 }
       })
 
       builder.register(RPC, () => ({}))
@@ -111,7 +112,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -126,7 +127,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -191,7 +192,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { method: 'works' } }
+        yield { method: 'works' }
       })
 
       builder.register(RPC, () => ({}))
@@ -206,7 +207,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { method: 'works' } }
+        yield { method: 'works' }
       })
 
       builder.register(RPC, () => ({}))
@@ -268,7 +269,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -283,7 +284,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -298,7 +299,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: {} }
+        yield {}
       })
 
       builder.register(RPC, () => ({}))
@@ -318,7 +319,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -336,7 +337,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -349,13 +350,13 @@ describe('HonoStreamAppBuilder', () => {
       expect(onRequestEnd.mock.calls[0]![0]).toHaveProperty('req')
     })
 
-    test('onStreamStart is called before streaming begins', async () => {
+    test('onStreamStart is called before streaming begins with streamMode', async () => {
       const onStreamStart = vi.fn()
       const builder = new HonoStreamAppBuilder({ onStreamStart })
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -365,15 +366,16 @@ describe('HonoStreamAppBuilder', () => {
 
       expect(onStreamStart).toHaveBeenCalledTimes(1)
       expect(onStreamStart.mock.calls[0]![0]).toHaveProperty('name', 'Test')
+      expect(onStreamStart.mock.calls[0]![2]).toBe('sse')
     })
 
-    test('onStreamEnd is called after stream completes', async () => {
+    test('onStreamEnd is called after stream completes with streamMode', async () => {
       const onStreamEnd = vi.fn()
       const builder = new HonoStreamAppBuilder({ onStreamEnd })
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -385,6 +387,7 @@ describe('HonoStreamAppBuilder', () => {
 
       expect(onStreamEnd).toHaveBeenCalledTimes(1)
       expect(onStreamEnd.mock.calls[0]![0]).toHaveProperty('name', 'Test')
+      expect(onStreamEnd.mock.calls[0]![2]).toBe('sse')
     })
 
     test('hooks execute in correct order', async () => {
@@ -400,7 +403,7 @@ describe('HonoStreamAppBuilder', () => {
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
         order.push('handler')
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -448,7 +451,7 @@ describe('HonoStreamAppBuilder', () => {
           },
         },
         async function* (ctx, params) {
-          yield { data: { count: params.count } }
+          yield { count: params.count }
         }
       )
 
@@ -471,7 +474,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
-        yield { data: { count: 1 } }
+        yield { count: 1 }
         throw new Error('Stream error')
       })
 
@@ -521,7 +524,7 @@ describe('HonoStreamAppBuilder', () => {
           },
         },
         async function* (ctx, params) {
-          yield { data: { count: params.count } }
+          yield { count: params.count }
         }
       )
 
@@ -558,7 +561,7 @@ describe('HonoStreamAppBuilder', () => {
           },
         },
         async function* (ctx, params) {
-          yield { data: { count: params.count } }
+          yield { count: params.count }
         }
       )
 
@@ -584,7 +587,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{ userId: string }, RPCConfig>()
 
       RPC.CreateStream('SecureStream', { scope: 'secure', version: 1 }, async function* (ctx) {
-        yield { data: { userId: ctx.userId } }
+        yield { userId: ctx.userId }
       })
 
       builder.register(RPC, () => {
@@ -618,7 +621,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
-        yield { data: { type: 'data', value: 1 } }
+        yield { type: 'data', value: 1 }
         throw new Error('Something broke')
       })
 
@@ -794,14 +797,15 @@ describe('HonoStreamAppBuilder', () => {
       expect(doc.jsonSchema.params).toBeDefined()
       expect(doc.jsonSchema.returnType).toBeDefined()
 
-      // SSE envelope fields are merged into yieldType
+      // yieldType is nested under SSE envelope's data property
       const yt = doc.jsonSchema.yieldType as Record<string, any>
+      expect(yt.description).toBe('SSE message envelope. The data field contains the procedure yield value.')
       expect(yt.required).toEqual(['data', 'event', 'id'])
       expect(yt.properties.event).toEqual({ type: 'string' })
       expect(yt.properties.id).toEqual({ type: 'string' })
       expect(yt.properties.retry).toEqual({ type: 'number' })
-      // Developer's data property is preserved
-      expect(yt.properties.message).toBeDefined()
+      // Developer's yieldType is nested under data
+      expect(yt.properties.data.properties.message).toBeDefined()
     })
 
     test('SSE mode generates SSE envelope even when no yieldType is defined', () => {
@@ -818,7 +822,9 @@ describe('HonoStreamAppBuilder', () => {
       const yt = builder.docs[0]!.jsonSchema.yieldType as Record<string, any>
       expect(yt).toBeDefined()
       expect(yt.type).toBe('object')
+      expect(yt.description).toBe('SSE message envelope. The data field contains the procedure yield value.')
       expect(yt.required).toEqual(['data', 'event', 'id'])
+      // data is empty schema when no yieldType defined
       expect(yt.properties.data).toEqual({})
       expect(yt.properties.event).toEqual({ type: 'string' })
       expect(yt.properties.id).toEqual({ type: 'string' })
@@ -849,25 +855,21 @@ describe('HonoStreamAppBuilder', () => {
       expect(yt.properties?.retry).toBeUndefined()
     })
 
-    test('developer-defined event/id in yieldType are preserved', () => {
+    test('yieldType with id property does not collide with SSE id field', () => {
+      // User's yieldType has an `id` field (number) — this should be nested under
+      // the SSE envelope's `data` property, not collide with the SSE `id` (string)
       const yieldSchema = v.object({
-        data: v.object({ msg: v.string() }),
-        event: v.string().const('custom-event'),
-        id: v.string().const('fixed-id'),
+        id: v.number(),
+        message: v.string(),
       })
       const builder = new HonoStreamAppBuilder()
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream(
-        'CustomSSE',
+        'Notifications',
         { scope: 'test', version: 1, schema: { yieldType: yieldSchema } },
         async function* () {
-          // suretype sucks, we have to assert this as the exact type to satisfy the const assertions in the schema
-          yield { data: { msg: 'hi' }, event: 'custom-event', id: 'fixed-id' } as {
-            data: { msg: string }
-            event: 'custom-event'
-            id: 'fixed-id'
-          }
+          yield { id: 42, message: 'hello' }
         }
       )
 
@@ -876,11 +878,11 @@ describe('HonoStreamAppBuilder', () => {
 
       const yt = builder.docs[0]!.jsonSchema.yieldType as Record<string, any>
       expect(yt.required).toEqual(['data', 'event', 'id'])
-      // Developer's custom event/id definitions take precedence
-      expect(yt.properties.event.const).toBe('custom-event')
-      expect(yt.properties.id.const).toBe('fixed-id')
-      // retry is still added as a base default
-      expect(yt.properties.retry).toEqual({ type: 'number' })
+      // SSE envelope id is a string
+      expect(yt.properties.id).toEqual({ type: 'string' })
+      // User's id (number) is safely nested under data
+      expect(yt.properties.data.properties.id.type).toBe('number')
+      expect(yt.properties.data.properties.message.type).toBe('string')
     })
 
     test('streamMode is recorded in docs', () => {
@@ -927,7 +929,7 @@ describe('HonoStreamAppBuilder', () => {
 
       // Streaming procedure (should be registered)
       RPC.CreateStream('Stream', { scope: 'stream', version: 1 }, async function* () {
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -956,7 +958,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('StreamEvents', { scope: 'events', version: 1 }, async function* () {
-        yield { data: {} }
+        yield {}
       })
 
       builder.register(RPC, () => ({}), {
@@ -979,7 +981,7 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-        yield { data: {} }
+        yield {}
       })
 
       builder.register(RPC, () => ({}), {
@@ -1050,7 +1052,7 @@ describe('HonoStreamAppBuilder', () => {
       const TextRPC = Procedures<{}, RPCConfig>()
 
       SSERPC.CreateStream('SSEStream', { scope: 'sse', version: 1 }, async function* () {
-        yield { data: { mode: 'sse' } }
+        yield { mode: 'sse' }
       })
 
       TextRPC.CreateStream('TextStream', { scope: 'text', version: 1 }, async function* () {
@@ -1114,7 +1116,7 @@ describe('HonoStreamAppBuilder', () => {
 
       RPC.CreateStream('CheckPrevalidated', { scope: 'check', version: 1 }, async function* (ctx) {
         receivedIsPrevalidated = ctx.isPrevalidated
-        yield { data: { ok: true } }
+        yield { ok: true }
       })
 
       builder.register(RPC, () => ({}))
@@ -1200,13 +1202,13 @@ describe('HonoStreamAppBuilder', () => {
   // SSE Yield Shape Tests
   // --------------------------------------------------------------------------
   describe('SSE yield shape', () => {
-    test('custom event names in yields', async () => {
+    test('custom event names via sse() helper', async () => {
       const builder = new HonoStreamAppBuilder()
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Events', { scope: 'events', version: 1 }, async function* () {
-        yield { data: { type: 'user_joined' }, event: 'join' }
-        yield { data: { type: 'message' }, event: 'chat' }
+        yield sse({ type: 'user_joined' }, { event: 'join' })
+        yield sse({ type: 'message' }, { event: 'chat' })
       })
 
       builder.register(RPC, () => ({}))
@@ -1220,13 +1222,13 @@ describe('HonoStreamAppBuilder', () => {
       expect(text).not.toContain('event: Events')
     })
 
-    test('custom id in yields', async () => {
+    test('custom id via sse() helper', async () => {
       const builder = new HonoStreamAppBuilder()
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Events', { scope: 'events', version: 1 }, async function* () {
-        yield { data: { msg: 'first' }, id: 'msg-001' }
-        yield { data: { msg: 'second' }, id: 'msg-002' }
+        yield sse({ msg: 'first' }, { id: 'msg-001' })
+        yield sse({ msg: 'second' }, { id: 'msg-002' })
       })
 
       builder.register(RPC, () => ({}))
@@ -1244,8 +1246,8 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('Events', { scope: 'events', version: 1 }, async function* () {
-        yield { data: 'already a string' }
-        yield { data: { needs: 'stringify' } }
+        yield 'already a string'
+        yield { needs: 'stringify' }
       })
 
       builder.register(RPC, () => ({}))
@@ -1265,9 +1267,9 @@ describe('HonoStreamAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
 
       RPC.CreateStream('MyProcedure', { scope: 'test', version: 1 }, async function* () {
-        yield { data: { value: 1 } }
-        yield { data: { value: 2 }, event: 'custom' }
-        yield { data: { value: 3 } }
+        yield { value: 1 }
+        yield sse({ value: 2 }, { event: 'custom' })
+        yield { value: 3 }
       })
 
       builder.register(RPC, () => ({}))
@@ -1288,6 +1290,312 @@ describe('HonoStreamAppBuilder', () => {
     })
   })
 
+  // --------------------------------------------------------------------------
+  // sse() Helper Tests
+  // --------------------------------------------------------------------------
+  describe('sse() helper', () => {
+    test('tagged yields with custom event/id/retry', async () => {
+      const builder = new HonoStreamAppBuilder()
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('Tagged', { scope: 'tagged', version: 1 }, async function* () {
+        yield sse({ count: 1 }, { event: 'tick', id: 'evt-1', retry: 5000 })
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/tagged/tagged/1')
+      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('plain domain objects use procedure name and auto-incremented id', async () => {
+      const builder = new HonoStreamAppBuilder()
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('Plain', { scope: 'plain', version: 1 }, async function* () {
+        yield { a: 1 }
+        yield { a: 2 }
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/plain/plain/1')
+      const text = await res.text()
+
+      const messages = text.split('\n\n').filter(Boolean)
+      expect(messages[0]).toContain('event: Plain')
+      expect(messages[0]).toContain('id: 0')
+      expect(messages[0]).toContain('data: {"a":1}')
+      expect(messages[1]).toContain('event: Plain')
+      expect(messages[1]).toContain('id: 1')
+      expect(messages[1]).toContain('data: {"a":2}')
+    })
+
+    test('sse() metadata is invisible in text mode', async () => {
+      const builder = new HonoStreamAppBuilder({ defaultStreamMode: 'text' })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('TextTagged', { scope: 'text', version: 1 }, async function* () {
+        yield sse({ count: 1 }, { event: 'tick' })
+        yield { count: 2 }
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/text/text-tagged/1')
+      const text = await res.text()
+      const lines = text.trim().split('\n')
+
+      // Text mode just JSON-stringifies — sse() metadata is not visible
+      expect(JSON.parse(lines[0]!)).toEqual({ count: 1 })
+      expect(JSON.parse(lines[1]!)).toEqual({ count: 2 })
+    })
+
+    test('sse() with partial options', async () => {
+      const builder = new HonoStreamAppBuilder()
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('Partial', { scope: 'partial', version: 1 }, async function* () {
+        yield sse({ v: 1 }, { event: 'custom' })
+        yield sse({ v: 2 }, { id: 'my-id' })
+        yield sse({ v: 3 })
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/partial/partial/1')
+      const text = await res.text()
+      const messages = text.split('\n\n').filter(Boolean)
+
+      // First: custom event, auto id
+      expect(messages[0]).toContain('event: custom')
+      expect(messages[0]).toContain('id: 0')
+
+      // Second: default event, custom id
+      expect(messages[1]).toContain('event: Partial')
+      expect(messages[1]).toContain('id: my-id')
+
+      // Third: sse() with no options — same as plain object (defaults)
+      expect(messages[2]).toContain('event: Partial')
+      expect(messages[2]).toContain('id: 2')
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // streamMode in Lifecycle Hooks
+  // --------------------------------------------------------------------------
+  describe('streamMode in lifecycle hooks', () => {
+    test('onStreamStart receives sse streamMode', async () => {
+      const onStreamStart = vi.fn()
+      const builder = new HonoStreamAppBuilder({ onStreamStart })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
+        yield { ok: true }
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      await app.request('/test/test/1')
+
+      expect(onStreamStart).toHaveBeenCalledTimes(1)
+      const [, , streamMode] = onStreamStart.mock.calls[0]!
+      expect(streamMode).toBe('sse')
+    })
+
+    test('onStreamEnd receives text streamMode', async () => {
+      const onStreamEnd = vi.fn()
+      const builder = new HonoStreamAppBuilder({ defaultStreamMode: 'text', onStreamEnd })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
+        yield { ok: true }
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/test/test/1')
+      await res.text()
+
+      expect(onStreamEnd).toHaveBeenCalledTimes(1)
+      const [, , streamMode] = onStreamEnd.mock.calls[0]!
+      expect(streamMode).toBe('text')
+    })
+
+    test('onStreamStart and onStreamEnd receive matching streamMode', async () => {
+      const modes: { start?: StreamMode; end?: StreamMode } = {}
+      const builder = new HonoStreamAppBuilder({
+        defaultStreamMode: 'text',
+        onStreamStart: (_proc, _c, mode) => { modes.start = mode },
+        onStreamEnd: (_proc, _c, mode) => { modes.end = mode },
+      })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
+        yield { ok: true }
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/test/test/1')
+      await res.text()
+
+      expect(modes.start).toBe('text')
+      expect(modes.end).toBe('text')
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // sse() in onMidStreamError
+  // --------------------------------------------------------------------------
+  describe('sse() in onMidStreamError', () => {
+    test('sse() wraps error data with custom event and id', async () => {
+      const builder = new HonoStreamAppBuilder({
+        onMidStreamError: (procedure, c, error) => {
+          return {
+            data: sse(
+              { type: 'error', message: error.message },
+              { event: 'custom-error', id: 'err-1' }
+            ),
+          }
+        },
+      })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
+        yield { type: 'data', value: 1 }
+        throw new Error('Something broke')
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/error/error-stream/1')
+      const text = await res.text()
+
+      // Normal yield
+      expect(text).toContain('data: {"type":"data","value":1}')
+      // Error yield with sse() metadata
+      expect(text).toContain('event: custom-error')
+      expect(text).toContain('id: err-1')
+      expect(text).toContain('"type":"error"')
+    })
+
+    test('string error data without sse() uses default event and id', async () => {
+      const builder = new HonoStreamAppBuilder({
+        onMidStreamError: () => {
+          return { data: 'plain error string' }
+        },
+      })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
+        yield { count: 1 }
+        throw new Error('fail')
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/error/error-stream/1')
+      const text = await res.text()
+
+      // String data can't use sse() (not an object), so defaults apply
+      expect(text).toContain('data: plain error string')
+      // event defaults to procedure name when data is provided
+      expect(text).toContain('event: ErrorStream')
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // Generic TErrorData
+  // --------------------------------------------------------------------------
+  describe('generic TErrorData', () => {
+    test('typed builder constrains onMidStreamError return type', async () => {
+      type ErrorPayload = { type: 'error'; code: string; message: string }
+
+      const builder = new HonoStreamAppBuilder<ErrorPayload>({
+        onMidStreamError: (_procedure, _c, error) => {
+          // This satisfies MidStreamErrorResult<ErrorPayload>
+          return {
+            data: { type: 'error', code: 'STREAM_FAILED', message: error.message },
+          }
+        },
+      })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
+        yield { value: 1 }
+        throw new Error('typed error')
+      })
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/error/error-stream/1')
+      const text = await res.text()
+
+      expect(text).toContain('"code":"STREAM_FAILED"')
+      // Error message may be wrapped by Procedures with prefix
+      expect(text).toContain('typed error')
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // ProcedureValidationError narrowing in onPreStreamError
+  // --------------------------------------------------------------------------
+  describe('ProcedureValidationError narrowing', () => {
+    test('instanceof check works in onPreStreamError', async () => {
+      let wasValidationError = false
+
+      const builder = new HonoStreamAppBuilder({
+        onPreStreamError: (procedure, c, error) => {
+          if (error instanceof ProcedureValidationError) {
+            wasValidationError = true
+            return c.json({ validation: true, errors: error.errors }, 422)
+          }
+          return c.json({ error: error.message }, 500)
+        },
+      })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.CreateStream(
+        'Validated',
+        {
+          scope: 'validated',
+          version: 1,
+          schema: { params: v.object({ count: v.number() }) },
+        },
+        async function* (ctx, params) {
+          yield { count: params.count }
+        }
+      )
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await app.request('/validated/validated/1?count=not-a-number')
+
+      expect(res.status).toBe(422)
+      expect(wasValidationError).toBe(true)
+      const body = await res.json()
+      expect(body.validation).toBe(true)
+      expect(body.errors).toBeDefined()
+    })
+  })
+
   // --------------------------------------------------------------------------
   // Integration Test
   // --------------------------------------------------------------------------
@@ -1330,8 +1638,8 @@ describe('HonoStreamAppBuilder', () => {
         defaultStreamMode: 'text',
         onRequestStart: () => events.push('request-start'),
         onRequestEnd: () => events.push('request-end'),
-        onStreamStart: (proc) => events.push(`stream-start:${proc.name}`),
-        onStreamEnd: (proc) => events.push(`stream-end:${proc.name}`),
+        onStreamStart: () => events.push('stream-start'),
+        onStreamEnd: () => events.push('stream-end'),
       })
 
       builder.register(RPC, (c) => ({
@@ -1360,8 +1668,8 @@ describe('HonoStreamAppBuilder', () => {
 
       // Verify hooks were called
       expect(events).toContain('request-start')
-      expect(events).toContain('stream-start:WatchNotifications')
-      expect(events).toContain('stream-end:WatchNotifications')
+      expect(events).toContain('stream-start')
+      expect(events).toContain('stream-end')
       expect(events).toContain('request-end')
     })
   })