ts-procedures 8.6.0 → 9.1.0

package/src/codegen/emit/http-stream-route.ts

@@ -0,0 +1,162 @@
+/**
+ * Emitter for `kind: 'http-stream'` routes — structured multi-channel `Req`
+ * types plus `Yield` / `ReturnType` and a `client.stream(...)` callable.
+ */
+import type { HttpStreamRouteDoc } from '../../server/types.js'
+import { renameExtractedTypes } from '../emit-types.js'
+import { toPascalCase } from '../naming.js'
+import type { EmitRouteContext, RouteChunks } from './context.js'
+import { DeclarationCollector } from './declarations.js'
+import { convertBody, convertExtracted, formatSubNamespace, type NamedType } from './format-types.js'
+import { buildCallableJsDoc, buildErrorUnion, injectRouteErrors } from './route-shared.js'
+
+export async function emitHttpStreamRoute(route: HttpStreamRouteDoc, ctx: EmitRouteContext): Promise<RouteChunks> {
+  const pascal = toPascalCase(route.name)
+  const req = route.jsonSchema.req ?? {}
+  const res = route.jsonSchema.res ?? {}
+
+  // Request channels
+  const reqChannelKeys = ['pathParams', 'query', 'body', 'headers'] as const
+  const reqTypes: NamedType[] = []
+  const presentChannels: string[] = []
+
+  for (const channel of reqChannelKeys) {
+    const schema = req[channel]
+    if (schema != null) {
+      reqTypes.push({ shortName: toPascalCase(channel), schema })
+      presentChannels.push(channel)
+    }
+  }
+
+  // Yield + ReturnType
+  const yieldSchema = route.jsonSchema.yield
+  const returnSchema = route.jsonSchema.returnType
+  const resHeadersSchema = res.headers
+
+  const scopeStr = route.scope ?? 'default'
+  const declarations: string[] = []
+  let paramsTypeName = 'void'
+  let yieldTypeName = 'unknown'
+  let returnTypeName = 'void'
+
+  const taken = new Set<string>(['Req', 'Response', 'Yield', 'ReturnType'])
+
+  if (ctx.namespaceTypes) {
+    const nsLines: string[] = []
+
+    // Req sub-namespace
+    const { nsBlock: reqBlock, refs: reqRefs } = await formatSubNamespace(
+      pascal, 'Req', reqTypes, ctx, taken
+    )
+    if (reqBlock) {
+      nsLines.push(reqBlock)
+      // Merged type alias so Req can be used as a generic type arg (same pattern as emitApiRoute)
+      const reqFields = presentChannels
+        .map((ch) => `${ch}: Req.${toPascalCase(ch)}`)
+        .join('; ')
+      nsLines.push(`    export type Req = { ${reqFields} }`)
+    }
+
+    // Response sub-namespace (headers only for http-stream)
+    const resTypes: NamedType[] = [{ shortName: 'Headers', schema: resHeadersSchema }]
+    const { nsBlock: resBlock } = await formatSubNamespace(
+      pascal, 'Response', resTypes, ctx, taken
+    )
+    if (resBlock) nsLines.push(resBlock)
+
+    // Yield and ReturnType directly in the route namespace
+    const directTypes: NamedType[] = [
+      { shortName: 'Yield', schema: yieldSchema },
+      { shortName: 'ReturnType', schema: returnSchema },
+    ]
+    const collector = new DeclarationCollector(`namespace ${pascal}`)
+    for (const { shortName, schema } of directTypes) {
+      if (schema == null) continue
+      const rawResult = await convertExtracted(schema, ctx)
+      if (rawResult == null) continue
+      const result = renameExtractedTypes(rawResult, taken)
+      for (const decl of result.declarations) {
+        const line = collector.accept(decl, '    ')
+        if (line != null) nsLines.push(line)
+      }
+      nsLines.push(`    export type ${shortName} = ${result.body}`)
+    }
+
+    if (nsLines.length > 0) {
+      declarations.push(`  export namespace ${pascal} {\n${nsLines.join('\n')}\n  }`)
+    }
+
+    if (presentChannels.length > 0) {
+      paramsTypeName = `${ctx.scopePascal}.${pascal}.Req`
+    }
+
+    if (yieldSchema != null) yieldTypeName = `${ctx.scopePascal}.${pascal}.Yield`
+    if (returnSchema != null) returnTypeName = `${ctx.scopePascal}.${pascal}.ReturnType`
+  } else {
+    // Flat mode
+    for (const { shortName, schema } of reqTypes) {
+      if (schema == null) continue
+      const flatName = `${pascal}Req${shortName}`
+      const body = await convertBody(schema, ctx)
+      if (body == null) continue
+      declarations.push(`export type ${flatName} = ${body}`)
+    }
+
+    if (presentChannels.length > 0) {
+      const structureFields = presentChannels
+        .map((ch) => `${ch}: ${pascal}Req${toPascalCase(ch)}`)
+        .join('; ')
+      declarations.push(`export type ${pascal}Req = { ${structureFields} }`)
+      paramsTypeName = `${pascal}Req`
+    }
+
+    if (resHeadersSchema != null) {
+      const body = await convertBody(resHeadersSchema, ctx)
+      if (body != null) declarations.push(`export type ${pascal}ResponseHeaders = ${body}`)
+    }
+
+    if (yieldSchema != null) {
+      const body = await convertBody(yieldSchema, ctx)
+      if (body != null) {
+        declarations.push(`export type ${pascal}Yield = ${body}`)
+        yieldTypeName = `${pascal}Yield`
+      }
+    }
+
+    if (returnSchema != null) {
+      const body = await convertBody(returnSchema, ctx)
+      if (body != null) {
+        declarations.push(`export type ${pascal}ReturnType = ${body}`)
+        returnTypeName = `${pascal}ReturnType`
+      }
+    }
+  }
+
+  const callable = [
+    buildCallableJsDoc({
+      methodLabel: route.method.toUpperCase(),
+      path: route.fullPath,
+      errorsRef: null,
+    }),
+    `    ${route.name}(req: ${paramsTypeName}, options?: ProcedureCallOptions): TypedStream<${yieldTypeName}, ${returnTypeName}> {`,
+    `      return client.stream<${yieldTypeName}, ${returnTypeName}>({`,
+    `        name: '${route.name}',`,
+    `        scope: '${scopeStr}',`,
+    `        path: '${route.fullPath}',`,
+    `        method: '${route.method}',`,
+    `        kind: 'http-stream',`,
+    `        streamMode: '${route.streamMode}',`,
+    `        params: req,`,
+    `      }, options)`,
+    `    },`,
+  ].join('\n')
+
+  const hasErrors = injectRouteErrors(
+    declarations,
+    pascal,
+    buildErrorUnion(route.errors, ctx),
+    ctx.namespaceTypes
+  )
+
+  return { typeDeclarations: declarations, callable, hasStream: true, hasErrors }
+}

