ts-procedures 8.5.0 → 9.0.0

package/src/server/request/params.ts

@@ -0,0 +1,68 @@
+import type { HttpMethod } from '../types.js'
+import { extractQuery } from './query.js'
+import type { QueryParser } from './query.js'
+
+/** HTTP methods whose requests may carry a body. */
+export const BODY_METHODS: HttpMethod[] = ['post', 'put', 'patch']
+
+/**
+ * Adapter-provided view of an incoming request — the minimal surface needed
+ * to extract `schema.req` channels. Each server adapter implements this once
+ * (e.g. the Hono adapter wraps `Context`).
+ */
+export type RequestSource = {
+  /** Decoded path params (`/users/:id` → `{ id }`). */
+  pathParams(): Record<string, string>
+  /** The full request URL (query extraction slices it). */
+  url(): string
+  /** The parsed JSON body. Only called for body-carrying methods. */
+  json(): Promise<unknown>
+  /** All request headers, lowercased keys. */
+  headers(): Record<string, string>
+}
+
+/**
+ * Extracts the declared `schema.req` channels from a request. Only channels
+ * present in the schema are read — an undeclared body is never parsed, an
+ * undeclared header never observed. Body extraction is skipped for non-body
+ * methods. JSON parse failures yield `{}` (validation then reports the
+ * missing fields, which beats an opaque parse error).
+ */
+export async function extractReqChannels(
+  source: RequestSource,
+  method: HttpMethod,
+  reqSchema: Record<string, unknown>,
+  parser: QueryParser,
+): Promise<Record<string, unknown>> {
+  const params: Record<string, unknown> = {}
+  for (const channel of Object.keys(reqSchema)) {
+    switch (channel) {
+      case 'pathParams':
+        params.pathParams = source.pathParams()
+        break
+      case 'query':
+        params.query = extractQuery(source.url(), parser)
+        break
+      case 'body':
+        if (BODY_METHODS.includes(method)) {
+          params.body = await source.json().catch(() => ({}))
+        }
+        break
+      case 'headers':
+        params.headers = source.headers()
+        break
+      default:
+        params[channel] = undefined
+    }
+  }
+  return params
+}
+
+/** Success-status defaults by method: POST→201, DELETE→204, others→200. */
+export function defaultSuccessStatus(method: HttpMethod): number {
+  switch (method) {
+    case 'post':   return 201
+    case 'delete': return 204
+    default:       return 200
+  }
+}

package/src/server/request/query.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from 'vitest'
+import { extractQuery, parseQueryNative } from './query.js'
+
+describe('parseQueryNative', () => {
+  test('single-value keys remain scalars', () => {
+    expect(parseQueryNative('a=1&b=two')).toEqual({ a: '1', b: 'two' })
+  })
+
+  test('multi-value keys become arrays', () => {
+    expect(parseQueryNative('tag=a&tag=b&tag=c')).toEqual({ tag: ['a', 'b', 'c'] })
+  })
+
+  test('mixes scalars and arrays', () => {
+    expect(parseQueryNative('limit=10&tag=a&tag=b')).toEqual({ limit: '10', tag: ['a', 'b'] })
+  })
+
+  test('empty string parses to an empty object', () => {
+    expect(parseQueryNative('')).toEqual({})
+  })
+
+  test('decodes URL-encoded values (URLSearchParams semantics)', () => {
+    expect(parseQueryNative('q=hello%20world&plus=a+b')).toEqual({
+      q: 'hello world',
+      plus: 'a b',
+    })
+  })
+
+  test('key without a value yields an empty string', () => {
+    expect(parseQueryNative('flag')).toEqual({ flag: '' })
+  })
+})
+
+describe('extractQuery', () => {
+  test('parses the query portion of a URL', () => {
+    expect(extractQuery('http://localhost/users?limit=10&tag=a', parseQueryNative)).toEqual({
+      limit: '10',
+      tag: 'a',
+    })
+  })
+
+  test('returns {} when the URL has no "?"', () => {
+    expect(extractQuery('http://localhost/users', parseQueryNative)).toEqual({})
+  })
+
+  test('returns {} for a trailing "?" with an empty query', () => {
+    expect(extractQuery('http://localhost/users?', parseQueryNative)).toEqual({})
+  })
+
+  test('custom parser receives the raw query string and its result passes through', () => {
+    let receivedRaw: string | undefined
+    const custom = (raw: string) => {
+      receivedRaw = raw
+      return { parsed: true }
+    }
+    const result = extractQuery('http://localhost/p?a=1&b=2', custom)
+    expect(receivedRaw).toBe('a=1&b=2')
+    expect(result).toEqual({ parsed: true })
+  })
+
+  test('custom parser is NOT invoked when there is no query string', () => {
+    let called = false
+    const custom = (raw: string) => {
+      called = true
+      return { raw }
+    }
+    expect(extractQuery('http://localhost/p', custom)).toEqual({})
+    expect(extractQuery('http://localhost/p?', custom)).toEqual({})
+    expect(called).toBe(false)
+  })
+})

