ts-procedures 7.2.0 → 8.0.0

package/src/index.test.ts

@@ -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', () => {
@@ -16,265 +15,6 @@ describe('Procedures', () => {
     expect(result).toHaveProperty('Create')
   })
 
-  test('Procedures generic context & extended config', () => {
-    interface CustomContext {
-      authToken: string
-    }
-
-    interface ExtendedConfig {
-      customProp: string
-      optionalProp?: number
-    }
-
-    const { Create } = Procedures<CustomContext, ExtendedConfig>()
-
-    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<void>((done) => {
-      let mockHttpCall: any
-
-      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<void>((done) => {
-      let mockHttpCall: any
-
-      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: any
-
-    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<void>((done) => {
-      let mockHttpCall: any
-
-      const { Create } = Procedures({
-        onCreate: ({ handler, config, name }) => {
-          mockHttpCall = (callParams: any) => {
-            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<void>((done) => {
-      let mockHttpCall: any
-
-      const { Create } = Procedures({
-        onCreate: async ({ handler, config, name }) => {
-          mockHttpCall = async (callParams: any) => {
-            if (config.validation?.params) {
-              const { errors } = config.validation.params(callParams)
-              expect(errors).toBeDefined()
-              expect(errors?.length).toEqual(2)
-            }
-
-            try {
-              await handler(callParams, {})
-            } catch (e: any) {
-              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<void>((done) => {
-      let mockHttpCall: any
-
-      const { Create } = Procedures<{
-        testCtx: string
-      }>({
-        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: any) {
-      expect(e).toBeInstanceOf(ProcedureError)
-
-      expect(e.message).toEqual('Local context error')
-      expect(e.procedureName).toEqual('TestProcedureHandlerError')
-    }
-  })
-
   test('Procedures - getRegisteredProcedures', () => {
     const { Create, getProcedures } = Procedures({
       onCreate: () => {
@@ -314,41 +54,6 @@ describe('Procedures', () => {
     })
   })
 
-  test('Procedures - context() throws', async () => {
-    interface CustomContext {
-      authToken: string
-    }
-
-    const { Create } = Procedures<CustomContext>()
-
-    function validateAuthToken(token: string) {
-      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()
 
@@ -359,24 +64,6 @@ describe('Procedures', () => {
     }).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 as any).code = 'ECONNREFUSED'
-
-    const { TestCause } = Create('TestCause', {}, async () => {
-      throw originalError
-    })
-
-    try {
-      await TestCause({}, {})
-    } catch (e: any) {
-      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()
 
@@ -415,377 +102,7 @@ describe('Procedures', () => {
     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: any) {
-      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<{ signal: AbortSignal }>()
-    const externalAc = new AbortController()
-    let capturedSignal: AbortSignal | null = 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<{ signal: AbortSignal }>()
-    const externalAc = new AbortController()
-    let capturedSignal: AbortSignal | null = 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<{ signal: AbortSignal }>()
-    const externalAc = new AbortController()
-    let wasAbortedDuringWork = false
-    const ready = Promise.withResolvers<void>()
-
-    const { LongWork } = Create('LongWork', {}, async (ctx) => {
-      ready.resolve()
-      await new Promise<void>((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: any) {
-      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: any) {
-      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: any) {
-      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: any) {
-      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: any) {
-      // 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: string) =>
-        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: { value: number }[] = []
-    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: any) {
-      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' } as any // Invalid - should throw
-      }
-    )
-
-    const values: any[] = []
-    try {
-      for await (const val of StreamValidateYields({}, {})) {
-        values.push(val)
-      }
-      expect.fail('Should have thrown on invalid yield')
-    } catch (e: any) {
-      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' } as any // Invalid but won't throw
-      }
-    )
-
-    const values: any[] = []
-    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: any[] = []
-    try {
-      for await (const val of StreamError({}, {})) {
-        values.push(val)
-      }
-      expect.fail('Should have thrown')
-    } catch (e: any) {
-      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')
@@ -800,423 +117,50 @@ describe('Streaming Procedures - CreateStream', () => {
     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)
-  })
-
-  test('CreateStream onCreate callback receives isStream flag', () =>
-    new Promise<void>((done) => {
-      let receivedProc: any
-
-      const { CreateStream } = Procedures({
-        onCreate: (proc) => {
-          receivedProc = proc
-        },
-      })
-
-      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: any) {
-      expect(e.definedAt).toBeDefined()
-      expect(e.definedAt.file).toContain('index.test.ts')
-      expect(e.stack).toContain('--- Procedure "StreamErrorLocation" defined at ---')
-    }
+    expect(regular?.kind).toBe('rpc')
+    expect(stream?.kind).toBe('rpc-stream')
   })
+})
 
-  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() }),
-        },
+describe('builder.config.noRuntimeValidation', () => {
+  test('noRuntimeValidation does not interfere with onCreate callback', async () => {
+    const seen: string[] = []
+    const { Create } = Procedures({
+      config: { noRuntimeValidation: true },
+      onCreate: (proc) => {
+        seen.push(proc.name)
       },
-      async function* (ctx, params) {
-        for (let i = 0; i < params.limit; i++) {
-          yield { data: `item-${i}` }
-        }
-      }
-    )
-
-    const values: any[] = []
-    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 () => {
-    interface StreamContext {
-      userId: string
-    }
-
-    const { CreateStream } = Procedures<StreamContext>()
-
-    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: any[] = []
-    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 {
-      readonly name = 'MyDomainError'
-      readonly 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: any) {
-      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', () => {
-    interface ExtConfig {
-      scope: string
-      version: number
-    }
-
-    const { CreateStream } = Procedures<unknown, ExtConfig>()
-
-    const { info } = CreateStream(
-      'ExtendedStream',
-      {
-        scope: 'api',
-        version: 1,
-        description: 'Extended config stream',
-      },
-      async function* () {
-        yield 'data'
-      }
+    Create(
+      'Registered',
+      { schema: { params: Type.Object({ id: Type.String() }) } },
+      async (_ctx, params) => params
     )
 
-    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: AbortSignal | null = 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: AbortSignal | null = 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')
+    expect(seen).toEqual(['Registered'])
   })
 
-  test('CreateStream combines external signal with internal signal', async () => {
-    const { CreateStream } = Procedures<{ signal: AbortSignal }>()
-    const externalAc = new AbortController()
-    let capturedSignal: AbortSignal | null = 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 }, {} as any)
-    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 }, {} as any)
-      expect.fail('Should have thrown validation error')
-    } catch (e: any) {
-      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({}, {} as any)
-      expect.fail('Should have thrown validation error')
-    } catch (e: any) {
-      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: any[] = []
-    for await (const val of StreamSkipValidation({ isPrevalidated: true }, {} as any)) {
-      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 }, {} as any)) {
-        // consume
-      }
-      expect.fail('Should have thrown validation error')
-    } catch (e: any) {
-      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({}, {} as any)) {
-        // consume
-      }
-      expect.fail('Should have thrown validation error')
-    } catch (e: any) {
-      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')
   })
 })