package/src/codegen/emit/route-shared.ts

@@ -0,0 +1,104 @@
+/**
+ * Helpers shared across the per-kind route emitters: versioned route naming,
+ * the route-level `Errors` union builder/injector, and the callable JSDoc
+ * builder.
+ */
+import { toPascalCase } from '../naming.js'
+import type { EmitRouteContext } from './context.js'
+
+/**
+ * Returns the PascalCase display name for a route, appending `V{version}`
+ * when version > 1. Version 1 produces no suffix for backward compatibility.
+ */
+export function versionedPascal(name: string, version: number | undefined): string {
+  const pascal = toPascalCase(name)
+  if (version != null && version > 1) return `${pascal}V${version}`
+  return pascal
+}
+
+// ---------------------------------------------------------------------------
+// Route-level Errors union injection
+// ---------------------------------------------------------------------------
+
+/**
+ * Builds the body of an `Errors` type union from the route's declared error
+ * keys. Filters to keys actually emitted in `_errors.ts` so generated code
+ * never references undefined types.
+ *
+ * In namespace mode the union uses qualified names (`ApiErrors.UseCaseError`);
+ * in flat mode it uses the bundled wildcard import alias (`_errors.UseCaseError`).
+ * Returns `null` when no keys remain.
+ */
+export function buildErrorUnion(
+  routeErrors: string[] | undefined,
+  ctx: EmitRouteContext
+): string | null {
+  if (!routeErrors || routeErrors.length === 0) return null
+  const available = ctx.errorKeys
+  const filtered = available ? routeErrors.filter((k) => available.has(k)) : routeErrors
+  if (filtered.length === 0) return null
+  const qualify = ctx.namespaceTypes
+    ? (k: string) => `${toPascalCase(ctx.serviceName)}Errors.${k}`
+    : (k: string) => `_errors.${k}`
+  return filtered.map(qualify).join(' | ')
+}
+
+/**
+ * Injects `export type Errors = ...` into an existing route namespace block
+ * (namespace mode) or appends a flat `export type ${pascal}Errors = ...` in
+ * flat mode. An errors-only route (no req/res/params types) has no namespace
+ * block yet, so one is created to house the union — the typed callable always
+ * references `Scope.Route.Errors`, which must resolve (DX #6). Mutates the
+ * `declarations` array in place and returns whether an injection happened.
+ */
+export function injectRouteErrors(
+  declarations: string[],
+  routePascal: string,
+  errorUnion: string | null,
+  namespaceTypes: boolean
+): boolean {
+  if (!errorUnion) return false
+  if (namespaceTypes) {
+    const errorsLine = `    export type Errors = ${errorUnion}\n`
+    const lastDecl = declarations.length > 0 ? declarations[declarations.length - 1]! : null
+    const closingIdx = lastDecl?.lastIndexOf('  }') ?? -1
+    if (lastDecl == null || closingIdx === -1) {
+      declarations.push(`  export namespace ${routePascal} {\n${errorsLine}  }`)
+      return true
+    }
+    declarations[declarations.length - 1] =
+      lastDecl.slice(0, closingIdx) + errorsLine + lastDecl.slice(closingIdx)
+    return true
+  }
+  declarations.push(`export type ${routePascal}Errors = ${errorUnion}`)
+  return true
+}
+
+/**
+ * Builds the multi-line JSDoc comment for a route callable. Surfaces the
+ * second `options` argument (the per-call AbortSignal/timeout seam — DX #8) and,
+ * for routes that declare typed errors, points at the route's `Errors` type and
+ * how to narrow it on the throwing path (DX #10). Indented for placement inside
+ * the bind-object (4 spaces).
+ */
+export function buildCallableJsDoc(opts: {
+  methodLabel: string
+  path: string
+  errorsRef: string | null
+}): string {
+  const lines = [
+    `    /**`,
+    `     * ${opts.methodLabel} ${opts.path}`,
+    `     *`,
+    `     * @param options Optional per-call {@link ProcedureCallOptions} —`,
+    `     *   \`signal\` (cancel on dispose), \`timeout\`, \`headers\`, \`basePath\`.`,
+  ]
+  if (opts.errorsRef) {
+    lines.push(
+      `     * @throws Declared typed errors: {@link ${opts.errorsRef}}. Narrow with`,
+      `     *   \`instanceof\` on the throwing path, or call \`.safe()\` for a \`Result\`.`,
+    )
+  }
+  lines.push(`     */`)
+  return lines.join('\n')
+}

