ts-procedures 7.2.0 → 8.0.0

package/build/index.test.js

@@ -1,9 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { describe, expect, test } from 'vitest';
+import { describe, expect, it, test } from 'vitest';
 import { Procedures } from './index.js';
 import { v } from 'suretype';
 import { Type } from 'typebox';
-import { ProcedureError, ProcedureValidationError } from './errors.js';
 describe('Procedures', () => {
     test('Procedures', () => {
         const result = Procedures({
@@ -13,188 +12,6 @@ describe('Procedures', () => {
         });
         expect(result).toHaveProperty('Create');
     });
-    test('Procedures generic context & extended config', () => {
-        const { Create } = Procedures();
-        const { info } = Create('TestProcedure', {
-            // should not throw type errors
-            customProp: 'customProp',
-        }, async (ctx) => {
-            // should not throw type errors
-            return ctx.authToken;
-        });
-        expect(info.customProp).toEqual('customProp');
-        expect(info.optionalProp).toEqual(undefined);
-    });
-    test('Create Single Procedures', () => {
-        const { procedure: procedure1, info: info1 } = Procedures().Create('test1', {}, async () => {
-            return '1';
-        });
-        const { procedure: procedure2, info: info2 } = Procedures().Create('test2', {}, async () => {
-            return '2';
-        });
-        expect(procedure1).toBeDefined();
-        expect(info1).toBeDefined();
-        expect(procedure2).toBeDefined();
-        expect(info2).toBeDefined();
-    });
-    test('Procedures - Create call', () => new Promise((done) => {
-        let mockHttpCall;
-        const { Create } = Procedures({
-            onCreate: ({ handler }) => {
-                mockHttpCall = handler;
-            },
-        });
-        Create('Handler', {
-            schema: {
-                params: v.object({ name: v.string() }),
-                returnType: v.string(),
-            },
-        }, async (ctx, params) => {
-            expect(params).toEqual({ name: 'name' });
-            done();
-            return 'name';
-        });
-        mockHttpCall({}, { name: 'name' });
-    }));
-    test('Procedures - Create call w/ Typebox', () => new Promise((done) => {
-        let mockHttpCall;
-        const { Create } = Procedures({
-            onCreate: ({ handler, config, name }) => {
-                mockHttpCall = handler;
-            },
-        });
-        Create('Handler', {
-            schema: {
-                params: Type.Object({ name: Type.Optional(Type.String()) }),
-                returnType: Type.String(),
-            },
-        }, async (ctx, params) => {
-            expect(params).toEqual({ name: 'name' });
-            done();
-            return 'name';
-        });
-        mockHttpCall({}, { name: 'name' });
-    }));
-    test('Procedures - Create returns a handler to call/test the Procedure registration', async () => {
-        let ProcedureRegisteredCbHandler;
-        const { Create } = Procedures({
-            onCreate: (Procedure) => {
-                ProcedureRegisteredCbHandler = Procedure.handler;
-            },
-        });
-        const { NamedExportHandler, procedure, info } = Create('NamedExportHandler', {
-            description: 'Handler description',
-            schema: {
-                params: v.object({ number: v.number() }),
-            },
-        }, async (ctx, params) => {
-            return params.number;
-        });
-        expect(NamedExportHandler).toBeDefined();
-        expect(procedure).toBeDefined();
-        expect(ProcedureRegisteredCbHandler).toEqual(NamedExportHandler);
-        expect(ProcedureRegisteredCbHandler).toEqual(procedure);
-        const result = NamedExportHandler({}, { number: 1 });
-        expect(result).toBeDefined();
-        expect(result).toBeInstanceOf(Promise);
-        await expect(result).resolves.toEqual(1);
-        expect(info).toBeDefined();
-        expect(info).toBeInstanceOf(Object);
-        expect(info.schema).toHaveProperty('params');
-        expect(info.schema.params).toEqual({
-            type: 'object',
-            properties: { number: { type: 'number' } },
-        });
-        expect(info).toHaveProperty('description');
-        expect(info.description).toEqual('Handler description');
-    });
-    test('Procedures - Create params validation w/ no params provided', () => new Promise((done) => {
-        let mockHttpCall;
-        const { Create } = Procedures({
-            onCreate: ({ handler, config, name }) => {
-                mockHttpCall = (callParams) => {
-                    if (config.validation?.params) {
-                        const { errors } = config.validation.params(callParams);
-                        if (errors && 'message' in errors[0]) {
-                            expect(errors[0].message).toEqual('must be object');
-                            done();
-                            return;
-                        }
-                    }
-                    handler(callParams, {});
-                };
-            },
-        });
-        Create('test', {
-            schema: {
-                params: v.object({}),
-            },
-        }, async () => {
-            done();
-        });
-        mockHttpCall();
-    }));
-    test('Procedures - Create params validation w/ missing params', async () => new Promise((done) => {
-        let mockHttpCall;
-        const { Create } = Procedures({
-            onCreate: async ({ handler, config, name }) => {
-                mockHttpCall = async (callParams) => {
-                    if (config.validation?.params) {
-                        const { errors } = config.validation.params(callParams);
-                        expect(errors).toBeDefined();
-                        expect(errors?.length).toEqual(2);
-                    }
-                    try {
-                        await handler(callParams, {});
-                    }
-                    catch (e) {
-                        expect(e).instanceof(ProcedureValidationError);
-                        expect(e.errors.length).toEqual(2);
-                        done();
-                    }
-                };
-            },
-        });
-        Create('test', {
-            schema: {
-                params: v.object({
-                    name: v.string().required(),
-                    id: v.number().required(),
-                    email: v.string(),
-                }),
-            },
-        }, async () => {
-            return;
-        });
-        mockHttpCall({});
-    }));
-    test('Procedures - Create call provides ctx to handler', () => new Promise((done) => {
-        let mockHttpCall;
-        const { Create } = Procedures({
-            onCreate: ({ handler }) => {
-                mockHttpCall = () => handler({ testCtx: 'testCtx' });
-            },
-        });
-        Create('test', {}, async (ctx, params) => {
-            expect(ctx.testCtx).toEqual('testCtx');
-            done();
-        });
-        mockHttpCall();
-    }));
-    test('Procedure handler can throw local ctx error and is caught', async () => {
-        const { Create } = Procedures();
-        const { TestProcedureHandlerError } = Create('TestProcedureHandlerError', {}, async (ctx) => {
-            throw ctx.error('Local context error');
-        });
-        try {
-            await TestProcedureHandlerError({}, {});
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureError);
-            expect(e.message).toEqual('Local context error');
-            expect(e.procedureName).toEqual('TestProcedureHandlerError');
-        }
-    });
     test('Procedures - getRegisteredProcedures', () => {
         const { Create, getProcedures } = Procedures({
             onCreate: () => {
@@ -227,24 +44,6 @@ describe('Procedures', () => {
             },
         });
     });
-    test('Procedures - context() throws', async () => {
-        const { Create } = Procedures();
-        function validateAuthToken(token) {
-            return token === 'valid-token';
-        }
-        const { CheckIsAuthenticated } = Create('CheckIsAuthenticated', {
-            schema: {
-                returnType: v.string(),
-            },
-        }, async (ctx) => {
-            if (!validateAuthToken(ctx.authToken)) {
-                throw ctx.error('Invalid auth token');
-            }
-            return 'User authentication is valid';
-        });
-        await expect(CheckIsAuthenticated({ authToken: 'valid-token' }, {})).resolves.toEqual('User authentication is valid');
-        await expect(CheckIsAuthenticated({ authToken: 'not-valid-token' }, {})).rejects.toThrowError(ProcedureError);
-    });
     test('Procedures - duplicate registration throws before schema computation', () => {
         const { Create } = Procedures();
         Create('DuplicateTest', {}, async () => 'first');
@@ -252,22 +51,6 @@ describe('Procedures', () => {
             Create('DuplicateTest', {}, async () => 'second');
         }).toThrow('Procedure with name DuplicateTest is already registered');
     });
-    test('Procedures - wrapped errors preserve cause', async () => {
-        const { Create } = Procedures();
-        const originalError = new Error('Database connection failed');
-        originalError.code = 'ECONNREFUSED';
-        const { TestCause } = Create('TestCause', {}, async () => {
-            throw originalError;
-        });
-        try {
-            await TestCause({}, {});
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureError);
-            expect(e.cause).toBe(originalError);
-            expect(e.cause.code).toBe('ECONNREFUSED');
-        }
-    });
     test('Procedures - getProcedure returns specific procedure', () => {
         const { Create, getProcedure } = Procedures();
         Create('FindMe', {}, async () => 'found');
@@ -295,307 +78,7 @@ describe('Procedures', () => {
         clear();
         expect(getProcedures().length).toBe(0);
     });
-    test('Procedures - ctx.error still works after optimization', async () => {
-        const { Create } = Procedures();
-        const { ErrorTest } = Create('ErrorTest', {}, async (ctx) => {
-            throw ctx.error('Custom error message', { code: 'ERR_001' });
-        });
-        try {
-            await ErrorTest({}, {});
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureError);
-            expect(e.message).toBe('Custom error message');
-            expect(e.procedureName).toBe('ErrorTest');
-            expect(e.meta).toEqual({ code: 'ERR_001' });
-        }
-    });
-    test('Create passes through external signal from context', async () => {
-        const { Create } = Procedures();
-        const externalAc = new AbortController();
-        let capturedSignal = null;
-        const { WithSignal } = Create('WithSignal', {}, async (ctx) => {
-            capturedSignal = ctx.signal;
-            return 'done';
-        });
-        await WithSignal({ signal: externalAc.signal }, {});
-        expect(capturedSignal).toBe(externalAc.signal);
-        expect(capturedSignal.aborted).toBe(false);
-    });
-    test('Create external signal reflects abort from caller', async () => {
-        const { Create } = Procedures();
-        const externalAc = new AbortController();
-        let capturedSignal = null;
-        const { AbortedSignal } = Create('AbortedSignal', {}, async (ctx) => {
-            capturedSignal = ctx.signal;
-            expect(ctx.signal.aborted).toBe(true);
-            return 'done';
-        });
-        externalAc.abort();
-        await AbortedSignal({ signal: externalAc.signal }, {});
-        expect(capturedSignal.aborted).toBe(true);
-    });
-    test('Create external signal cancels in-flight async work', async () => {
-        const { Create } = Procedures();
-        const externalAc = new AbortController();
-        let wasAbortedDuringWork = false;
-        const ready = Promise.withResolvers();
-        const { LongWork } = Create('LongWork', {}, async (ctx) => {
-            ready.resolve();
-            await new Promise((resolve) => {
-                ctx.signal.addEventListener('abort', () => {
-                    wasAbortedDuringWork = true;
-                    resolve();
-                });
-            });
-            return 'done';
-        });
-        const p = LongWork({ signal: externalAc.signal }, {});
-        await ready.promise;
-        externalAc.abort();
-        await p;
-        expect(wasAbortedDuringWork).toBe(true);
-    });
-});
-describe('Procedures - Definition Location in Errors', () => {
-    test('ProcedureValidationError includes definition location', async () => {
-        const { Create } = Procedures();
-        const { TestValidation } = Create('TestValidation', {
-            schema: {
-                params: v.object({ name: v.string().required() }),
-            },
-        }, async (ctx, params) => {
-            return params.name;
-        });
-        try {
-            // @ts-expect-error - intentionally passing invalid params
-            await TestValidation({}, {}); // Missing required 'name' param
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureValidationError);
-            expect(e.definedAt).toBeDefined();
-            expect(e.definedAt.file).toContain('index.test.ts');
-            expect(e.definedAt.line).toBeGreaterThan(0);
-            expect(e.definedAt.column).toBeGreaterThan(0);
-            expect(e.stack).toContain('--- Procedure "TestValidation" defined at ---');
-        }
-    });
-    test('ctx.error() includes definition location', async () => {
-        const { Create } = Procedures();
-        const { TestCtxError } = Create('TestCtxError', {}, async (ctx) => {
-            throw ctx.error('Custom error');
-        });
-        try {
-            await TestCtxError({}, {});
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureError);
-            expect(e.definedAt).toBeDefined();
-            expect(e.definedAt.file).toContain('index.test.ts');
-            expect(e.getDefinitionLocation()).toBeDefined();
-            expect(e.stack).toContain('--- Procedure "TestCtxError" defined at ---');
-        }
-    });
-    test('wrapped errors include definition location', async () => {
-        const { Create } = Procedures();
-        const { TestWrappedError } = Create('TestWrappedError', {}, async () => {
-            throw new Error('Original error');
-        });
-        try {
-            await TestWrappedError({}, {});
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureError);
-            expect(e.definedAt).toBeDefined();
-            expect(e.definedAt.file).toContain('index.test.ts');
-            expect(e.message).toContain('Error in handler for TestWrappedError');
-            expect(e.cause).toBeInstanceOf(Error);
-            expect(e.cause.message).toBe('Original error');
-        }
-    });
-    test('getDefinitionLocation returns formatted string', async () => {
-        const { Create } = Procedures();
-        const { TestGetLocation } = Create('TestGetLocation', {
-            schema: {
-                params: v.object({ id: v.number().required() }),
-            },
-        }, async (ctx, params) => {
-            return params.id;
-        });
-        try {
-            // @ts-expect-error - intentionally passing invalid params
-            await TestGetLocation({}, {}); // Missing required 'id' param
-        }
-        catch (e) {
-            const location = e.getDefinitionLocation();
-            expect(location).toBeDefined();
-            expect(location).toMatch(/index\.test\.ts:\d+:\d+/);
-        }
-    });
-    test('error stack shows procedure definition location at the end', async () => {
-        const { Create } = Procedures();
-        const { TestStackFormat } = Create('TestStackFormat', {
-            schema: {
-                params: v.object({ value: v.string().required() }),
-            },
-        }, async (ctx, params) => {
-            return params.value;
-        });
-        try {
-            // @ts-expect-error - intentionally passing invalid params
-            await TestStackFormat({}, {});
-        }
-        catch (e) {
-            // Verify it's a validation error
-            expect(e.name).toBe('ProcedureValidationError');
-            expect(e).toBeInstanceOf(ProcedureValidationError);
-            // Stack should contain the error message and definition location
-            expect(e.stack).toContain('Validation error for TestStackFormat');
-            expect(e.stack).toContain('--- Procedure "TestStackFormat" defined at ---');
-            // The definition section should be at the end of the stack
-            const stackLines = e.stack.split('\n');
-            const definitionIndex = stackLines.findIndex((line) => line.includes('--- Procedure "TestStackFormat" defined at ---'));
-            expect(definitionIndex).toBeGreaterThan(0);
-        }
-    });
-});
-describe('Streaming Procedures - CreateStream', () => {
-    test('CreateStream creates a streaming procedure', async () => {
-        const { CreateStream } = Procedures();
-        const { StreamTest, procedure, info } = CreateStream('StreamTest', {
-            description: 'Test streaming procedure',
-            schema: {
-                params: v.object({ count: v.number().required() }),
-                yieldType: v.object({ value: v.number().required() }),
-            },
-        }, async function* (ctx, params) {
-            for (let i = 0; i < params.count; i++) {
-                yield { value: i };
-            }
-        });
-        expect(StreamTest).toBeDefined();
-        expect(procedure).toBeDefined();
-        expect(info.isStream).toBe(true);
-        expect(info.name).toBe('StreamTest');
-        expect(info.description).toBe('Test streaming procedure');
-        expect(info.schema.params).toEqual({
-            type: 'object',
-            properties: { count: { type: 'number' } },
-            required: ['count'],
-        });
-        expect(info.schema.yieldType).toEqual({
-            type: 'object',
-            properties: { value: { type: 'number' } },
-            required: ['value'],
-        });
-        // Collect yielded values
-        const values = [];
-        for await (const val of StreamTest({}, { count: 3 })) {
-            values.push(val);
-        }
-        expect(values).toEqual([{ value: 0 }, { value: 1 }, { value: 2 }]);
-    });
-    test('CreateStream validates params', async () => {
-        const { CreateStream } = Procedures();
-        const { StreamWithParams } = CreateStream('StreamWithParams', {
-            schema: {
-                params: v.object({ name: v.string().required() }),
-                yieldType: v.string(),
-            },
-        }, async function* (ctx, params) {
-            yield params.name;
-        });
-        // Missing required param should throw ProcedureValidationError
-        try {
-            // @ts-expect-error - intentionally passing invalid params
-            for await (const _val of StreamWithParams({}, {})) {
-                // Should not reach here
-            }
-            expect.fail('Should have thrown');
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureValidationError);
-            expect(e.message).toContain('Validation error for StreamWithParams');
-        }
-    });
-    test('CreateStream with validateYields validates each yielded value', async () => {
-        const { CreateStream } = Procedures();
-        const { ProcedureYieldValidationError } = await import('./errors.js');
-        const { StreamValidateYields } = CreateStream('StreamValidateYields', {
-            schema: {
-                yieldType: v.object({ id: v.number().required() }),
-            },
-            validateYields: true,
-        }, async function* () {
-            yield { id: 1 }; // Valid
-            yield { id: 'not-a-number' }; // Invalid - should throw
-        });
-        const values = [];
-        try {
-            for await (const val of StreamValidateYields({}, {})) {
-                values.push(val);
-            }
-            expect.fail('Should have thrown on invalid yield');
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureYieldValidationError);
-            expect(e.message).toContain('Yield validation error for StreamValidateYields');
-            expect(values).toEqual([{ id: 1 }]); // First value was valid
-        }
-    });
-    test('CreateStream without validateYields does not validate yields', async () => {
-        const { CreateStream } = Procedures();
-        const { StreamNoValidate } = CreateStream('StreamNoValidate', {
-            schema: {
-                yieldType: v.object({ id: v.number().required() }),
-            },
-            // validateYields defaults to false
-        }, async function* () {
-            yield { id: 1 };
-            yield { id: 'not-a-number' }; // Invalid but won't throw
-        });
-        const values = [];
-        for await (const val of StreamNoValidate({}, {})) {
-            values.push(val);
-        }
-        expect(values).toEqual([{ id: 1 }, { id: 'not-a-number' }]);
-    });
-    test('CreateStream ctx.error throws ProcedureError', async () => {
-        const { CreateStream } = Procedures();
-        const { StreamError } = CreateStream('StreamError', {}, async function* (ctx) {
-            yield 'first';
-            throw ctx.error('Custom stream error', { code: 'STREAM_ERR' });
-        });
-        const values = [];
-        try {
-            for await (const val of StreamError({}, {})) {
-                values.push(val);
-            }
-            expect.fail('Should have thrown');
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureError);
-            expect(e.message).toBe('Custom stream error');
-            expect(e.procedureName).toBe('StreamError');
-            expect(e.meta).toEqual({ code: 'STREAM_ERR' });
-            expect(values).toEqual(['first']);
-        }
-    });
-    test('CreateStream provides ctx.signal for abort handling', async () => {
-        const { CreateStream } = Procedures();
-        let signalReceived = false;
-        const { StreamWithSignal } = CreateStream('StreamWithSignal', {}, async function* (ctx) {
-            expect(ctx.signal).toBeDefined();
-            expect(ctx.signal).toBeInstanceOf(AbortSignal);
-            signalReceived = true;
-            yield 'value';
-        });
-        for await (const _val of StreamWithSignal({}, {})) {
-            // consume
-        }
-        expect(signalReceived).toBe(true);
-    });
-    test('CreateStream appears in getProcedures with isStream flag', () => {
+    test('CreateStream appears in getProcedures with kind: rpc-stream', () => {
         const { Create, CreateStream, getProcedures } = Procedures();
         Create('RegularProc', {}, async () => 'regular');
         CreateStream('StreamProc', {}, async function* () {
@@ -605,316 +88,41 @@ describe('Streaming Procedures - CreateStream', () => {
         expect(procs.length).toBe(2);
         const regular = procs.find((p) => p.name === 'RegularProc');
         const stream = procs.find((p) => p.name === 'StreamProc');
-        expect(regular?.isStream).toBeUndefined();
-        expect(stream?.isStream).toBe(true);
+        expect(regular?.kind).toBe('rpc');
+        expect(stream?.kind).toBe('rpc-stream');
     });
-    test('CreateStream onCreate callback receives isStream flag', () => new Promise((done) => {
-        let receivedProc;
-        const { CreateStream } = Procedures({
+});
+describe('builder.config.noRuntimeValidation', () => {
+    test('noRuntimeValidation does not interfere with onCreate callback', async () => {
+        const seen = [];
+        const { Create } = Procedures({
+            config: { noRuntimeValidation: true },
             onCreate: (proc) => {
-                receivedProc = proc;
+                seen.push(proc.name);
             },
         });
-        CreateStream('OnCreateStream', {}, async function* () {
-            yield 'test';
-        });
-        expect(receivedProc).toBeDefined();
-        expect(receivedProc.isStream).toBe(true);
-        expect(receivedProc.name).toBe('OnCreateStream');
-        done();
-    }));
-    test('CreateStream duplicate registration throws', () => {
-        const { CreateStream } = Procedures();
-        CreateStream('DuplicateStream', {}, async function* () {
-            yield 'first';
-        });
-        expect(() => {
-            CreateStream('DuplicateStream', {}, async function* () {
-                yield 'second';
-            });
-        }).toThrow('Procedure with name DuplicateStream is already registered');
-    });
-    test('CreateStream error includes definition location', async () => {
-        const { CreateStream } = Procedures();
-        const { StreamErrorLocation } = CreateStream('StreamErrorLocation', {
-            schema: {
-                params: v.object({ id: v.number().required() }),
-            },
-        }, async function* () {
-            yield 'test';
-        });
-        try {
-            // @ts-expect-error - intentionally passing invalid params
-            for await (const _val of StreamErrorLocation({}, {})) {
-                // consume
-            }
-            expect.fail('Should have thrown');
-        }
-        catch (e) {
-            expect(e.definedAt).toBeDefined();
-            expect(e.definedAt.file).toContain('index.test.ts');
-            expect(e.stack).toContain('--- Procedure "StreamErrorLocation" defined at ---');
-        }
-    });
-    test('CreateStream with Typebox schema', async () => {
-        const { CreateStream } = Procedures();
-        const { TypeboxStream } = CreateStream('TypeboxStream', {
-            schema: {
-                params: Type.Object({ limit: Type.Number() }),
-                yieldType: Type.Object({ data: Type.String() }),
-            },
-        }, async function* (ctx, params) {
-            for (let i = 0; i < params.limit; i++) {
-                yield { data: `item-${i}` };
-            }
-        });
-        const values = [];
-        for await (const val of TypeboxStream({}, { limit: 2 })) {
-            values.push(val);
-        }
-        expect(values).toEqual([{ data: 'item-0' }, { data: 'item-1' }]);
-    });
-    test('CreateStream with context type', async () => {
-        const { CreateStream } = Procedures();
-        const { ContextStream } = CreateStream('ContextStream', {}, async function* (ctx) {
-            // ctx should have both userId and error
-            expect(ctx.userId).toBe('user-123');
-            expect(ctx.error).toBeDefined();
-            expect(ctx.signal).toBeDefined();
-            yield ctx.userId;
-        });
-        const values = [];
-        for await (const val of ContextStream({ userId: 'user-123' }, {})) {
-            values.push(val);
-        }
-        expect(values).toEqual(['user-123']);
-    });
-    test('CreateStream rethrows the original error preserving class identity', async () => {
-        // The streaming wrapper must NOT box user errors inside ProcedureError —
-        // doing so would defeat route-declared typed-error dispatch on the client
-        // (the HTTP builder's taxonomy would see `ProcedureError` instead of the
-        // user's class). Stack annotation is added in place; class identity and
-        // custom properties are preserved.
-        class MyDomainError extends Error {
-            name = 'MyDomainError';
-            code = 'STREAM_FAIL';
-        }
-        const { CreateStream } = Procedures();
-        const originalError = new MyDomainError('Stream underlying error');
-        const { StreamCause } = CreateStream('StreamCause', {}, 
-        // eslint-disable-next-line require-yield
-        async function* () {
-            throw originalError;
-        });
-        try {
-            for await (const _val of StreamCause({}, {})) {
-                // consume
-            }
-            expect.fail('Should have thrown');
-        }
-        catch (e) {
-            expect(e).toBe(originalError);
-            expect(e).toBeInstanceOf(MyDomainError);
-            expect(e.code).toBe('STREAM_FAIL');
-        }
-    });
-    test('CreateStream propagates .return() to the user generator', async () => {
-        // Consumers that close a stream early (via `iterator.return()` or breaking
-        // out of for-await) must trigger the user generator's `finally` block so
-        // cleanup (db handles, subscriptions, signal-driven teardown) runs.
-        const { CreateStream } = Procedures();
-        let finallyRan = false;
-        const { EarlyClose } = CreateStream('EarlyClose', {}, async function* () {
-            try {
-                yield 1;
-                yield 2;
-                yield 3;
-            }
-            finally {
-                finallyRan = true;
-            }
-        });
-        const iter = EarlyClose({}, {});
-        const first = await iter.next();
-        expect(first.value).toBe(1);
-        await iter.return(undefined);
-        expect(finallyRan).toBe(true);
-    });
-    test('CreateStream with extended config', () => {
-        const { CreateStream } = Procedures();
-        const { info } = CreateStream('ExtendedStream', {
-            scope: 'api',
-            version: 1,
-            description: 'Extended config stream',
-        }, async function* () {
-            yield 'data';
-        });
-        expect(info.scope).toBe('api');
-        expect(info.version).toBe(1);
-        expect(info.description).toBe('Extended config stream');
-        expect(info.isStream).toBe(true);
-    });
-    test('CreateStream signal.aborted becomes true after generator completes', async () => {
-        const { CreateStream } = Procedures();
-        let capturedSignal = null;
-        const { AbortStream } = CreateStream('AbortStream', {}, async function* (ctx) {
-            capturedSignal = ctx.signal;
-            yield 'value';
-        });
-        // Consume the generator
-        for await (const _val of AbortStream({}, {})) {
-            // consume
-        }
-        // After generator completes, signal should be aborted
-        expect(capturedSignal).not.toBeNull();
-        expect(capturedSignal.aborted).toBe(true);
-    });
-    test('CreateStream signal.reason is stream-completed after normal completion', async () => {
-        const { CreateStream } = Procedures();
-        let capturedSignal = null;
-        const { ReasonStream } = CreateStream('ReasonStream', {}, async function* (ctx) {
-            capturedSignal = ctx.signal;
-            yield 'value';
-        });
-        for await (const _val of ReasonStream({}, {})) {
-            // consume
-        }
-        expect(capturedSignal.reason).toBe('stream-completed');
+        Create('Registered', { schema: { params: Type.Object({ id: Type.String() }) } }, async (_ctx, params) => params);
+        expect(seen).toEqual(['Registered']);
     });
-    test('CreateStream combines external signal with internal signal', async () => {
-        const { CreateStream } = Procedures();
-        const externalAc = new AbortController();
-        let capturedSignal = null;
-        const { CombinedStream } = CreateStream('CombinedStream', {}, async function* (ctx) {
-            capturedSignal = ctx.signal;
-            // Combined signal is a new object, not the raw external signal
-            expect(ctx.signal).not.toBe(externalAc.signal);
-            yield 'value';
-        });
-        // Abort external before consuming — combined signal should reflect it
-        externalAc.abort('client-disconnected');
-        for await (const _val of CombinedStream({ signal: externalAc.signal }, {})) {
-            // consume
-        }
-        expect(capturedSignal.aborted).toBe(true);
-        // Reason comes from external abort, not internal 'stream-completed'
-        expect(capturedSignal.reason).toBe('client-disconnected');
+    test('noRuntimeValidation: false is rejected by the type system', () => {
+        // @ts-expect-error - only `true` (or omitted) is allowed for noRuntimeValidation
+        void Procedures({ config: { noRuntimeValidation: false } });
     });
 });
-describe('isPrevalidated context property', () => {
-    test('Create skips validation when ctx.isPrevalidated is true', async () => {
-        const { Create } = Procedures();
-        const { SkipValidation } = Create('SkipValidation', {
-            schema: {
-                params: v.object({ name: v.string().required() }),
-            },
-        }, async (ctx, params) => {
-            return params;
-        });
-        // Without isPrevalidated, missing required param would throw
-        // With isPrevalidated: true, validation is skipped
-        const result = await SkipValidation({ isPrevalidated: true }, {});
-        expect(result).toEqual({});
-    });
-    test('Create validates when ctx.isPrevalidated is false', async () => {
-        const { Create } = Procedures();
-        const { ValidateParams } = Create('ValidateParams', {
-            schema: {
-                params: v.object({ name: v.string().required() }),
-            },
-        }, async (ctx, params) => {
-            return params;
-        });
-        // With isPrevalidated: false, validation should still run
-        try {
-            await ValidateParams({ isPrevalidated: false }, {});
-            expect.fail('Should have thrown validation error');
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureValidationError);
-        }
-    });
-    test('Create validates when ctx.isPrevalidated is undefined', async () => {
-        const { Create } = Procedures();
-        const { ValidateUndefined } = Create('ValidateUndefined', {
-            schema: {
-                params: v.object({ id: v.number().required() }),
-            },
-        }, async (ctx, params) => {
-            return params;
-        });
-        // Without isPrevalidated property, validation should run
-        try {
-            await ValidateUndefined({}, {});
-            expect.fail('Should have thrown validation error');
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureValidationError);
-        }
-    });
-    test('CreateStream skips validation when ctx.isPrevalidated is true', async () => {
-        const { CreateStream } = Procedures();
-        const { StreamSkipValidation } = CreateStream('StreamSkipValidation', {
-            schema: {
-                params: v.object({ count: v.number().required() }),
-            },
-        }, async function* (ctx, params) {
-            yield { received: params };
-        });
-        // With isPrevalidated: true, validation is skipped even with invalid params
-        const values = [];
-        for await (const val of StreamSkipValidation({ isPrevalidated: true }, {})) {
-            values.push(val);
-        }
-        expect(values).toEqual([{ received: {} }]);
-    });
-    test('CreateStream validates when ctx.isPrevalidated is false', async () => {
-        const { CreateStream } = Procedures();
-        const { StreamValidate } = CreateStream('StreamValidate', {
-            schema: {
-                params: v.object({ count: v.number().required() }),
-            },
-        }, async function* (ctx, params) {
-            yield { received: params };
-        });
-        // With isPrevalidated: false, validation should run
-        try {
-            for await (const _val of StreamValidate({ isPrevalidated: false }, {})) {
-                // consume
-            }
-            expect.fail('Should have thrown validation error');
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureValidationError);
-        }
-    });
-    test('CreateStream validates when ctx.isPrevalidated is undefined', async () => {
-        const { CreateStream } = Procedures();
-        const { StreamValidateUndefined } = CreateStream('StreamValidateUndefined', {
-            schema: {
-                params: v.object({ value: v.string().required() }),
-            },
-        }, async function* (ctx, params) {
-            yield params;
-        });
-        // Without isPrevalidated property, validation should run
-        try {
-            for await (const _val of StreamValidateUndefined({}, {})) {
-                // consume
-            }
-            expect.fail('Should have thrown validation error');
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ProcedureValidationError);
-        }
-    });
-    test('isPrevalidated is not exposed in handler context type', async () => {
-        const { Create } = Procedures();
-        Create('CheckCtxType', {}, async (ctx) => {
-            // @ts-expect-error - isPrevalidated should not be on handler context type
-            void ctx.isPrevalidated;
-            return 'done';
-        });
+describe('Procedure registration kind discriminant', () => {
+    it('Create produces kind: rpc', () => {
+        const procs = Procedures();
+        procs.Create('Foo', { schema: { params: Type.Object({}) } }, async () => undefined);
+        const reg = procs.getProcedure('Foo');
+        expect(reg?.kind).toBe('rpc');
+    });
+    it('CreateStream produces kind: rpc-stream', () => {
+        const procs = Procedures();
+        procs.CreateStream('Bar', {
+            schema: { params: Type.Object({}), yieldType: Type.Number() },
+        }, async function* () { });
+        const reg = procs.getProcedure('Bar');
+        expect(reg?.kind).toBe('rpc-stream');
     });
 });
 //# sourceMappingURL=index.test.js.map