package/src/server/request/query.ts

@@ -0,0 +1,24 @@
+/** Parses a raw query string into a params record. */
+export type QueryParser = (queryString: string) => Record<string, unknown>
+
+/**
+ * Default query parser using URLSearchParams. Multi-value keys become arrays;
+ * single-value keys remain scalars (matches browser-native behavior).
+ */
+export function parseQueryNative(queryString: string): Record<string, unknown> {
+  const sp = new URLSearchParams(queryString)
+  const result: Record<string, unknown> = {}
+  for (const key of new Set(sp.keys())) {
+    const values = sp.getAll(key)
+    result[key] = values.length > 1 ? values : values[0]
+  }
+  return result
+}
+
+/** Extracts and parses the query string portion of a URL (empty object when none). */
+export function extractQuery(url: string, parser: QueryParser): Record<string, unknown> {
+  const q = url.indexOf('?')
+  if (q === -1) return {}
+  const raw = url.slice(q + 1)
+  return raw ? parser(raw) : {}
+}

package/src/server/sse.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it, test } from 'vitest'
+import { SseEventSequencer, getSSEMeta, serializeSseValue, sse } from './sse.js'
+
+describe('sse', () => {
+  test('returns the value unchanged (same reference)', () => {
+    const payload = { progress: 0.5 }
+    const result = sse(payload, { event: 'progress' })
+    expect(result).toBe(payload)
+    // Metadata rides in a WeakMap — never on the payload itself.
+    expect(Object.keys(result)).toEqual(['progress'])
+  })
+
+  test('getSSEMeta round-trips the attached options', () => {
+    const payload = sse({ progress: 0.5 }, { event: 'progress', id: 'p-1', retry: 3000 })
+    expect(getSSEMeta(payload)).toEqual({ event: 'progress', id: 'p-1', retry: 3000 })
+  })
+
+  test('defaults to {} when no options are given', () => {
+    const payload = sse({ done: true })
+    expect(getSSEMeta(payload)).toEqual({})
+  })
+
+  test('metadata is per-object — two payloads keep separate options', () => {
+    const a = sse({ n: 1 }, { event: 'a' })
+    const b = sse({ n: 2 }, { event: 'b' })
+    expect(getSSEMeta(a)).toEqual({ event: 'a' })
+    expect(getSSEMeta(b)).toEqual({ event: 'b' })
+  })
+})
+
+describe('getSSEMeta', () => {
+  test('returns undefined for plain (undecorated) objects', () => {
+    expect(getSSEMeta({ progress: 0.5 })).toBeUndefined()
+  })
+
+  test('returns undefined for primitives', () => {
+    expect(getSSEMeta('text')).toBeUndefined()
+    expect(getSSEMeta(42)).toBeUndefined()
+    expect(getSSEMeta(true)).toBeUndefined()
+    expect(getSSEMeta(undefined)).toBeUndefined()
+  })
+
+  test('returns undefined for null', () => {
+    expect(getSSEMeta(null)).toBeUndefined()
+  })
+})
+
+describe('SseEventSequencer', () => {
+  function collector() {
+    const written: Array<{ data: string; event: string; id: string; retry?: number }> = []
+    return { written, write: (e: (typeof written)[number]) => void written.push(e) }
+  }
+
+  async function* gen(values: unknown[], ret?: unknown) {
+    for (const v of values) yield v
+    return ret
+  }
+
+  it('writes yields with the default event and auto-incrementing ids', async () => {
+    const { written, write } = collector()
+    await new SseEventSequencer(write, 'Watch').pump(gen([{ a: 1 }, { a: 2 }]))
+    expect(written).toEqual([
+      { data: '{"a":1}', event: 'Watch', id: '0' },
+      { data: '{"a":2}', event: 'Watch', id: '1' },
+    ])
+  })
+
+  it('sse() metadata overrides event/id/retry on yields', async () => {
+    const { written, write } = collector()
+    const tagged = sse({ p: 1 }, { event: 'progress', id: 'p-1', retry: 5 })
+    await new SseEventSequencer(write, 'Watch').pump(gen([tagged, { p: 2 }]))
+    expect(written[0]).toEqual({ data: '{"p":1}', event: 'progress', id: 'p-1', retry: 5 })
+    // counter not consumed by the custom id — next auto id is still 0
+    expect(written[1]).toEqual({ data: '{"p":2}', event: 'Watch', id: '0' })
+  })
+
+  it('emits the return value as event: return and skips undefined returns', async () => {
+    const { written, write } = collector()
+    await new SseEventSequencer(write, 'W').pump(gen([1], { total: 1 }))
+    expect(written[1]).toEqual({ data: '{"total":1}', event: 'return', id: '1' })
+
+    const second = collector()
+    await new SseEventSequencer(second.write, 'W').pump(gen([1]))
+    expect(second.written).toHaveLength(1)
+  })
+
+  it('writeError continues the id sequence and honors dispatched/meta events', async () => {
+    const { written, write } = collector()
+    const seq = new SseEventSequencer(write, 'W')
+    await seq.writeYield('x')
+    await seq.writeError({ data: { error: 'boom' }, sseEvent: 'error' })
+    expect(written[1]).toEqual({ data: '{"error":"boom"}', event: 'error', id: '1' })
+
+    await seq.writeError({ data: sse({ msg: 'm' }, { event: 'custom-fail' }) })
+    expect(written[2]!.event).toBe('custom-fail')
+  })
+
+  it('serializeSseValue: strings pass through, null/undefined become empty', () => {
+    expect(serializeSseValue('raw')).toBe('raw')
+    expect(serializeSseValue(null)).toBe('')
+    expect(serializeSseValue(undefined)).toBe('')
+    expect(serializeSseValue(7)).toBe('7')
+  })
+
+  it('propagates iterator errors to the caller (dispatch happens outside)', async () => {
+    const { write } = collector()
+    async function* boom() {
+      yield 1
+      throw new Error('mid')
+    }
+    await expect(new SseEventSequencer(write, 'W').pump(boom())).rejects.toThrow('mid')
+  })
+})

