ts-procedures 7.3.0 → 8.1.0

package/src/codegen/targets/kotlin/emit-route-kotlin.test.ts

@@ -34,11 +34,9 @@ describe('emitKotlinRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: {
-        input: {
-          pathParams: { type: 'object' },
-        },
-        returnType: { type: 'object' },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
       },
       errors: [],
     } as unknown as AnyHttpRouteDoc
@@ -64,7 +62,10 @@ describe('emitKotlinRoute', () => {
       name: 'CreateUser',
       method: 'POST',
       fullPath: '/users',
-      schema: { input: { body: { type: 'object' } }, returnType: { type: 'object' } },
+      jsonSchema: {
+        req: { body: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -84,7 +85,10 @@ describe('emitKotlinRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: { input: { pathParams: { type: 'object' } }, returnType: { type: 'object' } },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
       errors: ['NotFound'],
     } as unknown as AnyHttpRouteDoc
 
@@ -103,14 +107,14 @@ describe('emitKotlinRoute', () => {
   it('silently skips error keys with no schema in the envelope map', () => {
     const route = {
       kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users',
-      schema: {}, errors: ['UnknownTaxonomyKey'],
+      jsonSchema: {}, errors: ['UnknownTaxonomyKey'],
     } as unknown as AnyHttpRouteDoc
     const result = emitKotlinRoute(route, createStubKotlinEmitter({}), new Map())
     expect(result.code).not.toContain('object Errors {')
   })
 
   it('returns skipped:true for stream routes', () => {
-    const route = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/users/stream', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/users/stream', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
     const result = emitKotlinRoute(route, createStubKotlinEmitter({}), noErrors)
     expect(result.code).toBe('')
     expect(result.skipped).toBe(true)
@@ -122,9 +126,9 @@ describe('emitKotlinRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: {
-        input: { pathParams: { type: 'object' } },
-        returnType: { type: 'object' },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
       },
       errors: ['NotFound'],
     } as unknown as AnyHttpRouteDoc
@@ -155,13 +159,13 @@ describe('emitKotlinRoute', () => {
       name: 'X',
       method: 'POST',
       fullPath: '/x/:id',
-      schema: {
-        input: {
+      jsonSchema: {
+        req: {
           pathParams: { type: 'object' },
           query: { type: 'object' },
           body: { type: 'object' },
         },
-        returnType: { type: 'object' },
+        res: { body: { type: 'object' } },
       },
       errors: ['Z'],
     } as unknown as AnyHttpRouteDoc
@@ -187,7 +191,7 @@ describe('emitKotlinRoute', () => {
       name: 'X',
       method: 'GET',
       fullPath: '/x',
-      schema: { returnType: { type: 'object' } },
+      jsonSchema: { res: { body: { type: 'object' } } },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -207,13 +211,92 @@ describe('emitKotlinRoute', () => {
     expect(calls[0]!.opts.uncountableWords).toEqual(['data', 'metadata'])
   })
 
+  it('emits ResponseHeaders slot when res.headers is declared on an api route', () => {
+    const route = {
+      kind: 'api',
+      name: 'DownloadUser',
+      method: 'GET',
+      fullPath: '/users/:id/download',
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: {
+          body: { type: 'object' },
+          headers: { type: 'object' },
+        },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      PathParams: ok('@Serializable data class PathParams(val id: String)', 'PathParams'),
+      Response: ok('@Serializable data class Response(val url: String)', 'Response'),
+      ResponseHeaders: ok(
+        '@Serializable\ndata class ResponseHeaders(\n    @SerialName("x-download-token") val xDownloadToken: String,\n)',
+        'ResponseHeaders',
+      ),
+    })
+
+    const result = emitKotlinRoute(route, emitter, noErrors)
+    expect(calls.map((c) => c.opts.rootTypeName)).toEqual(['PathParams', 'Response', 'ResponseHeaders'])
+    expect(result.code).toContain('@SerialName("x-download-token") val xDownloadToken: String')
+  })
+
+  it('does not emit ResponseHeaders when res.headers is absent', () => {
+    const route = {
+      kind: 'api',
+      name: 'GetUser',
+      method: 'GET',
+      fullPath: '/users/:id',
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      PathParams: ok('@Serializable data class PathParams(val id: String)', 'PathParams'),
+      Response: ok('@Serializable data class Response(val id: String)', 'Response'),
+    })
+
+    emitKotlinRoute(route, emitter, noErrors)
+    expect(calls.map((c) => c.opts.rootTypeName)).not.toContain('ResponseHeaders')
+  })
+
+  it('processes http-stream routes (not skipped) and emits Yield/ReturnType slots', () => {
+    const route = {
+      kind: 'http-stream',
+      name: 'TailLogs',
+      method: 'GET',
+      fullPath: '/logs/tail',
+      jsonSchema: {
+        req: { query: { type: 'object' } },
+        yield: { type: 'object' },
+        returnType: { type: 'object' },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      Query: ok('@Serializable data class Query(val filter: String? = null)', 'Query'),
+      Yield: ok('@Serializable data class Yield(val line: String)', 'Yield'),
+      ReturnType: ok('@Serializable data class ReturnType(val count: Long)', 'ReturnType'),
+    })
+
+    const result = emitKotlinRoute(route, emitter, noErrors)
+    expect(result.skipped).toBeFalsy()
+    expect(calls.map((c) => c.opts.rootTypeName)).toEqual(['Query', 'Yield', 'ReturnType'])
+    expect(result.code).toContain('const val method = "GET"')
+    expect(result.code).toContain('const val path = "/logs/tail"')
+  })
+
   it('does not include passthrough keys when caller omits them', () => {
     const route = {
       kind: 'api',
       name: 'X',
       method: 'GET',
       fullPath: '/x',
-      schema: { returnType: { type: 'object' } },
+      jsonSchema: { res: { body: { type: 'object' } } },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 

package/src/codegen/targets/kotlin/emit-scope-kotlin.test.ts

@@ -18,7 +18,10 @@ describe('emitKotlinScope', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: { input: { pathParams: { type: 'object' } }, returnType: { type: 'object' } },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -40,8 +43,8 @@ describe('emitKotlinScope', () => {
   })
 
   it('joins multiple routes inside one scope object', () => {
-    const route1 = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users/:id', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
-    const route2 = { kind: 'api', name: 'CreateUser', method: 'POST', fullPath: '/users', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route1 = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users/:id', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route2 = { kind: 'api', name: 'CreateUser', method: 'POST', fullPath: '/users', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'users', camelCase: 'users', routes: [route1, route2] }
     const emitter = createStubKotlinEmitter({})
 
@@ -60,7 +63,7 @@ describe('emitKotlinScope', () => {
   })
 
   it('threads all 5 passthrough opts to every emitter call', () => {
-    const route = { kind: 'api', name: 'X', method: 'GET', fullPath: '/x', schema: { returnType: { type: 'object' } }, errors: [] } as unknown as AnyHttpRouteDoc
+    const route = { kind: 'api', name: 'X', method: 'GET', fullPath: '/x', jsonSchema: { res: { body: { type: 'object' } } }, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'x', camelCase: 'x', routes: [route] }
 
     const calls: KotlinEmitOptions[] = []
@@ -96,8 +99,8 @@ describe('emitKotlinScope', () => {
   })
 
   it('collects skipped stream-route names', () => {
-    const stream = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/u/stream', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
-    const api = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/u', schema: { returnType: { type: 'object' } }, errors: [] } as unknown as AnyHttpRouteDoc
+    const stream = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/u/stream', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const api = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/u', jsonSchema: { res: { body: { type: 'object' } } }, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'u', camelCase: 'u', routes: [stream, api] }
 
     const emitter = createStubKotlinEmitter({

package/src/codegen/targets/kotlin/integration.test.ts

@@ -61,6 +61,25 @@ describe('kotlin codegen — integration', () => {
         'Query',
         ['kotlinx.serialization.Serializable', 'kotlinx.serialization.SerialName'],
       ),
+
+      // DownloadUser
+      ResponseHeaders: ok(
+        '@Serializable\ndata class ResponseHeaders(\n    @SerialName("x-download-token") val xDownloadToken: String,\n    @SerialName("content-disposition") val contentDisposition: String? = null,\n)',
+        'ResponseHeaders',
+        ['kotlinx.serialization.Serializable', 'kotlinx.serialization.SerialName'],
+      ),
+
+      // WatchUsers (http-stream) — reuses Query and ResponseHeaders stubs from above;
+      // adds Yield and ReturnType which are unique to the stream route.
+      Yield: ok(
+        '@Serializable\ndata class Yield(\n    val id: String,\n    val event: Event,\n) {\n    @Serializable\n    enum class Event {\n        @SerialName("created") CREATED,\n        @SerialName("updated") UPDATED,\n        @SerialName("deleted") DELETED,\n    }\n}',
+        'Yield',
+        ['kotlinx.serialization.Serializable', 'kotlinx.serialization.SerialName'],
+      ),
+      ReturnType: ok(
+        '@Serializable\ndata class ReturnType(\n    val count: Long,\n)',
+        'ReturnType',
+      ),
     })
 
     const files = await runPipeline({

package/src/codegen/targets/swift/__fixtures__/users-golden.swift

@@ -120,4 +120,83 @@ public enum Users {
             }
         }
     }
+
+    public enum DownloadUser {
+        public static let method = "GET"
+        public static let pathTemplate = "/users/{id}/download"
+        public static func path(_ p: PathParams) -> String { return "/users/\(p.id)/download" }
+
+        public struct PathParams: Codable {
+            public let id: String
+        }
+
+        public struct Response: Codable {
+            public let id: String
+            public let name: String
+            public let createdAt: Date
+            public let address: Address
+
+            enum CodingKeys: String, CodingKey {
+                case id, name
+                case createdAt = "created-at"
+                case address
+            }
+
+            public struct Address: Codable {
+                public let street: String
+                public let city: String
+            }
+        }
+
+        public struct ResponseHeaders: Codable {
+            public let xDownloadToken: String
+            public let contentDisposition: String?
+
+            enum CodingKeys: String, CodingKey {
+                case xDownloadToken = "x-download-token"
+                case contentDisposition = "content-disposition"
+            }
+        }
+    }
+
+    public enum WatchUsers {
+        public static let method = "GET"
+        public static let pathTemplate = "/users/watch"
+        public static let path = "/users/watch"
+
+        public struct Query: Codable {
+            public let status: Status?
+            public let limit: Int64?
+
+            public enum Status: String, Codable {
+                case active
+                case inactive
+            }
+        }
+
+        public struct ResponseHeaders: Codable {
+            public let xDownloadToken: String
+            public let contentDisposition: String?
+
+            enum CodingKeys: String, CodingKey {
+                case xDownloadToken = "x-download-token"
+                case contentDisposition = "content-disposition"
+            }
+        }
+
+        public struct Yield: Codable {
+            public let id: String
+            public let event: Event
+
+            public enum Event: String, Codable {
+                case created
+                case updated
+                case deleted
+            }
+        }
+
+        public struct ReturnType: Codable {
+            public let count: Int64
+        }
+    }
 }

package/src/codegen/targets/swift/access-level.test.ts

@@ -28,23 +28,20 @@ const envelope: DocEnvelope = {
       method: 'get',
       path: '/things/:id',
       fullPath: '/things/:id',
-      jsonSchema: {},
-      // The swift route emitter reads `route.schema.input.*` and
-      // `route.schema.returnType` directly; mirror what the codegen
-      // pipeline downstream expects rather than the doc-builder
-      // `jsonSchema` shape.
-      schema: {
-        input: {
+      jsonSchema: {
+        req: {
           pathParams: {
             type: 'object',
             properties: { id: { type: 'string' } },
             required: ['id'],
           },
         },
-        returnType: {
-          type: 'object',
-          properties: { id: { type: 'string' } },
-          required: ['id'],
+        res: {
+          body: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+          },
         },
       },
       errors: [],

package/src/codegen/targets/swift/emit-route-swift.test.ts

@@ -34,11 +34,9 @@ describe('emitSwiftRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: {
-        input: {
-          pathParams: { type: 'object' },
-        },
-        returnType: { type: 'object' },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
       },
       errors: [],
     } as unknown as AnyHttpRouteDoc
@@ -64,7 +62,10 @@ describe('emitSwiftRoute', () => {
       name: 'CreateUser',
       method: 'POST',
       fullPath: '/users',
-      schema: { input: { body: { type: 'object' } }, returnType: { type: 'object' } },
+      jsonSchema: {
+        req: { body: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -84,7 +85,10 @@ describe('emitSwiftRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: { input: { pathParams: { type: 'object' } }, returnType: { type: 'object' } },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
       errors: ['NotFound'],
     } as unknown as AnyHttpRouteDoc
 
@@ -103,14 +107,14 @@ describe('emitSwiftRoute', () => {
   it('silently skips error keys with no schema in the envelope map', () => {
     const route = {
       kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users',
-      schema: {}, errors: ['UnknownTaxonomyKey'],
+      jsonSchema: {}, errors: ['UnknownTaxonomyKey'],
     } as unknown as AnyHttpRouteDoc
     const result = emitSwiftRoute(route, createStubSwiftEmitter({}), new Map())
     expect(result.code).not.toContain('enum Errors {')
   })
 
   it('returns skipped:true for stream routes', () => {
-    const route = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/users/stream', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/users/stream', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
     const result = emitSwiftRoute(route, createStubSwiftEmitter({}), noErrors)
     expect(result.code).toBe('')
     expect(result.skipped).toBe(true)
@@ -122,9 +126,9 @@ describe('emitSwiftRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: {
-        input: { pathParams: { type: 'object' } },
-        returnType: { type: 'object' },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
       },
       errors: ['NotFound'],
     } as unknown as AnyHttpRouteDoc
@@ -157,13 +161,13 @@ describe('emitSwiftRoute', () => {
       name: 'X',
       method: 'POST',
       fullPath: '/x/:id',
-      schema: {
-        input: {
+      jsonSchema: {
+        req: {
           pathParams: { type: 'object' },
           query: { type: 'object' },
           body: { type: 'object' },
         },
-        returnType: { type: 'object' },
+        res: { body: { type: 'object' } },
       },
       errors: ['Z'],
     } as unknown as AnyHttpRouteDoc
@@ -189,7 +193,7 @@ describe('emitSwiftRoute', () => {
       name: 'X',
       method: 'GET',
       fullPath: '/x',
-      schema: { returnType: { type: 'object' } },
+      jsonSchema: { res: { body: { type: 'object' } } },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -209,13 +213,92 @@ describe('emitSwiftRoute', () => {
     expect(calls[0]!.opts.uncountableWords).toEqual(['data', 'metadata'])
   })
 
+  it('emits ResponseHeaders slot when res.headers is declared on an api route', () => {
+    const route = {
+      kind: 'api',
+      name: 'DownloadUser',
+      method: 'GET',
+      fullPath: '/users/:id/download',
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: {
+          body: { type: 'object' },
+          headers: { type: 'object' },
+        },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      PathParams: ok('public struct PathParams: Codable { public let id: String }', 'PathParams'),
+      Response: ok('public struct Response: Codable { public let url: String }', 'Response'),
+      ResponseHeaders: ok(
+        'public struct ResponseHeaders: Codable { public let xDownloadToken: String }',
+        'ResponseHeaders',
+      ),
+    })
+
+    const result = emitSwiftRoute(route, emitter, noErrors)
+    expect(calls.map((c) => c.opts.rootTypeName)).toEqual(['PathParams', 'Response', 'ResponseHeaders'])
+    expect(result.code).toContain('public struct ResponseHeaders: Codable { public let xDownloadToken: String }')
+  })
+
+  it('does not emit ResponseHeaders when res.headers is absent', () => {
+    const route = {
+      kind: 'api',
+      name: 'GetUser',
+      method: 'GET',
+      fullPath: '/users/:id',
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      PathParams: ok('public struct PathParams: Codable { public let id: String }', 'PathParams'),
+      Response: ok('public struct Response: Codable { public let id: String }', 'Response'),
+    })
+
+    emitSwiftRoute(route, emitter, noErrors)
+    expect(calls.map((c) => c.opts.rootTypeName)).not.toContain('ResponseHeaders')
+  })
+
+  it('processes http-stream routes (not skipped) and emits Yield/ReturnType slots', () => {
+    const route = {
+      kind: 'http-stream',
+      name: 'TailLogs',
+      method: 'GET',
+      fullPath: '/logs/tail',
+      jsonSchema: {
+        req: { query: { type: 'object' } },
+        yield: { type: 'object' },
+        returnType: { type: 'object' },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      Query: ok('public struct Query: Codable { public let filter: String? }', 'Query'),
+      Yield: ok('public struct Yield: Codable { public let line: String }', 'Yield'),
+      ReturnType: ok('public struct ReturnType: Codable { public let count: Int }', 'ReturnType'),
+    })
+
+    const result = emitSwiftRoute(route, emitter, noErrors)
+    expect(result.skipped).toBeFalsy()
+    expect(calls.map((c) => c.opts.rootTypeName)).toEqual(['Query', 'Yield', 'ReturnType'])
+    expect(result.code).toContain('public static let method = "GET"')
+    expect(result.code).toContain('public static let path = "/logs/tail"')
+  })
+
   it('does not include passthrough keys when caller omits them', () => {
     const route = {
       kind: 'api',
       name: 'X',
       method: 'GET',
       fullPath: '/x',
-      schema: { returnType: { type: 'object' } },
+      jsonSchema: { res: { body: { type: 'object' } } },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -246,7 +329,7 @@ describe('emitSwiftRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: { input: { pathParams: { type: 'object' } } },
+      jsonSchema: { req: { pathParams: { type: 'object' } } },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -265,7 +348,7 @@ describe('emitSwiftRoute', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: { input: { pathParams: { type: 'object' } } },
+      jsonSchema: { req: { pathParams: { type: 'object' } } },
       errors: ['NotFound'],
     } as unknown as AnyHttpRouteDoc
 
@@ -291,7 +374,7 @@ describe('emitSwiftRoute', () => {
       name: 'CreateUser',
       method: 'POST',
       fullPath: '/users',
-      schema: {},
+      jsonSchema: {},
       errors: [],
     } as unknown as AnyHttpRouteDoc
     const result = emitSwiftRoute(route, createStubSwiftEmitter({}), noErrors, { accessLevel: 'internal' })

package/src/codegen/targets/swift/emit-scope-swift.test.ts

@@ -18,7 +18,10 @@ describe('emitSwiftScope', () => {
       name: 'GetUser',
       method: 'GET',
       fullPath: '/users/:id',
-      schema: { input: { pathParams: { type: 'object' } }, returnType: { type: 'object' } },
+      jsonSchema: {
+        req: { pathParams: { type: 'object' } },
+        res: { body: { type: 'object' } },
+      },
       errors: [],
     } as unknown as AnyHttpRouteDoc
 
@@ -41,8 +44,8 @@ describe('emitSwiftScope', () => {
   })
 
   it('joins multiple routes inside one scope enum, separated by a blank line', () => {
-    const route1 = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users/:id', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
-    const route2 = { kind: 'api', name: 'CreateUser', method: 'POST', fullPath: '/users', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route1 = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users/:id', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route2 = { kind: 'api', name: 'CreateUser', method: 'POST', fullPath: '/users', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'users', camelCase: 'users', routes: [route1, route2] }
     const emitter = createStubSwiftEmitter({})
 
@@ -74,8 +77,8 @@ describe('emitSwiftScope', () => {
   })
 
   it('dedupes and sorts imports across all routes in the scope', () => {
-    const route1 = { kind: 'api', name: 'A', method: 'GET', fullPath: '/a', schema: { returnType: { type: 'object' } }, errors: [] } as unknown as AnyHttpRouteDoc
-    const route2 = { kind: 'api', name: 'B', method: 'GET', fullPath: '/b', schema: { returnType: { type: 'object' } }, errors: [] } as unknown as AnyHttpRouteDoc
+    const route1 = { kind: 'api', name: 'A', method: 'GET', fullPath: '/a', jsonSchema: { res: { body: { type: 'object' } } }, errors: [] } as unknown as AnyHttpRouteDoc
+    const route2 = { kind: 'api', name: 'B', method: 'GET', fullPath: '/b', jsonSchema: { res: { body: { type: 'object' } } }, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'multi', camelCase: 'multi', routes: [route1, route2] }
     const emitter = {
       emit(_s: unknown, opts: SwiftEmitOptions): SwiftEmitResult {
@@ -93,7 +96,7 @@ describe('emitSwiftScope', () => {
   })
 
   it('threads all 6 passthrough opts to every emitter call', () => {
-    const route = { kind: 'api', name: 'X', method: 'GET', fullPath: '/x', schema: { returnType: { type: 'object' } }, errors: [] } as unknown as AnyHttpRouteDoc
+    const route = { kind: 'api', name: 'X', method: 'GET', fullPath: '/x', jsonSchema: { res: { body: { type: 'object' } } }, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'x', camelCase: 'x', routes: [route] }
 
     const calls: SwiftEmitOptions[] = []
@@ -130,7 +133,7 @@ describe('emitSwiftScope', () => {
   })
 
   it('applies accessLevel to the outer scope enum and the route enum wrappers', () => {
-    const route = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const route = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/users', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'users', camelCase: 'users', routes: [route] }
     const emitter = createStubSwiftEmitter({})
 
@@ -142,8 +145,8 @@ describe('emitSwiftScope', () => {
   })
 
   it('collects skipped stream-route names', () => {
-    const stream = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/u/stream', schema: {}, errors: [] } as unknown as AnyHttpRouteDoc
-    const api = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/u', schema: { returnType: { type: 'object' } }, errors: [] } as unknown as AnyHttpRouteDoc
+    const stream = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/u/stream', jsonSchema: {}, errors: [] } as unknown as AnyHttpRouteDoc
+    const api = { kind: 'api', name: 'GetUser', method: 'GET', fullPath: '/u', jsonSchema: { res: { body: { type: 'object' } } }, errors: [] } as unknown as AnyHttpRouteDoc
     const group: ScopeGroup = { scopeKey: 'u', camelCase: 'u', routes: [stream, api] }
 
     const emitter = createStubSwiftEmitter({