ts-procedures 8.5.0 → 9.0.0

package/docs/superpowers/specs/2026-06-05-dx-feedback-round-design.md

@@ -1,285 +0,0 @@
-# DX Feedback Round — Design
-
-**Date:** 2026-06-05
-**Status:** Approved (pending spec review)
-**Source:** Downstream-developer feedback from building the demo server (`src/server`), 5 findings.
-
-This round addresses five findings. Each section states the problem, the decision
-taken (with the alternatives considered), and the concrete shape of the change.
-
-Two items are cross-logged but **explicitly out of scope** this round (no scope creep):
-- The `ts-channels` codegen has the identical #3 (per-route inlining) defect — coordinating the two is follow-up.
-- #5 is cross-logged with `ts-channels #9` / `mvc-kit #2` — aligning all three scaffolders is follow-up.
-
----
-
-## #1 — `ts-procedures-codegen --help` (MEDIUM)
-
-### Problem
-`--help` falls through to the unknown-flag branch and exits non-zero with a
-misfiring did-you-mean suggestion (`Did you mean --url?`). There is no usage text
-anywhere in the CLI, so the rich flag surface (`--watch`, `--dry-run`,
-`--enum-style`, Kotlin/Swift targets, …) is undiscoverable without reading the
-built JS.
-
-### Decision: structured flags as the single source of truth
-Replace the bare-string `KNOWN_FLAGS` array (`src/codegen/bin/cli.ts`) with a
-structured table — one entry per flag:
-
-```ts
-interface FlagSpec {
-  name: string            // '--service-name'
-  arg?: string            // '<name>'  (omitted for booleans)
-  description: string     // one line
-  group: 'Source' | 'Output' | 'Codegen' | 'Targets' | 'Misc'
-  default?: string        // shown in help when meaningful, e.g. 'Api'
-}
-```
-
-Derive **both** the validation set (the current `KNOWN_FLAGS` membership check)
-and the `--help` output from this table — adding a flag now documents it and the
-two can never drift. This directly resolves the CLAUDE.md warning that
-`KNOWN_FLAGS` must be hand-synced with `parseArgs`.
-
-Behaviour:
-- `--help` / `-h` / **bare invocation with no args** → print grouped usage
-  (header, usage line, flags grouped by `group` with aligned descriptions and
-  defaults) and **exit 0**.
-- Exclude `--help`/`-h` from the did-you-mean candidate set so the suggestion is
-  never actively misleading.
-
-### Alternatives considered
-- *Hand-written usage block, `KNOWN_FLAGS` stays bare strings.* Rejected:
-  descriptions live apart from the flag list and drift — exactly the duplication
-  the codebase warns against.
-
----
-
-## #2 — Offline doc-envelope emission (LOW)
-
-### Problem
-`--file <path>` codegen works, but nothing *produces* that file. The envelope
-only exists in-process via `builder.toDocEnvelope(cfg)`, so the regen loop forces
-either a running server (`codegen --url`) or a hand-written `JSON.stringify`
-script.
-
-### Decision: exported helper only
-Ship a public, stable helper:
-
-```ts
-export async function writeDocEnvelope(
-  source: DocEnvelope | { toDocEnvelope(): DocEnvelope } | DocRegistry,
-  path: string,
-): Promise<void>
-```
-
-- Accepts a built `HonoAppBuilder`/`DocRegistry` (anything with
-  `toDocEnvelope()`) **or** a plain `DocEnvelope`.
-- Serializes pretty JSON to `path` (creating parent dirs).
-- Exported from a stable entry point and documented with a 3-line script:
-  `build builder → writeDocEnvelope(builder, 'docs.json') → codegen --file docs.json`.
-
-No module-loading magic in the CLI — the user owns the tiny emit script, which is
-the most portable option and avoids a TS-loader dependency.
-
-### Alternatives considered
-- *CLI `--builder <module>` that imports the user's builder in-process.* Rejected
-  for now: importing user TS/ESM requires a loader (tsx/jiti) the package doesn't
-  carry; pushes complexity and failure modes into the CLI.
-
----
-
-## #3 — Shared types keyed on `$id` (MEDIUM)
-
-### Problem
-Codegen inlines a fresh structural literal at every route site. The same `Message`
-entity is emitted ~4× under different names in one scope file
-(`GetThread.Response.Message`, `ListMessages.Response.RootType`,
-`SendMessage.Response.Body`, nested in `CreateThread`), none connected to the
-authored `@shared/schemas` `Message`. The copies type-check only because the
-shapes coincide today; a field change one codegen path misses drifts **silently**.
-
-### Decision: hoist in codegen, leave the envelope untouched
-
-**Architectural call.** The `$id` already rides along on route subschemas in the
-envelope (verified: `Type.Object({…}, { $id, title })` survives `toDocEnvelope()`).
-Rather than change the envelope into a `$defs`/`$ref` table — which would break
-every already-serialized envelope and force the Kotlin/Swift pipelines to become
-`$ref`-aware — the **TS codegen** does a pre-pass over the inlined schemas. Result:
-zero envelope-shape change, zero impact on Kotlin/Swift, already-serialized
-envelopes keep working.
-
-#### Identity rule (correctness-critical)
-- Hoist **only** schemas carrying `$id`. `$id` is the dedup key (globally unique).
-- The generated type **name** comes from `title` (fallback: derive from `$id`).
-- Schemas with a `title` but no `$id` are **not** hoisted — they stay inlined
-  exactly as today. Identity is *declared*, never inferred from structure.
-- If two subschemas share an `$id` but have **divergent bodies** → **hard error**
-  at collect time (never silently pick one).
-- Schemas without `$id` produce byte-identical output to today, so existing
-  consumers who never set `$id` see no change.
-
-#### Components
-1. **`src/codegen/collect-models.ts`** (new) — walks every route's JSON schema
-   recursively (all four route kinds: rpc/api/stream/http-stream slots), collects
-   each subschema carrying `$id` into a model registry
-   `{ $id, name, schema }`. Detects `$id` body-divergence collisions and throws.
-   Also detects generated-name collisions between distinct `$id`s and disambiguates
-   (`Message`, `Message2`, …) deterministically by first-seen order.
-
-2. **`_models.ts`** (new emitted file) — the single hub:
-   - For each model whose `$id` is in the `sharedTypesImport` map → emit a
-     re-export: `export { Message } from '@shared/schemas'` (renamed to the
-     model name if `name` differs).
-   - Otherwise → emit a generated named type for the model schema (via ajsc).
-   - Scopes **always** import from `_models.ts`, regardless of generated-vs-vendored.
-     Flipping a type between the two is a one-line change here with zero scope churn.
-
-3. **`emit-scope` change** — when a route's schema contains a hoisted `$id`
-   subschema, the emitted route type **references** the model's name (import in
-   flat mode, qualified `${Service}Models.Message` in namespace mode) instead of
-   inlining the literal. Non-hoisted subschemas emit unchanged.
-
-4. **`sharedTypesImport` config** (config-file only — a map doesn't fit a CLI flag):
-   ```jsonc
-   // ts-procedures-codegen.config.json
-   "sharedTypesImport": {
-     "https://schemas.example/message": { "module": "@shared/schemas", "name": "Message" }
-   }
-   ```
-
-5. **Flag:** `--share-models` defaults **on** (consistent with the other
-   good-by-default flags); `--no-share-models` opts out and restores pure
-   per-route inlining. Added to the structured flag table from #1.
-
-#### Scope
-- **TS target only.** Kotlin/Swift continue to inline (they simply ignore `$id`
-  metadata; the envelope is unchanged so their pipelines are untouched).
-
-#### Key technical risk — verify first
-The plan opens with a short **verification spike** before committing the emission
-mechanism:
-- **ajsc `$ref` behaviour (v7.2.0):** confirm how ajsc emits a `$ref` to a hoisted
-  model — whether it produces a *reference* to a named type or inlines it. Per
-  CLAUDE.md ajsc "resolves `$defs`/`$ref`", which may mean *inline*. Two paths:
-  - *Preferred:* feed ajsc a route schema with the hoisted subschema replaced by
-    `{ $ref: '#/$defs/Message' }` + a `$defs` table, and capture ajsc's named-type
-    reference.
-  - *Fallback:* emit model types standalone, then post-emit string-substitute the
-    inlined literal with the model name — the same word-boundary patching approach
-    `renameExtractedTypes` (`src/codegen/emit-types.ts`) already uses.
-- **Nested `$id` survival:** confirm `extractJsonSchema` preserves `$id` on
-  **nested** subschemas (root `$id` is verified; nested is not). If stripped, fix
-  extraction to preserve it — this is a prerequisite for hoisting nested entities
-  like `Thread.messages: Message[]`.
-
-### Alternatives considered
-- *Change the envelope to `$defs`/`$ref`.* Rejected: breaks serialized envelopes
-  and forces all targets to become `$ref`-aware.
-- *Hoist into existing `_types.ts`.* Rejected: mixes domain entities with
-  transport/runtime types and only works in self-contained mode.
-- *Per-scope first-declarer-owns.* Rejected: implicit cross-scope ordering/coupling.
-- *Auto-merge structurally-identical types.* Explicitly rejected per the feedback:
-  coincidental shape-equality must not couple two scopes.
-- *Dedup by `$id` OR `title`.* Rejected: two unrelated schemas titled `Response`
-  would wrongly merge — weak identity.
-
----
-
-## #4 — Dynamic auth seam: function-valued headers (MEDIUM)
-
-### Problem
-`config.headers` is a static `Record<string,string>` (`src/client/types.ts:202`),
-captured once at construction. The only dynamic seam is `onBeforeRequest`, which
-is discoverable only by reading `_client.ts`. A live bearer token set in `headers`
-silently goes stale after the next login (the easy-and-wrong path compiles).
-
-### Decision: function-valued headers + signposting docs
-Make `headers` accept a function on both the client `defaults` and per-call options:
-
-```ts
-type HeadersInit =
-  | Record<string, string>
-  | (() => Record<string, string> | Promise<Record<string, string>>)
-```
-
-- `ProcedureCallDefaults.headers` and `ProcedureCallOptions.headers` adopt
-  `HeadersInit` (`src/client/types.ts`).
-- Resolution happens on the **async request path**: `call.ts` / `stream.ts` await
-  header resolution before building the `AdapterRequest`. The static-record path
-  stays synchronous and fast (no behavioural change when headers is a plain object).
-- Merge semantics preserved: resolve defaults-headers and per-call-headers to
-  records, then merge with per-call winning — `onBeforeRequest` still has final say.
-- The resolved `AdapterRequest.headers` remains a plain `Record<string,string>` —
-  adapters are unaffected.
-- Regenerates into self-contained `_types.ts` / `_client.ts`; direct consumers get
-  it from `ts-procedures/client`.
-
-**Docs:** add a short auth section (in the generated-client docs /
-`client-and-codegen.md`) presenting function-valued `headers` and `onBeforeRequest`
-as the canonical auth seams, with an explicit "a token in static `headers` goes
-stale — use a function or the hook" warning.
-
-### Alternatives considered
-- *First-class `auth`/`bearer` option wiring the hook internally.* Not chosen this
-  round — function-valued headers is the general-purpose primitive that also covers
-  auth; a dedicated `auth` sugar can layer on later if wanted.
-- *Docs only.* Rejected: the easy-and-wrong static-headers path still compiles.
-
----
-
-## #5 — Scaffolder file-naming knobs (LOW)
-
-### Problem
-The scaffolder (the AI skill `agent_config/claude-code/skills/ts-procedures/SKILL.md`
-scaffold mode + `templates/*.md`, **not** a CLI) hardcodes `{{Name}}.procedure.ts` —
-PascalCase, one file per procedure — so every scaffold is renamed and folded into a
-per-scope file by hand.
-
-### Decision: `fileNameStyle` + `groupBy` with auto-default
-Add two scaffold-mode args, surfaced in `SKILL.md` and consumed by the templates:
-- `fileNameStyle`: `'PascalCase'` (current) | `'kebab.concern'` (e.g.
-  `get-user.procedure.ts`).
-- `groupBy`: `'flat'` (current, CWD) | `'scope'` (e.g. `<scope>/get-user.procedure.ts`,
-  scope taken from the procedure config).
-
-When **unspecified**, the skill infers the default by inspecting the target
-directory's existing convention (per-scope kebab files vs flat Pascal) — so a
-scaffold matches the consumer's layout with no manual rename pass.
-
-Changes:
-- `SKILL.md` scaffold-mode section: document the two args + the auto-default
-  inference instruction; update the "Files Generated" table to show the computed
-  filename.
-- `templates/*.md`: replace the hardcoded `{{Name}}.<concern>.ts` output with a
-  computed `{{fileName}}` placeholder and an optional `{{scope}}/` directory
-  prefix, plus the placeholder-derivation notes (`{{kebab}}` already exists).
-
-### Alternatives considered
-- *Add knobs, explicit-only (no auto-detect).* Rejected: misses the zero-config
-  match to the repo layout, which is the actual friction.
-- *Defer.* Rejected by scope decision (all three findings actioned this round).
-
----
-
-## Testing strategy
-- **#1:** unit test `--help`/`-h`/bare → exit 0 + usage contains every flag from the
-  table; `--help` not in did-you-mean candidates; unknown flag still errors.
-- **#2:** unit test `writeDocEnvelope` with (a) a plain envelope, (b) a builder-like
-  object — round-trips to disk and re-loads via `resolveEnvelope --file`.
-- **#3:** spike verification first; then fixture-based tests on the canonical
-  `__fixtures__/users-envelope.json` extended with `$id`'d schemas — assert one
-  `_models.ts` declaration per `$id`, route types reference it, `$id` collision
-  throws, `sharedTypesImport` produces re-exports, and `--no-share-models` restores
-  byte-identical legacy output. Add a no-`$id` regression asserting unchanged output.
-- **#4:** unit test function-valued `headers` (sync + async) resolves per request,
-  merges with per-call, and `onBeforeRequest` still overrides; static-record path
-  unchanged.
-- **#5:** verify by scaffolding under each `fileNameStyle`/`groupBy` combination and
-  the auto-default inference (skill-level / template review).
-
-## Out of scope (follow-up)
-- `ts-channels` codegen shared-types fix (identical to #3).
-- Cross-scaffolder alignment with `ts-channels #9` / `mvc-kit #2` (#5).
-- A first-class `auth`/`bearer` client option (sugar over #4).
-- Kotlin/Swift shared-model emission.

package/src/create-http-stream.ts

@@ -1,191 +0,0 @@
-import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError, ProcedureYieldValidationError } from './errors.js'
-import { computeSchema } from './schema/compute-schema.js'
-import type { Prettify, TSchemaLib } from './schema/types.js'
-import { captureDefinitionInfo } from './stack-utils.js'
-import type {
-  HttpMethod, TBuilderConfig, TStreamContext,
-  THttpStreamProcedureRegistration, TProcedureRegistration, TStreamProcedureRegistration, THttpProcedureRegistration,
-} from './types.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: AsyncIterator<any, any, unknown>,
-  validateYields: boolean,
-  validations: { yield?: (value: any) => { errors?: any[] } },
-  abortController: AbortController,
-  definitionInfo: ReturnType<typeof captureDefinitionInfo>,
-  name: string,
-): AsyncGenerator<any, any, unknown> {
-  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: any) {
-    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<TContext>(
-  procedures: Map<string, TProcedureRegistration<TContext, any> | TStreamProcedureRegistration<TContext, any> | THttpProcedureRegistration<TContext> | THttpStreamProcedureRegistration<TContext>>,
-  builder?: { config?: TBuilderConfig; onCreate?: (procedure: any) => void },
-) {
-  return function CreateHttpStream<
-    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> }>,
-  ) {
-    const definitionInfo = captureDefinitionInfo()
-
-    if (procedures.has(name)) throw new Error(`Procedure with name ${name} is already registered`)
-    if ((config.schema as any)?.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 as Record<string, unknown> | undefined,
-      yieldType: config.schema.yield,
-      returnType: config.schema.returnType,
-    }, definitionInfo)
-
-    const pathParamsSchema = (jsonSchema.req as Record<string, unknown> | undefined)?.pathParams
-    checkPathParamConsistency(name, config.path, pathParamsSchema as Record<string, unknown> | undefined, definitionInfo)
-
-    const errorFactory = (message: string, meta?: object) => new ProcedureError(name, message, meta, definitionInfo)
-    const validateYields = config.validateYields ?? false
-
-    const wrappedHandler = async (ctx: TContext, req: any): Promise<{ stream: AsyncGenerator<any, any, unknown>; initialHeaders?: Record<string, string> }> => {
-      const abortController = new AbortController()
-      const skipValidation = (ctx as { isPrevalidated?: boolean }).isPrevalidated || builder?.config?.noRuntimeValidation
-
-      if (validations?.req && !skipValidation) {
-        for (const [channel, validator] of Object.entries(validations.req)) {
-          const channelValue = (req as Record<string, unknown>)?.[channel]
-          const { errors } = validator(channelValue)
-          if (errors) {
-            throw new ProcedureValidationError(name, `Validation error for ${name} in req.${channel}`, errors, definitionInfo)
-          }
-        }
-      }
-
-      const incomingSignal = (ctx as { signal?: AbortSignal }).signal
-      const signal = incomingSignal ? AbortSignal.any([incomingSignal, abortController.signal]) : abortController.signal
-      const streamCtx: TStreamContext = { error: errorFactory, signal }
-
-      const handlerResult: any = (handler as any)({ ...ctx, ...streamCtx }, req)
-
-      if (typeof handlerResult?.[Symbol.asyncIterator] === 'function') {
-        // Plain async generator from user
-        const userIterator = (handlerResult as AsyncGenerator<any, any, unknown>)[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 as AsyncGenerator<any, any, unknown>)[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: THttpStreamProcedureRegistration<TContext> = {
-      name,
-      kind: 'http-stream',
-      config: {
-        path: config.path,
-        method: config.method,
-        scope: config.scope,
-        errors: config.errors as string[] | undefined,
-        description: config.description,
-        schema: jsonSchema as any,
-        validation: { req: validations.req, yield: validations.yield },
-        validateYields,
-      },
-      handler: wrappedHandler as any,
-    }
-
-    procedures.set(name, registeredProcedure as any)
-    builder?.onCreate?.(registeredProcedure)
-
-    const info = { name, kind: 'http-stream' as const, ...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,
-    } as {
-      [K in TName]: (
-        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>
-      }>
-    } & {
-      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: typeof info
-    }
-  }
-}

package/src/create-http.ts

@@ -1,210 +0,0 @@
-import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError } from './errors.js'
-import { computeSchema } from './schema/compute-schema.js'
-import type { Prettify, TSchemaLib } from './schema/types.js'
-import { captureDefinitionInfo } from './stack-utils.js'
-import type {
-  TBuilderConfig,
-  TCreateHttpConfig,
-  TLocalContext,
-  THttpProcedureRegistration,
-  THttpStreamProcedureRegistration,
-  TProcedureRegistration,
-  TStreamProcedureRegistration,
-} from './types.js'
-
-type Infer<T> = TSchemaLib<T>
-
-export type HttpReturn<TRes> =
-  TRes extends { body: infer B; headers: infer H } ? { body: Infer<B>; headers: Infer<H> }
-  : TRes extends { headers: infer H }              ? { headers: Infer<H> }
-  : TRes extends { body: infer B }                 ? Infer<B>
-  : void
-
-const PATH_PARAM_RE = /:([a-zA-Z_][a-zA-Z0-9_]*)/g
-
-function extractPathParamNames(path: string): string[] {
-  const matches = path.match(PATH_PARAM_RE)
-  return matches ? matches.map((m) => m.slice(1)) : []
-}
-
-export function checkPathParamConsistency(
-  procedureName: string,
-  path: string,
-  pathParamsSchema: Record<string, unknown> | undefined,
-  definitionInfo: ReturnType<typeof captureDefinitionInfo>,
-) {
-  const pathParamNames = extractPathParamNames(path)
-  const hasPathParams = pathParamNames.length > 0
-  const hasSchema = pathParamsSchema !== undefined
-
-  if (hasPathParams && !hasSchema) {
-    throw new ProcedureRegistrationError(
-      procedureName,
-      `Path "${path}" has path parameters [${pathParamNames.join(', ')}] but schema.req.pathParams is not defined.`,
-      definitionInfo,
-    )
-  }
-  if (!hasPathParams && hasSchema) {
-    throw new ProcedureRegistrationError(
-      procedureName,
-      `schema.req.pathParams is defined but path "${path}" has no path parameters.`,
-      definitionInfo,
-    )
-  }
-  if (hasPathParams && hasSchema) {
-    const schemaProperties = (pathParamsSchema as { properties?: Record<string, unknown> }).properties
-    if (schemaProperties) {
-      const schemaKeys = Object.keys(schemaProperties)
-      const missing = pathParamNames.filter((p) => !schemaKeys.includes(p))
-      const extra = schemaKeys.filter((k) => !pathParamNames.includes(k))
-      if (missing.length > 0 || extra.length > 0) {
-        const parts: string[] = []
-        if (missing.length > 0) parts.push(`path has [${missing.join(', ')}] missing from schema`)
-        if (extra.length > 0) parts.push(`schema has [${extra.join(', ')}] not in path`)
-        throw new ProcedureRegistrationError(
-          procedureName,
-          `Path param mismatch for "${procedureName}": ${parts.join('; ')}.`,
-          definitionInfo,
-        )
-      }
-    }
-  }
-}
-
-export function makeCreateHttp<TContext>(
-  procedures: Map<
-    string,
-    | TProcedureRegistration<TContext, any>
-    | TStreamProcedureRegistration<TContext, any>
-    | THttpProcedureRegistration<TContext>
-    | THttpStreamProcedureRegistration<TContext>
-  >,
-  builder?: { config?: TBuilderConfig; onCreate?: (procedure: any) => void },
-) {
-  return function CreateHttp<
-    TName extends string,
-    TReq extends Record<string, unknown> | undefined,
-    TRes extends { body?: unknown; headers?: unknown } | undefined = undefined,
-    TErrorKey extends string = string,
-  >(
-    name: TName,
-    config: TCreateHttpConfig<TReq, TRes, TErrorKey>,
-    handler: (
-      ctx: Prettify<TContext & TLocalContext>,
-      req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
-    ) => Promise<HttpReturn<TRes>>,
-  ) {
-    const definitionInfo = captureDefinitionInfo()
-
-    if (procedures.has(name)) {
-      throw new Error(`Procedure with name ${name} is already registered`)
-    }
-
-    if ((config.schema as any)?.params) {
-      throw new ProcedureRegistrationError(
-        name,
-        `Use schema.req.body (or schema.req.query) instead of schema.params on CreateHttp. Procedure: "${name}".`,
-        definitionInfo,
-      )
-    }
-
-    const { jsonSchema, validations } = computeSchema(
-      name,
-      {
-        req: config.schema.req as Record<string, unknown> | undefined,
-        res: config.schema.res as { body?: unknown; headers?: unknown } | undefined,
-      },
-      definitionInfo,
-    )
-
-    const pathParamsSchema = (jsonSchema.req as Record<string, unknown> | undefined)?.pathParams
-    checkPathParamConsistency(
-      name,
-      config.path,
-      pathParamsSchema as Record<string, unknown> | undefined,
-      definitionInfo,
-    )
-
-    const errorFactory = (message: string, meta?: object) =>
-      new ProcedureError(name, message, meta, definitionInfo)
-
-    const registeredProcedure: THttpProcedureRegistration<TContext> = {
-      name,
-      kind: 'http',
-      config: {
-        path: config.path,
-        method: config.method,
-        successStatus: config.successStatus,
-        scope: config.scope,
-        errors: config.errors as string[] | undefined,
-        description: config.description,
-        schema: jsonSchema as any,
-        validation: { req: validations.req },
-      },
-      handler: async (ctx: TContext, req: any) => {
-        try {
-          const skipValidation =
-            (ctx as { isPrevalidated?: boolean }).isPrevalidated ||
-            builder?.config?.noRuntimeValidation
-
-          if (validations?.req && !skipValidation) {
-            for (const [channel, validator] of Object.entries(validations.req)) {
-              const channelValue = (req as Record<string, unknown>)?.[channel]
-              const { errors } = validator(channelValue)
-              if (errors) {
-                throw new ProcedureValidationError(
-                  name,
-                  `Validation error for ${name} in req.${channel}`,
-                  errors,
-                  definitionInfo,
-                )
-              }
-            }
-          }
-
-          const localCtx: TLocalContext = { error: errorFactory }
-          return await handler({ ...ctx, ...localCtx } as any, req)
-        } catch (error: any) {
-          if (error instanceof ProcedureError) throw error
-          const err = new ProcedureError(
-            name,
-            `Error in handler for ${name} - ${error?.message}`,
-            undefined,
-            definitionInfo,
-          )
-          err.cause = error
-          if (error.stack && definitionInfo.definedAt) {
-            const { file, line, column } = definitionInfo.definedAt
-            err.stack =
-              error.stack + `\n--- Procedure "${name}" defined at ---\n    at ${file}:${line}:${column}`
-          } else if (error.stack) {
-            err.stack = error.stack
-          }
-          throw err
-        }
-      },
-    }
-
-    procedures.set(name, registeredProcedure as any)
-    builder?.onCreate?.(registeredProcedure)
-
-    const info = { name, ...registeredProcedure.config }
-
-    return {
-      [name]: registeredProcedure.handler,
-      procedure: registeredProcedure.handler,
-      info,
-    } as {
-      [K in TName]: (
-        ctx: Prettify<TContext>,
-        req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
-      ) => Promise<HttpReturn<TRes>>
-    } & {
-      procedure: (
-        ctx: Prettify<TContext>,
-        req: TReq extends Record<string, unknown> ? Prettify<{ [K in keyof TReq]: TSchemaLib<TReq[K]> }> : undefined,
-      ) => Promise<HttpReturn<TRes>>
-      info: typeof info
-    }
-  }
-}