package/src/server/sse.ts

@@ -0,0 +1,117 @@
+/**
+ * SSE metadata attachment, shared by every server adapter's stream handlers.
+ */
+export type SSEOptions = {
+  event?: string
+  id?: string
+  retry?: number
+}
+
+const sseMetadata = new WeakMap<object, SSEOptions>()
+
+/**
+ * Marks an object yield as an SSE event with custom metadata. Stream handlers
+ * read this metadata to set the SSE `event:`, `id:`, and `retry:` fields:
+ *
+ * ```ts
+ * yield sse({ progress: 0.5 }, { event: 'progress', id: 'p-1' })
+ * ```
+ *
+ * The value is returned unchanged — metadata rides in a WeakMap, never on
+ * the payload.
+ */
+export function sse<T extends object>(data: T, options?: SSEOptions): T {
+  sseMetadata.set(data, options ?? {})
+  return data
+}
+
+/** Reads metadata attached via {@link sse}. Undefined for plain values. */
+export function getSSEMeta(value: unknown): SSEOptions | undefined {
+  if (typeof value === 'object' && value !== null) {
+    return sseMetadata.get(value as object)
+  }
+  return undefined
+}
+
+/** One wire-ready SSE event, as handed to the adapter's write function. */
+export type SseEvent = {
+  data: string
+  event: string
+  id: string
+  retry?: number
+}
+
+/** Adapter-provided sink (e.g. Hono's `stream.writeSSE`). */
+export type SseWrite = (event: SseEvent) => void | Promise<void>
+
+/** Yield payloads: strings pass through, `null`/`undefined` become empty data. */
+export function serializeSseValue(value: unknown): string {
+  if (typeof value === 'string') return value
+  return value != null ? JSON.stringify(value) : ''
+}
+
+/**
+ * The SSE wire protocol shared by every stream handler: auto-incrementing
+ * event ids, `sse()` metadata overrides, the `event: 'return'` envelope for
+ * the generator's return value, and the error-event shape after mid-stream
+ * dispatch. Adapters supply only the framework write function.
+ */
+export class SseEventSequencer {
+  private eventId = 0
+
+  constructor(
+    private readonly write: SseWrite,
+    /** Event name for yields without `sse()` metadata — the procedure name. */
+    private readonly defaultEvent: string,
+  ) {}
+
+  /** Writes one yielded value; `sse()` metadata overrides event/id/retry. */
+  async writeYield(value: unknown): Promise<void> {
+    const meta = getSSEMeta(value)
+    await this.write({
+      data: serializeSseValue(value),
+      event: meta?.event ?? this.defaultEvent,
+      id: meta?.id ?? String(this.eventId++),
+      ...(meta?.retry !== undefined && { retry: meta.retry }),
+    })
+  }
+
+  /**
+   * Writes the generator's return value as the `event: 'return'` payload
+   * (clients resolve it via `TypedStream.result`). Skipped for `undefined` —
+   * a `void` generator produces no return event.
+   */
+  async writeReturn(value: unknown): Promise<void> {
+    if (value === undefined) return
+    const data = typeof value === 'string' ? value : JSON.stringify(value)
+    await this.write({ data, event: 'return', id: String(this.eventId++) })
+  }
+
+  /**
+   * Writes a dispatched mid-stream error. `sse()` metadata on the payload
+   * (attachable inside `onMidStreamError`) wins over the dispatcher's event.
+   */
+  async writeError(dispatched: { data: unknown; sseEvent?: string }): Promise<void> {
+    const meta = getSSEMeta(dispatched.data)
+    await this.write({
+      data: serializeSseValue(dispatched.data),
+      event: meta?.event ?? dispatched.sseEvent ?? 'error',
+      id: meta?.id ?? String(this.eventId++),
+      ...(meta?.retry !== undefined && { retry: meta.retry }),
+    })
+  }
+
+  /**
+   * Drives a complete stream: every yield, then the return event. Errors from
+   * the iterator propagate to the caller, which dispatches them and writes the
+   * result via {@link writeError} (the id sequence continues across the two).
+   */
+  async pump(iterator: AsyncIterator<unknown, unknown>): Promise<void> {
+    let result = await iterator.next()
+    while (!result.done) {
+      await this.writeYield(result.value)
+      result = await iterator.next()
+    }
+    await this.writeReturn(result.value)
+  }
+}

