ts-procedures 6.0.2 → 6.2.0

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

@@ -0,0 +1,300 @@
+import { describe, expect, it } from 'vitest'
+import type { AnyHttpRouteDoc } from '../../../implementations/types.js'
+import { emitSwiftRoute } from './emit-route-swift.js'
+import { createStubSwiftEmitter, type SwiftEmitOptions, type SwiftEmitResult } from './ajsc-adapter.js'
+
+const ok = (code: string, rootTypeName: string): SwiftEmitResult => ({
+  code,
+  rootTypeName,
+  extractedTypeNames: [],
+  imports: ['Foundation'],
+})
+
+const noErrors = new Map<string, unknown>()
+
+interface CapturedCall { schema: unknown; opts: SwiftEmitOptions }
+
+function makeSpyEmitter(results: Record<string, SwiftEmitResult>) {
+  const calls: CapturedCall[] = []
+  const emitter = {
+    emit(schema: unknown, opts: SwiftEmitOptions) {
+      calls.push({ schema, opts })
+      const r = results[opts.rootTypeName]
+      if (r == null) throw new Error(`No stubbed result for "${opts.rootTypeName}"`)
+      return r
+    },
+  }
+  return { emitter, calls }
+}
+
+describe('emitSwiftRoute', () => {
+  it('emits an api-kind route with path params and a response', () => {
+    const route: AnyHttpRouteDoc = {
+      kind: 'api',
+      name: 'GetUser',
+      method: 'GET',
+      fullPath: '/users/:id',
+      schema: {
+        input: {
+          pathParams: { type: 'object' },
+        },
+        returnType: { type: 'object' },
+      },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const emitter = createStubSwiftEmitter({
+      PathParams: ok('public struct PathParams: Codable { public let id: String }', 'PathParams'),
+      Response: ok('public struct Response: Codable { public let id: String; public let name: String }', 'Response'),
+    })
+
+    const result = emitSwiftRoute(route, emitter, noErrors)
+
+    expect(result.imports).toContain('Foundation')
+    expect(result.code).toContain('public static let method = "GET"')
+    expect(result.code).toContain('public static let pathTemplate = "/users/{id}"')
+    expect(result.code).toContain('public static func path(_ p: PathParams) -> String { return "/users/\\(p.id)" }')
+    expect(result.code).toContain('public struct PathParams: Codable { public let id: String }')
+    expect(result.code).toContain('public struct Response: Codable { public let id: String; public let name: String }')
+  })
+
+  it('emits a route with no path params using a path constant', () => {
+    const route = {
+      kind: 'api',
+      name: 'CreateUser',
+      method: 'POST',
+      fullPath: '/users',
+      schema: { input: { body: { type: 'object' } }, returnType: { type: 'object' } },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const emitter = createStubSwiftEmitter({
+      Body: ok('public struct Body: Codable { public let name: String }', 'Body'),
+      Response: ok('public struct Response: Codable { public let id: String }', 'Response'),
+    })
+
+    const result = emitSwiftRoute(route, emitter, noErrors)
+    expect(result.code).toContain('public static let path = "/users"')
+    expect(result.code).not.toContain('static func path(')
+  })
+
+  it('emits an Errors namespace for routes whose error keys have schemas in the envelope', () => {
+    const route = {
+      kind: 'api',
+      name: 'GetUser',
+      method: 'GET',
+      fullPath: '/users/:id',
+      schema: { input: { pathParams: { type: 'object' } }, returnType: { type: 'object' } },
+      errors: ['NotFound'],
+    } as unknown as AnyHttpRouteDoc
+
+    const emitter = createStubSwiftEmitter({
+      PathParams: ok('public struct PathParams: Codable { public let id: String }', 'PathParams'),
+      Response: ok('public struct Response: Codable { public let id: String }', 'Response'),
+      NotFound: ok('public struct NotFound: Codable { public let name: String; public let message: String }', 'NotFound'),
+    })
+
+    const errorSchemas = new Map<string, unknown>([['NotFound', { type: 'object' }]])
+    const result = emitSwiftRoute(route, emitter, errorSchemas)
+    expect(result.code).toContain('public enum Errors {')
+    expect(result.code).toContain('public struct NotFound: Codable { public let name: String; public let message: String }')
+  })
+
+  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'],
+    } 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 result = emitSwiftRoute(route, createStubSwiftEmitter({}), noErrors)
+    expect(result.code).toBe('')
+    expect(result.skipped).toBe(true)
+  })
+
+  it('passes inlineTypes:true plus serializer/accessLevel/unsupportedUnions to every slot emit', () => {
+    const route = {
+      kind: 'api',
+      name: 'GetUser',
+      method: 'GET',
+      fullPath: '/users/:id',
+      schema: {
+        input: { pathParams: { type: 'object' } },
+        returnType: { type: 'object' },
+      },
+      errors: ['NotFound'],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      PathParams: ok('public struct PathParams { public let id: String }', 'PathParams'),
+      Response: ok('public struct Response { public let id: String }', 'Response'),
+      NotFound: ok('public struct NotFound { public let message: String }', 'NotFound'),
+    })
+
+    emitSwiftRoute(route, emitter, new Map([['NotFound', { type: 'object' }]]), {
+      serializer: 'none',
+      accessLevel: 'public',
+      unsupportedUnions: 'fallback',
+    })
+
+    // 3 emits: PathParams, Response, NotFound
+    expect(calls.length).toBe(3)
+    for (const c of calls) {
+      expect(c.opts.inlineTypes).toBe(true)
+      expect(c.opts.serializer).toBe('none')
+      expect(c.opts.accessLevel).toBe('public')
+      expect(c.opts.unsupportedUnions).toBe('fallback')
+    }
+  })
+
+  it('preserves slot order: pathParams → query → body → response → errors', () => {
+    const route = {
+      kind: 'api',
+      name: 'X',
+      method: 'POST',
+      fullPath: '/x/:id',
+      schema: {
+        input: {
+          pathParams: { type: 'object' },
+          query: { type: 'object' },
+          body: { type: 'object' },
+        },
+        returnType: { type: 'object' },
+      },
+      errors: ['Z'],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      PathParams: ok('a', 'PathParams'),
+      Query: ok('b', 'Query'),
+      Body: ok('c', 'Body'),
+      Response: ok('d', 'Response'),
+      Z: ok('e', 'Z'),
+    })
+
+    emitSwiftRoute(route, emitter, new Map([['Z', { type: 'object' }]]), {})
+
+    expect(calls.map((c) => c.opts.rootTypeName)).toEqual([
+      'PathParams', 'Query', 'Body', 'Response', 'Z',
+    ])
+  })
+
+  it('threads passthrough opts (arrayItemNaming/depluralize/uncountableWords) verbatim', () => {
+    const route = {
+      kind: 'api',
+      name: 'X',
+      method: 'GET',
+      fullPath: '/x',
+      schema: { returnType: { type: 'object' } },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      Response: ok('public struct Response: Codable { public let ok: Bool }', 'Response'),
+    })
+
+    emitSwiftRoute(route, emitter, new Map(), {
+      arrayItemNaming: false,
+      depluralize: true,
+      uncountableWords: ['data', 'metadata'],
+    })
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.opts.arrayItemNaming).toBe(false)
+    expect(calls[0]!.opts.depluralize).toBe(true)
+    expect(calls[0]!.opts.uncountableWords).toEqual(['data', 'metadata'])
+  })
+
+  it('does not include passthrough keys when caller omits them', () => {
+    const route = {
+      kind: 'api',
+      name: 'X',
+      method: 'GET',
+      fullPath: '/x',
+      schema: { returnType: { type: 'object' } },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const { emitter, calls } = makeSpyEmitter({
+      Response: ok('public struct Response: Codable { public let ok: Bool }', 'Response'),
+    })
+
+    emitSwiftRoute(route, emitter, new Map(), {})
+
+    expect(calls).toHaveLength(1)
+    // Conditional-spread invariant: undefined opts must NOT be forwarded as keys
+    // (otherwise ajsc would receive `{ arrayItemNaming: undefined }` etc, which
+    // could shadow ajsc-side defaults).
+    expect('arrayItemNaming' in calls[0]!.opts).toBe(false)
+    expect('depluralize' in calls[0]!.opts).toBe(false)
+    expect('uncountableWords' in calls[0]!.opts).toBe(false)
+    // serializer / accessLevel / unsupportedUnions same invariant
+    expect('serializer' in calls[0]!.opts).toBe(false)
+    expect('accessLevel' in calls[0]!.opts).toBe(false)
+    expect('unsupportedUnions' in calls[0]!.opts).toBe(false)
+    // inlineTypes is always set
+    expect(calls[0]!.opts.inlineTypes).toBe(true)
+  })
+
+  it('defaults the static-member access level to public', () => {
+    const route = {
+      kind: 'api',
+      name: 'GetUser',
+      method: 'GET',
+      fullPath: '/users/:id',
+      schema: { input: { pathParams: { type: 'object' } } },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const emitter = createStubSwiftEmitter({
+      PathParams: ok('public struct PathParams { public let id: String }', 'PathParams'),
+    })
+    const result = emitSwiftRoute(route, emitter, noErrors)
+    expect(result.code).toContain('public static let method = "GET"')
+    expect(result.code).toContain('public static let pathTemplate = "/users/{id}"')
+    expect(result.code).toContain('public static func path(_ p: PathParams) -> String')
+  })
+
+  it('honors accessLevel="internal" on the static members and the Errors enum', () => {
+    const route = {
+      kind: 'api',
+      name: 'GetUser',
+      method: 'GET',
+      fullPath: '/users/:id',
+      schema: { input: { pathParams: { type: 'object' } } },
+      errors: ['NotFound'],
+    } as unknown as AnyHttpRouteDoc
+
+    const emitter = createStubSwiftEmitter({
+      PathParams: ok('internal struct PathParams { internal let id: String }', 'PathParams'),
+      NotFound: ok('internal struct NotFound { internal let message: String }', 'NotFound'),
+    })
+    const result = emitSwiftRoute(
+      route,
+      emitter,
+      new Map([['NotFound', { type: 'object' }]]),
+      { accessLevel: 'internal' },
+    )
+    expect(result.code).toContain('internal static let method = "GET"')
+    expect(result.code).toContain('internal static let pathTemplate = "/users/{id}"')
+    expect(result.code).toContain('internal static func path(_ p: PathParams) -> String')
+    expect(result.code).toContain('internal enum Errors {')
+  })
+
+  it('emits accessLevel="internal" on the path constant for no-param routes', () => {
+    const route = {
+      kind: 'api',
+      name: 'CreateUser',
+      method: 'POST',
+      fullPath: '/users',
+      schema: {},
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+    const result = emitSwiftRoute(route, createStubSwiftEmitter({}), noErrors, { accessLevel: 'internal' })
+    expect(result.code).toContain('internal static let path = "/users"')
+  })
+})

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

@@ -0,0 +1,90 @@
+import type { AnyHttpRouteDoc } from '../../../implementations/types.js'
+import type { SwiftEmitter, SwiftEmitOptions } from './ajsc-adapter.js'
+import { indent } from '../_shared/indent.js'
+import { pickDefined } from '../_shared/pick-defined.js'
+import { toBracePath, pathParamNames } from '../_shared/path-utils.js'
+import { extractRouteSlots } from '../_shared/route-slots.js'
+
+export interface EmitRouteResult {
+  /** Inner body of the `enum RouteName { ... }` block — already indented one level. */
+  code: string
+  /** Imports collected from every ajsc emit + any helpers this route used. */
+  imports: string[]
+  /** Outer route name used as the `enum RouteName` identifier. */
+  routeName: string
+  /** True when the route was a stream (out-of-scope). Caller logs once. */
+  skipped?: boolean
+}
+
+/** Subset of SwiftEmitOptions threaded by the pipeline; per-call rootTypeName is set inside. */
+export type EmitRouteOpts = Omit<SwiftEmitOptions, 'rootTypeName' | 'inlineTypes'>
+
+function buildPathFn(bracePath: string, params: string[], access: string): string {
+  if (params.length === 0) return `${access} static let path = "${bracePath}"`
+  let body = bracePath
+  for (const name of params) body = body.replace(`{${name}}`, `\\(p.${name})`)
+  return `${access} static func path(_ p: PathParams) -> String { return "${body}" }`
+}
+
+function emitOptsFor(rootTypeName: string, routeOpts: EmitRouteOpts): SwiftEmitOptions {
+  const PASSTHROUGH_KEYS = ['serializer', 'accessLevel', 'unsupportedUnions', 'arrayItemNaming', 'depluralize', 'uncountableWords'] as const
+  return {
+    rootTypeName,
+    inlineTypes: true,
+    ...pickDefined(routeOpts, PASSTHROUGH_KEYS),
+  }
+}
+
+export function emitSwiftRoute(
+  route: AnyHttpRouteDoc,
+  emitter: SwiftEmitter,
+  errorSchemas: Map<string, unknown>,
+  routeOpts: EmitRouteOpts = {},
+): EmitRouteResult {
+  const kind = (route as { kind?: string }).kind
+  if (kind === 'stream') {
+    return { code: '', imports: [], routeName: route.name, skipped: true }
+  }
+
+  const isApi = kind === 'api' || 'fullPath' in route
+  const rawPath = isApi ? (route as { fullPath: string }).fullPath : (route as { path: string }).path
+  const method = String((route as { method: string }).method).toUpperCase()
+  const bracePath = toBracePath(rawPath)
+  const params = pathParamNames(rawPath)
+  const access = routeOpts.accessLevel ?? 'public'
+
+  const lines: string[] = [
+    `${access} static let method = "${method}"`,
+    `${access} static let pathTemplate = "${bracePath}"`,
+    buildPathFn(bracePath, params, access),
+  ]
+  const imports: string[] = []
+
+  // Per-slot emission. Order is fixed for deterministic output.
+  for (const slot of extractRouteSlots(route)) {
+    const result = emitter.emit(slot.source as Record<string, unknown>, emitOptsFor(slot.rootName, routeOpts))
+    lines.push('')
+    lines.push(result.code)
+    imports.push(...result.imports)
+  }
+
+  // Errors namespace — route.errors is `string[]` of taxonomy keys; look up each schema
+  // from the envelope-level errors map. Keys without schemas are skipped silently
+  // (matching the existing TS scope emitter's `errorKeys` filter).
+  const routeErrorKeys = ((route as { errors?: string[] }).errors ?? [])
+    .filter((key) => errorSchemas.has(key))
+  if (routeErrorKeys.length > 0) {
+    const inner: string[] = []
+    for (const key of routeErrorKeys) {
+      const r = emitter.emit(errorSchemas.get(key) as Record<string, unknown>, emitOptsFor(key, routeOpts))
+      inner.push(r.code)
+      imports.push(...r.imports)
+    }
+    lines.push('')
+    lines.push(`${access} enum Errors {`)
+    lines.push(indent(inner.join('\n\n'), 1))
+    lines.push('}')
+  }
+
+  return { code: lines.join('\n'), imports, routeName: route.name, skipped: false }
+}

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

@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest'
+import type { AnyHttpRouteDoc } from '../../../implementations/types.js'
+import type { ScopeGroup } from '../../group-routes.js'
+import { emitSwiftScope } from './emit-scope-swift.js'
+import { createStubSwiftEmitter, type SwiftEmitOptions, type SwiftEmitResult } from './ajsc-adapter.js'
+
+const ok = (code: string, rootTypeName: string): SwiftEmitResult => ({
+  code,
+  rootTypeName,
+  extractedTypeNames: [],
+  imports: ['Foundation'],
+})
+
+describe('emitSwiftScope', () => {
+  it('produces a complete swift source file for a single-route scope', () => {
+    const route: AnyHttpRouteDoc = {
+      kind: 'api',
+      name: 'GetUser',
+      method: 'GET',
+      fullPath: '/users/:id',
+      schema: { input: { pathParams: { type: 'object' } }, returnType: { type: 'object' } },
+      errors: [],
+    } as unknown as AnyHttpRouteDoc
+
+    const group: ScopeGroup = { scopeKey: 'users', camelCase: 'users', routes: [route] }
+    const emitter = createStubSwiftEmitter({
+      PathParams: ok('public struct PathParams: Codable { public let id: String }', 'PathParams'),
+      Response: ok('public struct Response: Codable { public let id: String }', 'Response'),
+    })
+
+    const file = emitSwiftScope(group, { sourceHash: 'abc123' }, emitter, new Map())
+
+    expect(file.filename).toBe('Users.swift')
+    expect(file.code).toContain('// Generated by ts-procedures-codegen — do not edit.')
+    expect(file.code).toContain('// Source hash: abc123')
+    expect(file.code).toContain('import Foundation')
+    expect(file.code).toContain('public enum Users {')
+    expect(file.code).toContain('public enum GetUser {')
+    expect(file.code).toContain('public static let method = "GET"')
+    expect(file.code).not.toContain('package ')
+  })
+
+  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 group: ScopeGroup = { scopeKey: 'users', camelCase: 'users', routes: [route1, route2] }
+    const emitter = createStubSwiftEmitter({})
+
+    const file = emitSwiftScope(group, { sourceHash: 'h' }, emitter, new Map())
+    expect(file.code).toContain('public enum GetUser {')
+    expect(file.code).toContain('public enum CreateUser {')
+    // exactly one outer scope enum
+    expect((file.code.match(/^public enum Users \{/gm) ?? []).length).toBe(1)
+  })
+
+  it('uses PascalCase scope name for the filename and outer enum', () => {
+    const group: ScopeGroup = { scopeKey: 'admin-users', camelCase: 'adminUsers', routes: [] }
+    const file = emitSwiftScope(group, { sourceHash: 'h' }, createStubSwiftEmitter({}), new Map())
+    expect(file.filename).toBe('AdminUsers.swift')
+    expect(file.code).toContain('public enum AdminUsers {')
+  })
+
+  it('PascalCases multi-segment kebab scope keys', () => {
+    const group: ScopeGroup = { scopeKey: 'admin-settings', camelCase: 'adminSettings', routes: [] }
+    const file = emitSwiftScope(group, { sourceHash: 'h' }, createStubSwiftEmitter({}), new Map())
+    expect(file.filename).toBe('AdminSettings.swift')
+    expect(file.code).toContain('public enum AdminSettings {')
+  })
+
+  it('emits an empty scope enum body when there are no non-stream routes', () => {
+    const group: ScopeGroup = { scopeKey: 'empty', camelCase: 'empty', routes: [] }
+    const file = emitSwiftScope(group, { sourceHash: 'h' }, createStubSwiftEmitter({}), new Map())
+    expect(file.code).toContain('public enum Empty {\n}')
+  })
+
+  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 group: ScopeGroup = { scopeKey: 'multi', camelCase: 'multi', routes: [route1, route2] }
+    const emitter = {
+      emit(_s: unknown, opts: SwiftEmitOptions): SwiftEmitResult {
+        if (opts.rootTypeName === 'Response') {
+          return { code: `public struct Response { }`, rootTypeName: 'Response', extractedTypeNames: [], imports: ['Foundation', 'CommonCrypto'] }
+        }
+        throw new Error(`No stub for ${opts.rootTypeName}`)
+      },
+    }
+
+    const file = emitSwiftScope(group, { sourceHash: 'h' }, emitter, new Map())
+    // Should appear once per unique import, sorted alphabetically.
+    const imports = file.code.split('\n').filter((l) => l.startsWith('import '))
+    expect(imports).toEqual(['import CommonCrypto', 'import Foundation'])
+  })
+
+  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 group: ScopeGroup = { scopeKey: 'x', camelCase: 'x', routes: [route] }
+
+    const calls: SwiftEmitOptions[] = []
+    const emitter = {
+      emit(_s: unknown, opts: SwiftEmitOptions) {
+        calls.push(opts)
+        return { code: 'public struct Response', rootTypeName: 'Response', extractedTypeNames: [], imports: [] }
+      },
+    }
+
+    emitSwiftScope(
+      group,
+      {
+        sourceHash: 'h',
+        serializer: 'none',
+        accessLevel: 'internal',
+        unsupportedUnions: 'fallback',
+        arrayItemNaming: false,
+        depluralize: true,
+        uncountableWords: ['data', 'metadata'],
+      },
+      emitter,
+      new Map(),
+    )
+
+    expect(calls.length).toBe(1)
+    expect(calls[0]!.inlineTypes).toBe(true)
+    expect(calls[0]!.serializer).toBe('none')
+    expect(calls[0]!.accessLevel).toBe('internal')
+    expect(calls[0]!.unsupportedUnions).toBe('fallback')
+    expect(calls[0]!.arrayItemNaming).toBe(false)
+    expect(calls[0]!.depluralize).toBe(true)
+    expect(calls[0]!.uncountableWords).toEqual(['data', 'metadata'])
+  })
+
+  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 group: ScopeGroup = { scopeKey: 'users', camelCase: 'users', routes: [route] }
+    const emitter = createStubSwiftEmitter({})
+
+    const file = emitSwiftScope(group, { sourceHash: 'h', accessLevel: 'internal' }, emitter, new Map())
+    expect(file.code).toContain('internal enum Users {')
+    expect(file.code).toContain('internal enum GetUser {')
+    expect(file.code).toContain('internal static let method = "GET"')
+    expect(file.code).not.toContain('public enum')
+  })
+
+  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 group: ScopeGroup = { scopeKey: 'u', camelCase: 'u', routes: [stream, api] }
+
+    const emitter = createStubSwiftEmitter({
+      Response: ok('public struct Response: Codable { public let id: String }', 'Response'),
+    })
+    const result = emitSwiftScope(group, { sourceHash: 'h' }, emitter, new Map())
+
+    expect(result.skippedStreams).toEqual(['WatchUsers'])
+    expect(result.code).toContain('public enum GetUser')
+    expect(result.code).not.toContain('public enum WatchUsers')
+  })
+
+  it('terminates the file with a trailing newline', () => {
+    const group: ScopeGroup = { scopeKey: 'x', camelCase: 'x', routes: [] }
+    const file = emitSwiftScope(group, { sourceHash: 'h' }, createStubSwiftEmitter({}), new Map())
+    expect(file.code.endsWith('\n')).toBe(true)
+  })
+})

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

