ts-procedures 8.6.0 → 9.0.0

package/src/server/context.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest'
+import { resolveFactoryContext } from './context.js'
+
+describe('resolveFactoryContext', () => {
+  it('returns a plain value as-is', async () => {
+    const ctx = { db: 'x' }
+    await expect(resolveFactoryContext(ctx, { raw: true })).resolves.toBe(ctx)
+  })
+
+  it('invokes a sync function with the raw request context', async () => {
+    const raw = { url: '/a' }
+    await expect(
+      resolveFactoryContext((r: { url: string }) => ({ from: r.url }), raw),
+    ).resolves.toEqual({ from: '/a' })
+  })
+
+  it('awaits an async function', async () => {
+    await expect(
+      resolveFactoryContext(async () => ({ ready: true }), null),
+    ).resolves.toEqual({ ready: true })
+  })
+})

package/src/server/context.ts

@@ -0,0 +1,18 @@
+/**
+ * A factory context as accepted by server adapters' `register()`: either the
+ * context value itself, or a function deriving it from the adapter's request
+ * context per request (sync or async).
+ */
+export type FactoryContextInit<TContext, TRaw> =
+  | TContext
+  | ((raw: TRaw) => TContext | Promise<TContext>)
+
+/** Resolves a {@link FactoryContextInit} for one request. */
+export async function resolveFactoryContext<TContext, TRaw>(
+  init: FactoryContextInit<TContext, TRaw>,
+  raw: TRaw,
+): Promise<TContext> {
+  return typeof init === 'function'
+    ? await (init as (raw: TRaw) => TContext | Promise<TContext>)(raw)
+    : init
+}

package/src/{doc-envelope.test.ts → server/doc-envelope.test.ts}