package/src/{implementations → server}/types.ts

@@ -1,5 +1,13 @@
-import type { Procedures } from '../index.js'
-import type { ErrorTaxonomy } from './http/error-taxonomy.js'
+/**
+ * Transport-agnostic HTTP server types.
+ *
+ * The doc shapes here (`*RouteDoc`, `DocEnvelope`, `ErrorDoc`, `HeaderDoc`)
+ * are a FROZEN wire contract: they are the input to client codegen, and v9
+ * guarantees byte-identical generated output vs v8. Do not change field names,
+ * optionality, or nesting without re-validating the codegen goldens.
+ */
+import type { ProcedureKind } from '../core/types.js'
+import type { ErrorTaxonomy } from './errors/taxonomy.js'
 
 /**
  * @typeParam TErrorKey - Union of valid taxonomy keys. Defaults to `string`
@@ -18,11 +26,6 @@ export interface RPCConfig<TErrorKey extends string = string> {
   errors?: TErrorKey[]
 }
 
-export type FactoryItem<C> = {
-  factory: ReturnType<typeof Procedures<C, RPCConfig>>
-  factoryContext: (req: Request) => C
-}
-
 export interface RPCHttpRouteDoc extends RPCConfig {
   kind: 'rpc'
   name: string // procedure name
@@ -50,7 +53,7 @@ export type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head'
  * typo protection on `errors`.
  */
 export interface APIConfig<TErrorKey extends string = string> {
-  /** HTTP route path (supports Hono path params, e.g., '/users/:id') */
+  /** HTTP route path (supports path params, e.g., '/users/:id') */
   path: string
   /** HTTP method for this endpoint */
   method: HttpMethod
@@ -91,12 +94,12 @@ export interface APIHttpRouteDoc {
 }
 
 /**
- * Constrains schema.input channel names to valid HTTP input sources.
- * Use with `satisfies` or as a type annotation to catch typos at compile time:
+ * Constrains `schema.req` channel names to valid HTTP input sources.
+ * Use with `satisfies` to catch typos at compile time:
  *
  * @example
  * schema: {
- *   input: {
+ *   req: {
  *     pathParams: Type.Object({ id: Type.String() }),
  *     qurey: Type.Object({ ... }), // TS error: 'qurey' not in APIInput
  *   } satisfies APIInput
@@ -184,8 +187,7 @@ export type ExtractConfig<TFactory> = TFactory extends {
 export type ProceduresFactory = {
   getProcedures: () => Array<{
     name: string
-    kind?: import('../types.js').ProcedureKind
-    isStream?: boolean
+    kind?: ProcedureKind
     config: any
     handler: (ctx: any, params?: any) => Promise<any> | AsyncGenerator<any, any, unknown>
   }>
@@ -205,9 +207,8 @@ export interface DocSource<T = AnyHttpRouteDoc> {
   readonly docs: T[]
   /**
    * Optional list of procedures that were registered with this builder but
-   * couldn't be served by it (e.g. a streaming procedure registered with an
-   * RPC builder). DocRegistry aggregates these across sources and warns at
-   * `toJSON()` time so silently-dropped procedures don't slip through.
+   * couldn't be served by it. DocRegistry aggregates these across sources and
+   * warns at `toJSON()` time so silently-dropped procedures don't slip through.
    */
   readonly skippedProcedures?: { name: string; reason: string }[]
 }