@@ -0,0 +1,59 @@
+import type { ScopeGroup } from '../../group-routes.js'
+import type { SwiftEmitter } from './ajsc-adapter.js'
+import { emitSwiftRoute, type EmitRouteOpts } from './emit-route-swift.js'
+import { swiftHeader, swiftImports } from './format-swift.js'
+import { indent } from '../_shared/indent.js'
+import { pickDefined } from '../_shared/pick-defined.js'
+import { pascalCase } from '../_shared/pascal-case.js'
+
+export interface EmitScopeOptions extends EmitRouteOpts {
+  sourceHash: string
+}
+
+export interface EmittedSwiftFile {
+  filename: string
+  code: string
+  /** Names of stream routes within this scope that were skipped. */
+  skippedStreams: string[]
+}
+
+export function emitSwiftScope(
+  group: ScopeGroup,
+  opts: EmitScopeOptions,
+  emitter: SwiftEmitter,
+  errorSchemas: Map<string, unknown>,
+): EmittedSwiftFile {
+  const scopeName = pascalCase(group.scopeKey)
+  const access = opts.accessLevel ?? 'public'
+  const allImports: string[] = []
+  const routeBlocks: string[] = []
+  const skippedStreams: string[] = []
+
+  const PASSTHROUGH_KEYS = ['serializer', 'accessLevel', 'unsupportedUnions', 'arrayItemNaming', 'depluralize', 'uncountableWords'] as const
+  const routeOpts: EmitRouteOpts = pickDefined(opts, PASSTHROUGH_KEYS)
+
+  for (const route of group.routes) {
+    const r = emitSwiftRoute(route, emitter, errorSchemas, routeOpts)
+    if (r.skipped) {
+      skippedStreams.push(r.routeName)
+      continue
+    }
+    allImports.push(...r.imports)
+    const wrapped = `${access} enum ${r.routeName} {\n${indent(r.code, 1)}\n}`
+    routeBlocks.push(wrapped)
+  }
+
+  const innerScope = routeBlocks.length === 0 ? '' : indent(routeBlocks.join('\n\n'), 1)
+  const scopeBlock = innerScope === ''
+    ? `${access} enum ${scopeName} {\n}`
+    : `${access} enum ${scopeName} {\n${innerScope}\n}`
+
+  const importsBlock = swiftImports(allImports)
+  const parts = [
+    swiftHeader(opts.sourceHash),
+    importsBlock,
+    scopeBlock,
+  ].filter((p) => p.length > 0)
+
+  return { filename: `${scopeName}.swift`, code: parts.join('\n\n') + '\n', skippedStreams }
+}

package/src/codegen/targets/swift/format-swift.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+import {
+  swiftHeader,
+  swiftImports,
+} from './format-swift.js'
+
+describe('format-swift', () => {
+  it('emits a two-line generated header with source hash', () => {
+    expect(swiftHeader('abc123')).toBe(
+      '// Generated by ts-procedures-codegen — do not edit.\n// Source hash: abc123',
+    )
+  })
+
+  it('dedupes and sorts imports', () => {
+    expect(swiftImports(['Foundation', 'Foundation', 'CommonCrypto'])).toBe(
+      'import CommonCrypto\nimport Foundation',
+    )
+  })
+
+  it('returns empty string when no imports', () => {
+    expect(swiftImports([])).toBe('')
+  })
+})

package/src/codegen/targets/swift/format-swift.ts

@@ -0,0 +1,9 @@
+export function swiftHeader(sourceHash: string): string {
+  return `// Generated by ts-procedures-codegen — do not edit.\n// Source hash: ${sourceHash}`
+}
+
+export function swiftImports(imports: string[]): string {
+  if (imports.length === 0) return ''
+  const unique = Array.from(new Set(imports)).sort()
+  return unique.map((i) => `import ${i}`).join('\n')
+}