package/src/codegen/emit/rpc-route.ts

@@ -0,0 +1,49 @@
+/**
+ * Emitter for `kind: 'rpc'` routes — bindCallable / bindCallableTyped
+ * callables with `Params` / `Response` (and optional `Errors`) types.
+ */
+import type { RPCHttpRouteDoc } from '../../server/types.js'
+import type { EmitRouteContext, RouteChunks } from './context.js'
+import { formatTypes } from './format-types.js'
+import { buildCallableJsDoc, buildErrorUnion, injectRouteErrors, versionedPascal } from './route-shared.js'
+
+export async function emitRpcRoute(route: RPCHttpRouteDoc, ctx: EmitRouteContext): Promise<RouteChunks> {
+  const pascal = versionedPascal(route.name, route.version)
+
+  const { declarations, refs } = await formatTypes(pascal, [
+    { shortName: 'Params', schema: route.jsonSchema.body },
+    { shortName: 'Response', schema: route.jsonSchema.response },
+  ], ctx)
+
+  const paramsTypeName = refs['Params'] ?? 'void'
+  const responseTypeName = refs['Response'] ?? 'unknown'
+  const scopeStr = Array.isArray(route.scope) ? route.scope.join('-') : route.scope
+
+  const errorUnion = buildErrorUnion(route.errors, ctx)
+  const hasErrors = errorUnion !== null
+  const errorsRef = ctx.namespaceTypes
+    ? `${ctx.scopePascal}.${pascal}.Errors`
+    : `${pascal}Errors`
+  const helperCall = hasErrors
+    ? `client.bindCallableTyped<${paramsTypeName}, ${responseTypeName}, ${errorsRef}>`
+    : `client.bindCallable<${paramsTypeName}, ${responseTypeName}>`
+
+  const callable = [
+    buildCallableJsDoc({
+      methodLabel: route.method.toUpperCase(),
+      path: route.path,
+      errorsRef: hasErrors ? errorsRef : null,
+    }),
+    `    ${pascal}: ${helperCall}({`,
+    `      name: '${pascal}',`,
+    `      scope: '${scopeStr}',`,
+    `      path: '${route.path}',`,
+    `      method: '${route.method}',`,
+    `      kind: 'rpc',`,
+    `    }),`,
+  ].join('\n')
+
+  const hasErrorsInjected = injectRouteErrors(declarations, pascal, errorUnion, ctx.namespaceTypes)
+
+  return { typeDeclarations: declarations, callable, hasStream: false, hasErrors: hasErrorsInjected }
+}