package/build/create-http-stream.d.ts

@@ -1,58 +0,0 @@
-import type { Prettify, TSchemaLib } from './schema/types.js';
-import type { HttpMethod, TBuilderConfig, TStreamContext, THttpStreamProcedureRegistration, TProcedureRegistration, TStreamProcedureRegistration, THttpProcedureRegistration } from './types.js';
-export declare function makeCreateHttpStream<TContext>(procedures: Map<string, TProcedureRegistration<TContext, any> | TStreamProcedureRegistration<TContext, any> | THttpProcedureRegistration<TContext> | THttpStreamProcedureRegistration<TContext>>, builder?: {
-    config?: TBuilderConfig;
-    onCreate?: (procedure: any) => void;
-}): <TName extends string, TReq extends Record<string, unknown> | undefined, TYieldType, TReturnType = void, TResHeaders = undefined, TErrorKey extends string = string>(name: TName, config: {
-    path: string;
-    method: HttpMethod;
-    scope?: string;
-    errors?: TErrorKey[];
-    description?: string;
-    schema: {
-        req?: TReq;
-        yield?: TYieldType;
-        returnType?: TReturnType;
-        res?: TResHeaders extends undefined ? undefined : {
-            headers: TResHeaders;
-        };
-    };
-    validateYields?: boolean;
-}, handler: TResHeaders extends undefined ? (ctx: Prettify<TContext & TStreamContext>, req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]>; }> : undefined) => AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown> : (ctx: Prettify<TContext & TStreamContext>, req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]>; }> : undefined) => Promise<{
-    headers: TSchemaLib<TResHeaders>;
-    stream: AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown>;
-}>) => { [K in TName]: (ctx: Prettify<TContext>, req: TReq extends Record<string, unknown> ? Prettify<{ [K_1 in keyof TReq]: TSchemaLib<TReq[K_1]>; }> : undefined) => Promise<{
-    stream: AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown>;
-    initialHeaders?: Record<string, string>;
-}>; } & {
-    procedure: (ctx: Prettify<TContext>, req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]>; }> : undefined) => Promise<{
-        stream: AsyncGenerator<TSchemaLib<TYieldType>, TSchemaLib<TReturnType> | void, unknown>;
-        initialHeaders?: Record<string, string>;
-    }>;
-    info: {
-        path: string;
-        method: HttpMethod;
-        scope?: string;
-        errors?: string[];
-        description?: string;
-        schema?: {
-            req?: Record<string, import("./schema/types.js").TJSONSchema>;
-            res?: {
-                headers?: import("./schema/types.js").TJSONSchema;
-            };
-            yield?: import("./schema/types.js").TJSONSchema;
-            returnType?: import("./schema/types.js").TJSONSchema;
-        };
-        validation?: {
-            req?: Record<string, (value: any) => {
-                errors?: any[];
-            }>;
-            yield?: (value: any) => {
-                errors?: any[];
-            };
-        };
-        validateYields?: boolean;
-        name: TName;
-        kind: "http-stream";
-    };
-};

