ts-procedures 4.0.1 → 5.1.0

package/build/implementations/http/hono-stream/index.test.js

@@ -3,7 +3,8 @@ 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 { HonoStreamAppBuilder, sse } from './index.js';
+import { ProcedureValidationError } from '../../../errors.js';
 /**
  * HonoStreamAppBuilder Test Suite
  *
@@ -20,7 +21,7 @@ describe('HonoStreamAppBuilder', () => {
             const RPC = Procedures();
             RPC.CreateStream('StreamMessages', { scope: 'messages', version: 1 }, async function* () {
                 yield { message: 'hello' };
-                yield { data: { message: 'world' } };
+                yield { message: 'world' };
             });
             builder.register(RPC, () => ({ userId: '123' }));
             const app = builder.build();
@@ -36,7 +37,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ app: customApp });
             const RPC = Procedures();
             RPC.CreateStream('StreamData', { scope: 'data', version: 1 }, async function* () {
-                yield { data: { data: 1 } };
+                yield { data: 1 };
             });
             builder.register(RPC, () => ({ userId: '123' }));
             const app = builder.build();
@@ -68,9 +69,9 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             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, () => ({}));
             const app = builder.build();
@@ -90,7 +91,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -101,7 +102,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ defaultStreamMode: 'sse' });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -153,7 +154,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { method: 'works' } };
+                yield { method: 'works' };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -164,7 +165,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { method: 'works' } };
+                yield { method: 'works' };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -214,7 +215,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ pathPrefix: '/api/v1' });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -225,7 +226,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ pathPrefix: 'custom' });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -236,7 +237,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ pathPrefix: '/api' });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: {} };
+                yield {};
             });
             builder.register(RPC, () => ({}));
             builder.build();
@@ -252,7 +253,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ onRequestStart });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -265,7 +266,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ onRequestEnd });
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -274,25 +275,26 @@ describe('HonoStreamAppBuilder', () => {
             expect(onRequestEnd).toHaveBeenCalledTimes(1);
             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();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
             await app.request('/test/test/1');
             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();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -301,6 +303,7 @@ describe('HonoStreamAppBuilder', () => {
             await res.text();
             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 () => {
             const order = [];
@@ -313,7 +316,7 @@ describe('HonoStreamAppBuilder', () => {
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
                 order.push('handler');
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -352,7 +355,7 @@ describe('HonoStreamAppBuilder', () => {
                     params: v.object({ count: v.number() }),
                 },
             }, async function* (ctx, params) {
-                yield { data: { count: params.count } };
+                yield { count: params.count };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -368,7 +371,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('ErrorStream', { scope: 'error', version: 1 }, async function* () {
-                yield { data: { count: 1 } };
+                yield { count: 1 };
                 throw new Error('Stream error');
             });
             builder.register(RPC, () => ({}));
@@ -405,7 +408,7 @@ describe('HonoStreamAppBuilder', () => {
                     params: v.object({ count: v.number() }),
                 },
             }, async function* (ctx, params) {
-                yield { data: { count: params.count } };
+                yield { count: params.count };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -429,7 +432,7 @@ describe('HonoStreamAppBuilder', () => {
                     params: v.object({ count: v.number() }),
                 },
             }, async function* (ctx, params) {
-                yield { data: { count: params.count } };
+                yield { count: params.count };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -448,7 +451,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ onPreStreamError });
             const RPC = Procedures();
             RPC.CreateStream('SecureStream', { scope: 'secure', version: 1 }, async function* (ctx) {
-                yield { data: { userId: ctx.userId } };
+                yield { userId: ctx.userId };
             });
             builder.register(RPC, () => {
                 throw new Error('Authentication required');
@@ -475,7 +478,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder({ onMidStreamError });
             const RPC = Procedures();
             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');
             });
             builder.register(RPC, () => ({}));
@@ -611,14 +614,15 @@ describe('HonoStreamAppBuilder', () => {
             expect(doc.streamMode).toBe('sse');
             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;
+            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', () => {
             const builder = new HonoStreamAppBuilder();
@@ -631,7 +635,9 @@ describe('HonoStreamAppBuilder', () => {
             const yt = builder.docs[0].jsonSchema.yieldType;
             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' });
@@ -653,27 +659,27 @@ describe('HonoStreamAppBuilder', () => {
             expect(yt.properties?.id).toBeUndefined();
             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();
-            RPC.CreateStream('CustomSSE', { 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' };
+            RPC.CreateStream('Notifications', { scope: 'test', version: 1, schema: { yieldType: yieldSchema } }, async function* () {
+                yield { id: 42, message: 'hello' };
             });
             builder.register(RPC, () => ({}));
             builder.build();
             const yt = builder.docs[0].jsonSchema.yieldType;
             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', () => {
             const builder = new HonoStreamAppBuilder({ defaultStreamMode: 'text' });
@@ -709,7 +715,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, () => ({}));
             const app = builder.build();
@@ -732,7 +738,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('StreamEvents', { scope: 'events', version: 1 }, async function* () {
-                yield { data: {} };
+                yield {};
             });
             builder.register(RPC, () => ({}), {
                 extendProcedureDoc: ({ procedure }) => ({
@@ -751,7 +757,7 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             RPC.CreateStream('Test', { scope: 'test', version: 1 }, async function* () {
-                yield { data: {} };
+                yield {};
             });
             builder.register(RPC, () => ({}), {
                 extendProcedureDoc: () => ({
@@ -801,7 +807,7 @@ describe('HonoStreamAppBuilder', () => {
             const SSERPC = Procedures();
             const TextRPC = Procedures();
             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* () {
                 yield { mode: 'text' };
@@ -852,7 +858,7 @@ describe('HonoStreamAppBuilder', () => {
             const RPC = Procedures();
             RPC.CreateStream('CheckPrevalidated', { scope: 'check', version: 1 }, async function* (ctx) {
                 receivedIsPrevalidated = ctx.isPrevalidated;
-                yield { data: { ok: true } };
+                yield { ok: true };
             });
             builder.register(RPC, () => ({}));
             const app = builder.build();
@@ -915,12 +921,12 @@ 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();
             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, () => ({}));
             const app = builder.build();
@@ -930,12 +936,12 @@ describe('HonoStreamAppBuilder', () => {
             expect(text).toContain('event: chat');
             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();
             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, () => ({}));
             const app = builder.build();
@@ -948,8 +954,8 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             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, () => ({}));
             const app = builder.build();
@@ -964,9 +970,9 @@ describe('HonoStreamAppBuilder', () => {
             const builder = new HonoStreamAppBuilder();
             const RPC = Procedures();
             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, () => ({}));
             const app = builder.build();
@@ -983,6 +989,245 @@ describe('HonoStreamAppBuilder', () => {
         });
     });
     // --------------------------------------------------------------------------
+    // sse() Helper Tests
+    // --------------------------------------------------------------------------
+    describe('sse() helper', () => {
+        test('tagged yields with custom event/id/retry', async () => {
+            const builder = new HonoStreamAppBuilder();
+            const RPC = Procedures();
+            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();
+            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();
+            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();
+            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();
+            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();
+            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 = {};
+            const builder = new HonoStreamAppBuilder({
+                defaultStreamMode: 'text',
+                onStreamStart: (_proc, _c, mode) => { modes.start = mode; },
+                onStreamEnd: (_proc, _c, mode) => { modes.end = mode; },
+            });
+            const RPC = Procedures();
+            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();
+            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();
+            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 () => {
+            const builder = new HonoStreamAppBuilder({
+                onMidStreamError: (_procedure, _c, error) => {
+                    // This satisfies MidStreamErrorResult<ErrorPayload>
+                    return {
+                        data: { type: 'error', code: 'STREAM_FAILED', message: error.message },
+                    };
+                },
+            });
+            const RPC = Procedures();
+            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();
+            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
     // --------------------------------------------------------------------------
     describe('integration', () => {
@@ -1010,8 +1255,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) => ({
                 userId: c.req.header('x-user-id') || 'anonymous',
@@ -1033,8 +1278,8 @@ describe('HonoStreamAppBuilder', () => {
             expect(JSON.parse(lines[1])).toEqual({ id: 2, message: 'Notification 2 for user-123' });
             // 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');
         });
     });