ts-procedures 5.4.0 → 5.4.1

package/src/index.test.ts

@@ -1,1194 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { describe, expect, 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({
-      onCreate: () => {
-        return undefined
-      },
-    })
-
-    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: () => {
-        return undefined
-      },
-    })
-
-    Create(
-      'test-docs',
-      {
-        schema: {
-          params: v.object({ name: v.string().required() }),
-          returnType: v.string(),
-        },
-      },
-      async () => {
-        return 'test-docs'
-      }
-    )
-
-    const procedures = getProcedures()
-    const testDocsProcedure = procedures.find((p) => p.name === 'test-docs')
-    expect(testDocsProcedure).toBeDefined()
-    expect(testDocsProcedure?.config?.schema).toEqual({
-      params: {
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-          },
-        },
-        required: ['name'],
-      },
-      returnType: {
-        type: 'string',
-      },
-    })
-  })
-
-  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()
-
-    Create('DuplicateTest', {}, async () => 'first')
-
-    expect(() => {
-      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 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()
-
-    Create('FindMe', {}, async () => 'found')
-
-    const proc = getProcedure('FindMe')
-    expect(proc).toBeDefined()
-    expect(proc?.name).toBe('FindMe')
-
-    expect(getProcedure('NotFound')).toBeUndefined()
-  })
-
-  test('Procedures - removeProcedure allows re-registration', () => {
-    const { Create, removeProcedure, getProcedure } = Procedures()
-
-    Create('Removable', {}, async () => 'v1')
-    expect(getProcedure('Removable')).toBeDefined()
-
-    const removed = removeProcedure('Removable')
-    expect(removed).toBe(true)
-    expect(getProcedure('Removable')).toBeUndefined()
-
-    // Can now re-register
-    Create('Removable', {}, async () => 'v2')
-    expect(getProcedure('Removable')).toBeDefined()
-  })
-
-  test('Procedures - clear removes all procedures', () => {
-    const { Create, getProcedures, clear } = Procedures()
-
-    Create('One', {}, async () => '1')
-    Create('Two', {}, async () => '2')
-    expect(getProcedures().length).toBe(2)
-
-    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: 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', () => {
-    const { Create, CreateStream, getProcedures } = Procedures()
-
-    Create('RegularProc', {}, async () => 'regular')
-
-    CreateStream('StreamProc', {}, async function* () {
-      yield 'stream'
-    })
-
-    const procs = getProcedures()
-    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)
-  })
-
-  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 ---')
-    }
-  })
-
-  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: 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 wrapped errors preserve cause', async () => {
-    const { CreateStream } = Procedures()
-    const originalError = new Error('Stream underlying error')
-    ;(originalError as any).code = 'STREAM_FAIL'
-
-    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).toBeInstanceOf(ProcedureError)
-      expect(e.cause).toBe(originalError)
-      expect(e.cause.code).toBe('STREAM_FAIL')
-    }
-  })
-
-  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'
-      }
-    )
-
-    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')
-  })
-
-  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')
-  })
-})
-
-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 available in handler context', async () => {
-    const { Create } = Procedures()
-    let capturedIsPrevalidated: boolean | undefined
-
-    const { CapturePrevalidated } = Create('CapturePrevalidated', {}, async (ctx) => {
-      capturedIsPrevalidated = ctx.isPrevalidated
-      return 'done'
-    })
-
-    await CapturePrevalidated({ isPrevalidated: true }, {})
-    expect(capturedIsPrevalidated).toBe(true)
-
-    await CapturePrevalidated({ isPrevalidated: false }, {})
-    expect(capturedIsPrevalidated).toBe(false)
-
-    await CapturePrevalidated({}, {})
-    expect(capturedIsPrevalidated).toBeUndefined()
-  })
-})