@@ -3,12 +3,12 @@ import { readFile, rm, mkdtemp } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { writeDocEnvelope } from './doc-envelope.js'
-import type { DocEnvelope } from './implementations/types.js'
+import type { DocEnvelope } from './types.js'
 
 const envelope: DocEnvelope = { basePath: '', headers: [], errors: [], routes: [] }
 
 describe('writeDocEnvelope', () => {
-  let dir: string
+  let dir: string | undefined
   afterEach(async () => { if (dir) await rm(dir, { recursive: true, force: true }) })
 
   it('writes a plain DocEnvelope as pretty JSON', async () => {

package/src/{doc-envelope.ts → server/doc-envelope.ts}

@@ -1,6 +1,6 @@
 import { mkdir, writeFile } from 'node:fs/promises'
 import { dirname } from 'node:path'
-import type { DocEnvelope } from './implementations/types.js'
+import type { DocEnvelope } from './types.js'
 
 export type DocEnvelopeSource =
   | DocEnvelope

package/src/{implementations/http → server}/doc-registry.test.ts

@@ -1,10 +1,14 @@
 import { describe, expect, it, test, vi, afterEach } from 'vitest'
-import { v } from 'suretype'
 import { Type } from 'typebox'
-import { Procedures } from '../../index.js'
-import { HonoAppBuilder } from './hono/index.js'
+import { Procedures } from '../core/procedures.js'
+import type {
+  THttpStreamProcedureRegistration,
+  TProcedureRegistration,
+} from '../core/types.js'
 import { DocRegistry } from './doc-registry.js'
-import { defineErrorTaxonomy } from './error-taxonomy.js'
+import { defineErrorTaxonomy } from './errors/taxonomy.js'
+import { buildRpcRouteDoc } from './docs/rpc-doc.js'
+import { buildHttpStreamRouteDoc } from './docs/http-stream-doc.js'
 import type {
   AnyHttpRouteDoc,
   RPCHttpRouteDoc,
@@ -13,9 +17,8 @@ import type {
   StreamHttpRouteDoc,
   HttpStreamRouteDoc,
   DocSource,
-  DocEnvelope,
   ErrorDoc,
-} from '../types.js'
+} from './types.js'
 
 // ---------------------------------------------------------------------------
 // Helpers — minimal doc fixtures
@@ -111,17 +114,17 @@ describe('DocRegistry', () => {
       expect(result).toBe(registry)
     })
 
-    test('accepts RPC builder source', () => {
+    test('accepts RPC doc source', () => {
       const registry = new DocRegistry().from(makeSource([rpcDoc]))
       expect(registry.toJSON().routes).toEqual([rpcDoc])
     })
 
-    test('accepts API builder source', () => {
+    test('accepts API doc source', () => {
       const registry = new DocRegistry().from(makeSource([apiDoc]))
       expect(registry.toJSON().routes).toEqual([apiDoc])
     })
 
-    test('accepts Stream builder source', () => {
+    test('accepts Stream doc source', () => {
       const registry = new DocRegistry().from(makeSource([streamDoc]))
       expect(registry.toJSON().routes).toEqual([streamDoc])
     })
@@ -132,13 +135,13 @@ describe('DocRegistry', () => {
       expect(registry.toJSON().routes).toHaveLength(2)
     })
 
-    test('builder not yet built returns empty routes', () => {
+    test('source with no docs yet returns empty routes', () => {
       const emptySource = makeSource<RPCHttpRouteDoc>([])
       const registry = new DocRegistry().from(emptySource)
       expect(registry.toJSON().routes).toEqual([])
     })
 
-    test('same builder twice duplicates routes', () => {
+    test('same source twice duplicates routes', () => {
       const source = makeSource([rpcDoc])
       const registry = new DocRegistry().from(source).from(source)
       expect(registry.toJSON().routes).toHaveLength(2)
@@ -313,7 +316,7 @@ describe('DocRegistry', () => {
   })
 
   // --------------------------------------------------------------------------
-  // taxonomy input + auto-defaults + dedupe (v6.0.1 simplification)
+  // taxonomy input + auto-defaults + dedupe
   // --------------------------------------------------------------------------
   describe('errors: ErrorTaxonomy (polymorphic constructor input)', () => {
     test('accepts an ErrorTaxonomy directly and converts to ErrorDoc[]', () => {
@@ -327,8 +330,8 @@ describe('DocRegistry', () => {
       const envelope = new DocRegistry({ errors: taxonomy }).toJSON()
       const auth = envelope.errors.find((e) => e.name === 'AuthError')
       expect(auth).toBeDefined()
-      expect(auth?.statusCode).toBe(401)
-      expect(auth?.description).toBe('unauthenticated')
+      expect(auth!.statusCode).toBe(401)
+      expect(auth!.description).toBe('unauthenticated')
     })
 
     test('auto-includes framework defaults when errors is a taxonomy', () => {
@@ -495,7 +498,7 @@ describe('DocRegistry', () => {
   // Integration
   // --------------------------------------------------------------------------
   describe('integration', () => {
-    test('multiple builder types composed', () => {
+    test('multiple doc kinds composed', () => {
       const registry = new DocRegistry({
         basePath: '/api',
         headers: [{ name: 'Authorization', description: 'Bearer token', required: false }],
@@ -597,7 +600,10 @@ describe('DocRegistry', () => {
       })
     })
 
-    it('aggregates http-stream routes from HonoAppBuilder', () => {
+    // v8 used a built HonoAppBuilder as the source here; the hono adapter
+    // doesn't exist yet in v9 (Phase 3), so a plain DocSource backed by the
+    // real doc builders takes its place.
+    it('aggregates http-stream routes built from a real procedure registration', () => {
       const procs = Procedures()
       procs.CreateHttpStream('Tail', {
         path: '/streams/logs',
@@ -608,29 +614,29 @@ describe('DocRegistry', () => {
         },
       }, async function* () {})
 
-      const builder = new HonoAppBuilder().register(procs, {})
-      builder.build()
+      const reg = procs.getProcedures()[0]! as THttpStreamProcedureRegistration<any>
+      const source: DocSource = { docs: [buildHttpStreamRouteDoc(reg, undefined)] }
 
-      const registry = new DocRegistry().from(builder)
+      const registry = new DocRegistry().from(source)
       const envelope = registry.toJSON()
       const route = envelope.routes.find((r) => r.name === 'Tail')
-      expect(route?.kind).toBe('http-stream')
+      expect(route).toBeDefined()
+      expect(route!.kind).toBe('http-stream')
     })
 
-    test('accepts a real HonoAppBuilder as source', () => {
+    test('accepts a real RPC registration via a plain DocSource', () => {
       const RPC = Procedures<{ userId: string }, RPCConfig>()
 
       RPC.Create(
         'Ping',
-        { scope: 'ping', version: 1, schema: { params: v.object({ msg: v.string() }) } },
+        { scope: 'ping', version: 1, schema: { params: Type.Object({ msg: Type.String() }) } },
         async (_ctx, params) => params,
       )
 
-      const builder = new HonoAppBuilder()
-      builder.register(RPC, () => ({ userId: '123' }))
-      builder.build()
+      const reg = RPC.getProcedures()[0]! as TProcedureRegistration<any, RPCConfig>
+      const source: DocSource = { docs: [buildRpcRouteDoc(reg, undefined)] }
 
-      const registry = new DocRegistry({ basePath: '/rpc' }).from(builder)
+      const registry = new DocRegistry({ basePath: '/rpc' }).from(source)
       const out = registry.toJSON()
 
       expect(out.basePath).toBe('/rpc')

package/src/{implementations/http → server}/doc-registry.ts

@@ -6,13 +6,13 @@ import type {
   DocSource,
   ErrorDoc,
   HeaderDoc,
-} from '../types.js'
+} from './types.js'
 import {
   PROCEDURE_REGISTRATION_ERROR_DOC,
   defaultErrorTaxonomy,
   taxonomyToErrorDocs,
   type ErrorTaxonomy,
-} from './error-taxonomy.js'
+} from './errors/taxonomy.js'
 
 export type {
   AnyHttpRouteDoc,
@@ -22,7 +22,7 @@ export type {
   DocSource,
   ErrorDoc,
   HeaderDoc,
-} from '../types.js'
+} from './types.js'
 
 function isTaxonomy(input: ErrorTaxonomy | ErrorDoc[]): input is ErrorTaxonomy {
   return !Array.isArray(input)
@@ -38,6 +38,11 @@ function dedupeByName(docs: ErrorDoc[]): ErrorDoc[] {
   return Array.from(byName.values())
 }
 
+/**
+ * Composes route docs from multiple builders into one {@link DocEnvelope}
+ * (multi-app aggregation). Single-app users prefer `builder.toDocEnvelope()`,
+ * which wraps this class.
+ */
 export class DocRegistry {
   private readonly basePath: string
   private readonly headers: HeaderDoc[]
@@ -88,10 +93,9 @@ export class DocRegistry {
       routes = routes.filter(options.filter)
     }
 
-    // Surface coverage gaps — when a builder skipped procedures (e.g. a
-    // streaming procedure registered with HonoAppBuilder), the per-builder
-    // warning fires once at `build()` time, but consumers who only call
-    // `registry.toJSON()` (e.g. to dump the envelope to disk for codegen)
+    // Surface coverage gaps — when a builder skipped procedures, the
+    // per-builder warning fires once at `build()` time, but consumers who only
+    // call `registry.toJSON()` (e.g. to dump the envelope to disk for codegen)
     // wouldn't see it without this aggregate. Single warning per call,
     // suppressed when the env var is set so CI pipelines stay quiet.
     if (process.env.TS_PROCEDURES_SUPPRESS_COVERAGE_WARNINGS !== '1') {

package/src/server/docs/docs.test.ts

@@ -0,0 +1,287 @@
+/**
+ * Doc-builder tests — ported from the doc-builder parts of v8's
+ * route-errors.test.ts (the hono-server parts arrive with the Phase 3
+ * adapter). Covers config.errors propagation onto route docs plus the
+ * core doc shapes each builder emits.
+ */
+import { describe, expect, test } from 'vitest'
+import { Type } from 'typebox'
+import { Procedures } from '../../core/procedures.js'
+import type {
+  THttpProcedureRegistration,
+  THttpStreamProcedureRegistration,
+  TProcedureRegistration,
+  TStreamProcedureRegistration,
+} from '../../core/types.js'
+import type { APIConfig, RPCConfig } from '../types.js'
+import { defineErrorTaxonomy } from '../errors/taxonomy.js'
+import { buildRpcRouteDoc } from './rpc-doc.js'
+import { buildStreamRouteDoc } from './stream-doc.js'
+import { buildHttpRouteDoc } from './http-doc.js'
+import { buildHttpStreamRouteDoc } from './http-stream-doc.js'
+
+class UseCaseError extends Error {
+  constructor(readonly externalMsg: string) {
+    super(externalMsg)
+    this.name = 'UseCaseError'
+    Object.setPrototypeOf(this, UseCaseError.prototype)
+  }
+}
+
+class AuthError extends Error {}
+
+const appErrors = defineErrorTaxonomy({
+  UseCaseError: { class: UseCaseError, statusCode: 422 },
+  AuthError: { class: AuthError, statusCode: 401 },
+})
+
+type AppErrorKey = keyof typeof appErrors & string
+
+// ---------------------------------------------------------------------------
+// Fixture helpers — real registrations built through the core factory
+// ---------------------------------------------------------------------------
+
+function makeRpcReg(config: RPCConfig<AppErrorKey> & { schema?: { params?: unknown; returnType?: unknown } }) {
+  const RPC = Procedures<Record<string, never>, RPCConfig<AppErrorKey>>()
+  RPC.Create('DoThing', config as any, async () => ({}))
+  return RPC.getProcedures()[0]! as TProcedureRegistration<any, RPCConfig>
+}
+
+function makeStreamReg(config: RPCConfig<AppErrorKey> & { schema?: { params?: unknown; yieldType?: unknown; returnType?: unknown } }) {
+  const Stream = Procedures<Record<string, never>, RPCConfig<AppErrorKey>>()
+  Stream.CreateStream('Watch', config as any, async function* () {
+    yield { ok: true }
+  })
+  return Stream.getProcedures()[0]! as TStreamProcedureRegistration<any, RPCConfig>
+}
+
+// ---------------------------------------------------------------------------
+// buildRpcRouteDoc
+// ---------------------------------------------------------------------------
+
+describe('buildRpcRouteDoc', () => {
+  test('copies config.errors onto the route doc', () => {
+    const reg = makeRpcReg({
+      scope: 'things',
+      version: 1,
+      errors: ['UseCaseError'],
+      schema: { params: Type.Object({}) },
+    })
+    const doc = buildRpcRouteDoc(reg, undefined)
+    expect(doc.errors).toEqual(['UseCaseError'])
+  })
+
+  test('omits errors when not declared', () => {
+    const reg = makeRpcReg({ scope: 'things', version: 1 })
+    const doc = buildRpcRouteDoc(reg, undefined)
+    expect(doc.errors).toBeUndefined()
+  })
+
+  test('emits kind, method and the rpc path (with prefix)', () => {
+    const reg = makeRpcReg({ scope: 'userThings', version: 2 })
+    const doc = buildRpcRouteDoc(reg, '/api')
+    expect(doc.kind).toBe('rpc')
+    expect(doc.method).toBe('post')
+    expect(doc.name).toBe('DoThing')
+    expect(doc.path).toBe('/api/user-things/do-thing/2')
+  })
+
+  test('maps schema.params → jsonSchema.body and schema.returnType → jsonSchema.response', () => {
+    const reg = makeRpcReg({
+      scope: 'things',
+      version: 1,
+      schema: {
+        params: Type.Object({ id: Type.String() }),
+        returnType: Type.Object({ ok: Type.Boolean() }),
+      },
+    })
+    const doc = buildRpcRouteDoc(reg, undefined)
+    expect(doc.jsonSchema.body).toMatchObject({ type: 'object' })
+    expect(doc.jsonSchema.response).toMatchObject({ type: 'object' })
+  })
+
+  test('extend() merges extra fields but base fields win', () => {
+    const reg = makeRpcReg({ scope: 'things', version: 1 })
+    const doc = buildRpcRouteDoc(reg, undefined, ({ base }) => ({
+      custom: 'extra',
+      name: `OVERRIDE-${base.name}`,
+    }))
+    expect((doc as unknown as Record<string, unknown>).custom).toBe('extra')
+    expect(doc.name).toBe('DoThing')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildStreamRouteDoc
+// ---------------------------------------------------------------------------
+
+describe('buildStreamRouteDoc', () => {
+  test('copies config.errors onto the route doc', () => {
+    const reg = makeStreamReg({ scope: 'watch', version: 1, errors: ['AuthError'] })
+    const doc = buildStreamRouteDoc(reg, 'sse', undefined)
+    expect(doc.errors).toEqual(['AuthError'])
+  })
+
+  test('omits errors when not declared', () => {
+    const reg = makeStreamReg({ scope: 'watch', version: 1 })
+    const doc = buildStreamRouteDoc(reg, 'sse', undefined)
+    expect(doc.errors).toBeUndefined()
+  })
+
+  test('emits kind, methods (post first for codegen) and streamMode', () => {
+    const reg = makeStreamReg({ scope: 'watch', version: 1 })
+    const doc = buildStreamRouteDoc(reg, 'sse', '/api')
+    expect(doc.kind).toBe('stream')
+    expect(doc.methods).toEqual(['post', 'get'])
+    expect(doc.streamMode).toBe('sse')
+    expect(doc.path).toBe('/api/watch/watch/1')
+  })
+
+  test('sse mode wraps yieldType in the SSE message envelope', () => {
+    const reg = makeStreamReg({
+      scope: 'watch',
+      version: 1,
+      schema: { yieldType: Type.Object({ ok: Type.Boolean() }) },
+    })
+    const doc = buildStreamRouteDoc(reg, 'sse', undefined)
+    const envelope = doc.jsonSchema.yieldType as Record<string, any>
+    expect(envelope.required).toEqual(['data', 'event', 'id'])
+    expect(envelope.properties.data).toMatchObject({ type: 'object' })
+    expect(envelope.properties.event).toEqual({ type: 'string' })
+    expect(envelope.properties.id).toEqual({ type: 'string' })
+    expect(envelope.properties.retry).toEqual({ type: 'number' })
+  })
+
+  test('text mode passes yieldType through unwrapped', () => {
+    const reg = makeStreamReg({
+      scope: 'watch',
+      version: 1,
+      schema: { yieldType: Type.Object({ ok: Type.Boolean() }) },
+    })
+    const doc = buildStreamRouteDoc(reg, 'text', undefined)
+    const yieldType = doc.jsonSchema.yieldType as Record<string, any>
+    expect(yieldType.properties.ok).toMatchObject({ type: 'boolean' })
+    expect(yieldType.properties.data).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildHttpRouteDoc
+// ---------------------------------------------------------------------------
+
+describe('buildHttpRouteDoc', () => {
+  function makeHttpReg() {
+    const HTTP = Procedures()
+    HTTP.CreateHttp(
+      'GetUser',
+      {
+        path: '/users/:id',
+        method: 'get',
+        scope: 'users',
+        successStatus: 200,
+        errors: ['UseCaseError'],
+        schema: {
+          req: { pathParams: Type.Object({ id: Type.String() }) },
+          res: { body: Type.Object({ id: Type.String() }) },
+        },
+      },
+      async (_ctx, req) => ({ id: req.pathParams.id }),
+    )
+    return HTTP.getProcedures()[0]! as THttpProcedureRegistration<any>
+  }
+
+  test('copies config.errors onto the route doc', () => {
+    const doc = buildHttpRouteDoc(makeHttpReg(), undefined)
+    expect(doc.errors).toEqual(['UseCaseError'])
+  })
+
+  test('route doc omits errors when not declared', () => {
+    const HTTP = Procedures()
+    HTTP.CreateHttp(
+      'Ping',
+      { path: '/ping', method: 'get', schema: {} },
+      async () => {},
+    )
+    const reg = HTTP.getProcedures()[0]! as THttpProcedureRegistration<any>
+    const doc = buildHttpRouteDoc(reg, undefined)
+    expect(doc.errors).toBeUndefined()
+  })
+
+  test('resolves fullPath from prefix while keeping the registered path', () => {
+    const doc = buildHttpRouteDoc(makeHttpReg(), '/api')
+    expect(doc.kind).toBe('api')
+    expect(doc.path).toBe('/users/:id')
+    expect(doc.fullPath).toBe('/api/users/:id')
+    expect(doc.method).toBe('get')
+    expect(doc.scope).toBe('users')
+  })
+
+  test('copies successStatus and req/res channel schemas', () => {
+    const doc = buildHttpRouteDoc(makeHttpReg(), undefined)
+    expect(doc.successStatus).toBe(200)
+    expect(doc.jsonSchema.req!.pathParams).toMatchObject({ type: 'object' })
+    expect(doc.jsonSchema.res!.body).toMatchObject({ type: 'object' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildHttpStreamRouteDoc
+// ---------------------------------------------------------------------------
+
+describe('buildHttpStreamRouteDoc', () => {
+  function makeHttpStreamReg(errors?: AppErrorKey[]) {
+    const S = Procedures()
+    S.CreateHttpStream(
+      'Tail',
+      {
+        path: '/streams/logs',
+        method: 'get',
+        errors,
+        schema: {
+          req: { query: Type.Object({ source: Type.String() }) },
+          yield: Type.Object({ line: Type.String() }),
+        },
+      },
+      async function* () {
+        yield { line: 'x' }
+      },
+    )
+    return S.getProcedures()[0]! as THttpStreamProcedureRegistration<any>
+  }
+
+  test('copies config.errors onto the route doc', () => {
+    const doc = buildHttpStreamRouteDoc(makeHttpStreamReg(['AuthError']), undefined)
+    expect(doc.errors).toEqual(['AuthError'])
+  })
+
+  test('omits errors when not declared', () => {
+    const doc = buildHttpStreamRouteDoc(makeHttpStreamReg(), undefined)
+    expect(doc.errors).toBeUndefined()
+  })
+
+  test('emits kind, streamMode sse, fullPath and yield schema', () => {
+    const doc = buildHttpStreamRouteDoc(makeHttpStreamReg(), '/api')
+    expect(doc.kind).toBe('http-stream')
+    expect(doc.streamMode).toBe('sse')
+    expect(doc.path).toBe('/streams/logs')
+    expect(doc.fullPath).toBe('/api/streams/logs')
+    expect(doc.jsonSchema.req!.query).toMatchObject({ type: 'object' })
+    expect(doc.jsonSchema.yield).toMatchObject({ type: 'object' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Compile-time narrowing (ported from route-errors.test.ts)
+// ---------------------------------------------------------------------------
+
+describe('per-route errors declaration', () => {
+  test('compile-time: errors typed as keyof taxonomy narrows valid keys', () => {
+    // TS-only: this test compiles only if the generic narrows correctly.
+    type Narrow = APIConfig<AppErrorKey>['errors']
+    const _valid: Narrow = ['UseCaseError', 'AuthError']
+    // @ts-expect-error - 'NotRegistered' is not in the taxonomy
+    const _invalid: Narrow = ['NotRegistered']
+    expect(_valid).toBeDefined()
+    expect(_invalid).toBeDefined()
+  })
+})

package/src/{implementations/http/hono → server}/docs/http-doc.ts

@@ -1,6 +1,6 @@
-import type { THttpProcedureRegistration } from '../../../../types.js'
-import type { APIHttpRouteDoc } from '../../../types.js'
-import { resolveFullPath } from '../path.js'
+import type { THttpProcedureRegistration } from '../../core/types.js'
+import type { APIHttpRouteDoc } from '../types.js'
+import { resolveFullPath } from '../paths.js'
 
 export function buildHttpRouteDoc(
   procedure: THttpProcedureRegistration<any>,

package/src/{implementations/http/hono → server}/docs/http-stream-doc.ts

@@ -1,6 +1,6 @@
-import type { THttpStreamProcedureRegistration } from '../../../../types.js'
-import type { HttpStreamRouteDoc } from '../../../types.js'
-import { resolveFullPath } from '../path.js'
+import type { THttpStreamProcedureRegistration } from '../../core/types.js'
+import type { HttpStreamRouteDoc } from '../types.js'
+import { resolveFullPath } from '../paths.js'
 
 export function buildHttpStreamRouteDoc(
   procedure: THttpStreamProcedureRegistration<any>,

package/src/{implementations/http/hono → server}/docs/rpc-doc.ts

@@ -1,6 +1,6 @@
-import type { TProcedureRegistration } from '../../../../types.js'
-import type { RPCConfig, RPCHttpRouteDoc } from '../../../types.js'
-import { makeRoutePath } from '../path.js'
+import type { TProcedureRegistration } from '../../core/types.js'
+import type { RPCConfig, RPCHttpRouteDoc } from '../types.js'
+import { makeRoutePath } from '../paths.js'
 
 export function buildRpcRouteDoc(
   procedure: TProcedureRegistration<any, RPCConfig>,

package/src/{implementations/http/hono → server}/docs/stream-doc.ts

@@ -1,6 +1,6 @@
-import type { TStreamProcedureRegistration } from '../../../../types.js'
-import type { RPCConfig, StreamHttpRouteDoc, StreamMode } from '../../../types.js'
-import { makeRoutePath } from '../path.js'
+import type { TStreamProcedureRegistration } from '../../core/types.js'
+import type { RPCConfig, StreamHttpRouteDoc, StreamMode } from '../types.js'
+import { makeRoutePath } from '../paths.js'
 
 export function buildStreamRouteDoc(
   procedure: TStreamProcedureRegistration<any, RPCConfig>,