package/src/codegen/emit/scope-file.ts

@@ -0,0 +1,226 @@
+/**
+ * `emitScopeFile` orchestration: dispatches each route to its per-kind
+ * emitter, accumulates type declarations / callables / referenced models,
+ * and assembles the final scope file (namespace or flat mode) with its
+ * import block.
+ */
+import type { ScopeGroup } from '../group-routes.js'
+import type {
+  RPCHttpRouteDoc,
+  APIHttpRouteDoc,
+  StreamHttpRouteDoc,
+  HttpStreamRouteDoc,
+} from '../../server/types.js'
+import type { AjscOptions } from '../emit-types.js'
+import { CODEGEN_HEADER } from '../constants.js'
+import { toPascalCase } from '../naming.js'
+import type { EmitRouteContext, RouteChunks } from './context.js'
+import { indent } from './declarations.js'
+import { emitRpcRoute } from './rpc-route.js'
+import { emitApiRoute } from './api-route.js'
+import { emitStreamRoute } from './stream-route.js'
+import { emitHttpStreamRoute } from './http-stream-route.js'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface EmitScopeOptions {
+  ajsc?: AjscOptions
+  clientImportPath?: string
+  namespaceTypes?: boolean
+  /** Service identifier used to namespace generated error types (defaults to 'Api'). */
+  serviceName?: string
+  /**
+   * Error keys present in the generated `_errors.ts`. Routes may list keys
+   * that aren't emitted (e.g. no schema); those are filtered out at emit time
+   * so generated code never references undefined types.
+   */
+  errorKeys?: Set<string>
+  /**
+   * Maps a model `$id` to its shared model type name (built by the run module
+   * from ALL models — generated and imported). When present and non-empty,
+   * `$id` subschemas are rewritten to `x-named-type` nodes before ajsc; ajsc
+   * emits bare references and reports them via `referencedNamedTypes`, which
+   * drives the `import type { … } from './_models'` line. Absent/empty →
+   * identical inlining behaviour (the conversion wrappers short-circuit so
+   * output is byte-identical for envelopes without models).
+   */
+  idToModelName?: Map<string, string>
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Infers the route kind when the `kind` discriminant is missing.
+ * This provides backward compatibility with servers running older ts-procedures
+ * versions that don't set `kind` on route docs.
+ */
+function inferRouteKind(route: Record<string, unknown>): 'rpc' | 'api' | 'stream' | 'http-stream' {
+  if ('streamMode' in route && 'fullPath' in route) return 'http-stream'
+  if ('streamMode' in route) return 'stream'
+  if ('fullPath' in route) return 'api'
+  return 'rpc'
+}
+
+// ---------------------------------------------------------------------------
+// emitScopeFile
+// ---------------------------------------------------------------------------
+
+/**
+ * Generates a complete TypeScript scope file for a ScopeGroup.
+ *
+ * When `namespaceTypes` is true, types are wrapped in nested TypeScript namespaces
+ * and ajsc runs with `inlineTypes: false` so formatting options (enumStyle, depluralize,
+ * jsdoc, etc.) produce extracted sub-types inside each namespace.
+ */
+export async function emitScopeFile(
+  group: ScopeGroup,
+  options?: EmitScopeOptions,
+): Promise<string> {
+  const {
+    ajsc: ajscOpts,
+    clientImportPath = 'ts-procedures/client',
+    namespaceTypes = false,
+    serviceName = 'Api',
+    errorKeys,
+    idToModelName,
+  } = options ?? {}
+
+  const pascal = toPascalCase(group.camelCase)
+  const referencedModels = new Set<string>()
+  const ctx: EmitRouteContext = {
+    ajsc: ajscOpts,
+    namespaceTypes,
+    scopePascal: pascal,
+    serviceName,
+    errorKeys,
+    idToModelName,
+    referencedModels,
+  }
+
+  const allTypeDeclarations: string[] = []
+  const callables: string[] = []
+  let hasStream = false
+  let scopeHasErrors = false
+
+  for (const route of group.routes) {
+    let chunks: RouteChunks
+    const kind = route.kind ?? inferRouteKind(route as Record<string, unknown>)
+
+    try {
+      if (kind === 'rpc') {
+        chunks = await emitRpcRoute(route as RPCHttpRouteDoc, ctx)
+      } else if (kind === 'api') {
+        chunks = await emitApiRoute(route as APIHttpRouteDoc, ctx)
+      } else if (kind === 'stream') {
+        chunks = await emitStreamRoute(route as StreamHttpRouteDoc, ctx)
+      } else if (kind === 'http-stream') {
+        chunks = await emitHttpStreamRoute(route as HttpStreamRouteDoc, ctx)
+      } else {
+        throw new Error(`Unknown route kind "${kind}"`)
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      throw new Error(
+        `[ts-procedures-codegen] Failed to emit route "${route.name}" (kind: ${kind}, scope: ${group.scopeKey}): ${msg}`
+      )
+    }
+
+    allTypeDeclarations.push(...chunks.typeDeclarations)
+    callables.push(chunks.callable)
+    if (chunks.hasStream) hasStream = true
+    if (chunks.hasErrors) scopeHasErrors = true
+  }
+
+  // Build client import line — Result/ResultNoTyped are no longer referenced
+  // directly in scope files; the bindCallable helpers infer them from ClientInstance.
+  const clientImports = hasStream
+    ? `import type { ClientInstance, ProcedureCallOptions, TypedStream } from '${clientImportPath}'`
+    : `import type { ClientInstance, ProcedureCallOptions } from '${clientImportPath}'`
+
+  // Build _errors import line when at least one route emits an Errors union.
+  // Namespace mode uses the qualified `${Service}Errors` namespace; flat mode
+  // pulls classes in via a wildcard alias (`_errors.UseCaseError`).
+  let errorsImport = ''
+  if (scopeHasErrors) {
+    if (namespaceTypes) {
+      errorsImport = `import type { ${toPascalCase(serviceName)}Errors } from './_errors'`
+    } else {
+      errorsImport = `import type * as _errors from './_errors'`
+    }
+  }
+
+  const callablesBlock = callables.join('\n\n')
+
+  // Assemble the type + callable section for this scope. ajsc already emitted
+  // bare model references (via `x-named-type`); `convertExtracted` / `convertBody`
+  // folded the reported names into `ctx.referencedModels`, which drives the
+  // `_models` import below. No post-pass over the body is needed.
+  let body: string
+  if (namespaceTypes) {
+    // Namespace mode: types AND `bindScope` live inside `export namespace ${pascal}`.
+    // Putting the function inside the namespace makes the merged symbol
+    // value+type, which lets `index.ts` use `export import ${pascal} = …`
+    // under `verbatimModuleSyntax: true`. (A type-only namespace would trip
+    // TS1269/TS1288.) Consumers call `${Pascal}.bindScope(client)`; the
+    // generated `index.ts` factory wires this internally.
+    const callableLines = indent(callablesBlock, '  ')
+    const namespaceMembers = [
+      ...(allTypeDeclarations.length > 0 ? [allTypeDeclarations.join('\n\n')] : []),
+      [
+        '  /** Binds every callable in this scope to a configured client. */',
+        '  export function bindScope(client: ClientInstance) {',
+        '    return {',
+        callableLines,
+        '    }',
+        '  }',
+      ].join('\n'),
+    ].join('\n\n')
+
+    body = [
+      `export namespace ${pascal} {`,
+      namespaceMembers,
+      '}',
+      '',
+    ].join('\n')
+  } else {
+    // Flat mode: types at module level, `bind${pascal}Scope` standalone.
+    const typesBlock = allTypeDeclarations.length > 0
+      ? allTypeDeclarations.join('\n') + '\n'
+      : ''
+
+    body = [
+      '// ── Types ────────────────────────────────────────',
+      '',
+      typesBlock,
+      '// ── Callables ────────────────────────────────────',
+      '',
+      `export function bind${pascal}Scope(client: ClientInstance) {`,
+      '  return {',
+      callablesBlock,
+      '  }',
+      '}',
+      '',
+    ].join('\n')
+  }
+
+  // Build the shared-models import line when any route referenced a `$id` model.
+  // Matches the `_errors` import convention exactly: `'./_models'` with no `.js`.
+  let modelsImport = ''
+  if (referencedModels.size > 0) {
+    const names = [...referencedModels].sort().join(', ')
+    modelsImport = `import type { ${names} } from './_models'`
+  }
+
+  const importsBlock = [clientImports, errorsImport, modelsImport].filter(Boolean).join('\n')
+
+  return [
+    CODEGEN_HEADER,
+    importsBlock,
+    '',
+    body,
+  ].join('\n')
+}

package/src/codegen/emit/stream-route.ts

@@ -0,0 +1,81 @@
+/**
+ * Emitter for `kind: 'stream'` routes — SSE envelope unwrapping for the yield
+ * type plus a `client.stream(...)` callable.
+ */
+import type { StreamHttpRouteDoc } from '../../server/types.js'
+import type { EmitRouteContext, RouteChunks } from './context.js'
+import { formatTypes } from './format-types.js'
+import { buildCallableJsDoc, buildErrorUnion, injectRouteErrors, versionedPascal } from './route-shared.js'
+
+/**
+ * Checks whether a JSON schema looks like an SSE envelope.
+ * SSE envelopes have properties: data, event, id (and optionally retry).
+ */
+function isSseEnvelope(schema: Record<string, unknown>): boolean {
+  const props = schema.properties
+  if (props == null || typeof props !== 'object') return false
+  const keys = Object.keys(props as Record<string, unknown>)
+  return keys.includes('data') && keys.includes('event') && keys.includes('id')
+}
+
+/**
+ * Unwraps an SSE envelope schema to return the inner `data` property schema.
+ * If not an SSE envelope, returns the schema unchanged.
+ */
+function unwrapSseEnvelope(
+  schema: Record<string, unknown>
+): Record<string, unknown> {
+  if (!isSseEnvelope(schema)) return schema
+  const props = schema.properties as Record<string, Record<string, unknown>>
+  const dataSchema = props['data']
+  return dataSchema ?? schema
+}
+
+export async function emitStreamRoute(route: StreamHttpRouteDoc, ctx: EmitRouteContext): Promise<RouteChunks> {
+  const pascal = versionedPascal(route.name, route.version)
+
+  // Unwrap SSE envelope from yieldType
+  let yieldSchema = route.jsonSchema.yieldType
+  if (yieldSchema != null && route.streamMode === 'sse' && isSseEnvelope(yieldSchema)) {
+    yieldSchema = unwrapSseEnvelope(yieldSchema)
+  }
+
+  const { declarations, refs } = await formatTypes(pascal, [
+    { shortName: 'Params', schema: route.jsonSchema.params },
+    { shortName: 'Yield', schema: yieldSchema },
+    { shortName: 'Return', schema: route.jsonSchema.returnType },
+  ], ctx)
+
+  const paramsTypeName = refs['Params'] ?? 'void'
+  const yieldTypeName = refs['Yield'] ?? 'unknown'
+  const returnTypeName = refs['Return'] ?? 'void'
+  const scopeStr = Array.isArray(route.scope) ? route.scope.join('-') : route.scope
+
+  const callable = [
+    buildCallableJsDoc({
+      methodLabel: route.methods.map((m) => m.toUpperCase()).join('|'),
+      path: route.path,
+      errorsRef: null,
+    }),
+    `    ${pascal}(params: ${paramsTypeName}, options?: ProcedureCallOptions): TypedStream<${yieldTypeName}, ${returnTypeName}> {`,
+    `      return client.stream<${yieldTypeName}, ${returnTypeName}>({`,
+    `        name: '${pascal}',`,
+    `        scope: '${scopeStr}',`,
+    `        path: '${route.path}',`,
+    `        method: '${route.methods[0] ?? 'get'}',`,
+    `        kind: 'stream',`,
+    `        streamMode: '${route.streamMode}',`,
+    `        params,`,
+    `      }, options)`,
+    `    },`,
+  ].join('\n')
+
+  const hasErrors = injectRouteErrors(
+    declarations,
+    pascal,
+    buildErrorUnion(route.errors, ctx),
+    ctx.namespaceTypes
+  )
+
+  return { typeDeclarations: declarations, callable, hasStream: true, hasErrors }
+}

package/src/codegen/emit-errors.integration.test.ts

@@ -14,8 +14,8 @@ import { emitErrorsFile } from './emit-errors.js'
 import {
   defineErrorTaxonomy,
   taxonomyToErrorDocs,
-} from '../implementations/http/error-taxonomy.js'
-import type { DocEnvelope } from '../implementations/types.js'
+} from '../server/errors/taxonomy.js'
+import type { DocEnvelope } from '../server/types.js'
 
 describe('generated _errors.ts — runtime behavior', () => {
   const envelope: DocEnvelope = {

package/src/codegen/emit-errors.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { emitErrorsFile } from './emit-errors.js'
-import type { ErrorDoc } from '../implementations/types.js'
+import type { ErrorDoc } from '../server/types.js'
 
 // ---------------------------------------------------------------------------
 // Fixtures

package/src/codegen/emit-errors.ts

@@ -1,5 +1,5 @@
 import { jsonSchemaToTypeBody, type AjscOptions } from './emit-types.js'
-import type { ErrorDoc } from '../implementations/types.js'
+import type { ErrorDoc } from '../server/types.js'
 import { CODEGEN_HEADER } from './constants.js'
 import { toPascalCase } from './naming.js'