package/build/create-http-stream.js

@@ -1,122 +0,0 @@
-import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError, ProcedureYieldValidationError } from './errors.js';
-import { computeSchema } from './schema/compute-schema.js';
-import { captureDefinitionInfo } from './stack-utils.js';
-import { checkPathParamConsistency } from './create-http.js';
-/**
- * Wraps a user's AsyncIterator in a generator that:
- * - optionally validates each yielded value
- * - augments error stack traces with the procedure definition site
- * - aborts the stream controller on completion
- */
-async function* yieldingWrapper(userIterator, validateYields, validations, abortController, definitionInfo, name) {
-    try {
-        let result = await userIterator.next();
-        while (!result.done) {
-            const value = result.value;
-            if (validateYields && validations.yield) {
-                const { errors } = validations.yield(value);
-                if (errors)
-                    throw new ProcedureYieldValidationError(name, `Yield validation error for ${name}`, errors, definitionInfo);
-            }
-            yield value;
-            result = await userIterator.next();
-        }
-        return result.value;
-    }
-    catch (error) {
-        if (definitionInfo.definedAt && error && typeof error.stack === 'string') {
-            const { file, line, column } = definitionInfo.definedAt;
-            error.stack = `${error.stack}\n--- Procedure "${name}" defined at ---\n    at ${file}:${line}:${column}`;
-        }
-        throw error;
-    }
-    finally {
-        try {
-            await userIterator.return?.(undefined);
-        }
-        catch { /* swallow */ }
-        abortController.abort('stream-completed');
-    }
-}
-export function makeCreateHttpStream(procedures, builder) {
-    return function CreateHttpStream(name, config, handler) {
-        const definitionInfo = captureDefinitionInfo();
-        if (procedures.has(name))
-            throw new Error(`Procedure with name ${name} is already registered`);
-        if (config.schema?.params) {
-            throw new ProcedureRegistrationError(name, `Use schema.req.body (or schema.req.query) instead of schema.params on CreateHttpStream. Procedure: "${name}".`, definitionInfo);
-        }
-        const { jsonSchema, validations } = computeSchema(name, {
-            req: config.schema.req,
-            yieldType: config.schema.yield,
-            returnType: config.schema.returnType,
-        }, definitionInfo);
-        const pathParamsSchema = jsonSchema.req?.pathParams;
-        checkPathParamConsistency(name, config.path, pathParamsSchema, definitionInfo);
-        const errorFactory = (message, meta) => new ProcedureError(name, message, meta, definitionInfo);
-        const validateYields = config.validateYields ?? false;
-        const wrappedHandler = async (ctx, req) => {
-            const abortController = new AbortController();
-            const skipValidation = ctx.isPrevalidated || builder?.config?.noRuntimeValidation;
-            if (validations?.req && !skipValidation) {
-                for (const [channel, validator] of Object.entries(validations.req)) {
-                    const channelValue = req?.[channel];
-                    const { errors } = validator(channelValue);
-                    if (errors) {
-                        throw new ProcedureValidationError(name, `Validation error for ${name} in req.${channel}`, errors, definitionInfo);
-                    }
-                }
-            }
-            const incomingSignal = ctx.signal;
-            const signal = incomingSignal ? AbortSignal.any([incomingSignal, abortController.signal]) : abortController.signal;
-            const streamCtx = { error: errorFactory, signal };
-            const handlerResult = handler({ ...ctx, ...streamCtx }, req);
-            if (typeof handlerResult?.[Symbol.asyncIterator] === 'function') {
-                // Plain async generator from user
-                const userIterator = handlerResult[Symbol.asyncIterator]();
-                return { stream: yieldingWrapper(userIterator, validateYields, validations, abortController, definitionInfo, name) };
-            }
-            else if (typeof handlerResult?.then === 'function') {
-                // Async preamble: Promise<{ headers, stream }>
-                const resolved = await handlerResult;
-                if (!resolved || typeof resolved !== 'object' || !('stream' in resolved)) {
-                    throw new ProcedureError(name, `CreateHttpStream handler returned a Promise that did not resolve to { headers, stream }. Got: ${JSON.stringify(resolved)}`, undefined, definitionInfo);
-                }
-                const userIterator = resolved.stream[Symbol.asyncIterator]();
-                return {
-                    stream: yieldingWrapper(userIterator, validateYields, validations, abortController, definitionInfo, name),
-                    initialHeaders: resolved.headers,
-                };
-            }
-            else {
-                throw new ProcedureError(name, `CreateHttpStream handler must return an AsyncGenerator or Promise<{ headers, stream }>.`, undefined, definitionInfo);
-            }
-        };
-        const registeredProcedure = {
-            name,
-            kind: 'http-stream',
-            config: {
-                path: config.path,
-                method: config.method,
-                scope: config.scope,
-                errors: config.errors,
-                description: config.description,
-                schema: jsonSchema,
-                validation: { req: validations.req, yield: validations.yield },
-                validateYields,
-            },
-            handler: wrappedHandler,
-        };
-        procedures.set(name, registeredProcedure);
-        builder?.onCreate?.(registeredProcedure);
-        const info = { name, kind: 'http-stream', ...registeredProcedure.config };
-        // Explicit return type — preserves TReq/TYieldType/TReturnType through the public callable.
-        // Do NOT use `typeof registeredProcedure.handler` — that erases generics to `any`.
-        return {
-            [name]: registeredProcedure.handler,
-            procedure: registeredProcedure.handler,
-            info,
-        };
-    };
-}
-//# sourceMappingURL=create-http-stream.js.map

package/build/create-http-stream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-http-stream.js","sourceRoot":"","sources":["../src/create-http-stream.ts"],"names":[],"mappings":"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"}