ts-procedures 6.0.2 → 6.2.0

package/src/codegen/__fixtures__/users-envelope.json

@@ -0,0 +1,144 @@
+{
+  "version": "1",
+  "basePath": "/api",
+  "headers": [],
+  "routes": [
+    {
+      "kind": "api",
+      "name": "GetUser",
+      "scope": "users",
+      "method": "GET",
+      "fullPath": "/users/:id",
+      "schema": {
+        "input": {
+          "pathParams": {
+            "type": "object",
+            "properties": { "id": { "type": "string" } },
+            "required": ["id"]
+          }
+        },
+        "returnType": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string" },
+            "name": { "type": "string" },
+            "created-at": { "type": "string", "format": "date-time" },
+            "address": {
+              "type": "object",
+              "properties": {
+                "street": { "type": "string" },
+                "city": { "type": "string" }
+              },
+              "required": ["street", "city"]
+            }
+          },
+          "required": ["id", "name", "created-at", "address"]
+        }
+      },
+      "errors": ["NotFound"]
+    },
+    {
+      "kind": "api",
+      "name": "CreateUser",
+      "scope": "users",
+      "method": "POST",
+      "fullPath": "/users",
+      "schema": {
+        "input": {
+          "body": {
+            "oneOf": [
+              {
+                "type": "object",
+                "properties": {
+                  "kind": { "const": "guest" },
+                  "displayName": { "type": "string" }
+                },
+                "required": ["kind", "displayName"]
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "kind": { "const": "registered" },
+                  "email": { "type": "string" },
+                  "name": { "type": "string" }
+                },
+                "required": ["kind", "email", "name"]
+              }
+            ]
+          }
+        },
+        "returnType": {
+          "type": "object",
+          "properties": { "id": { "type": "string" } },
+          "required": ["id"]
+        }
+      },
+      "errors": ["ValidationError"]
+    },
+    {
+      "kind": "api",
+      "name": "ListUsers",
+      "scope": "users",
+      "method": "GET",
+      "fullPath": "/users",
+      "schema": {
+        "input": {
+          "query": {
+            "type": "object",
+            "properties": {
+              "status": { "type": "string", "enum": ["active", "inactive"] },
+              "limit": { "type": "integer" }
+            }
+          }
+        },
+        "returnType": {
+          "type": "object",
+          "properties": {
+            "items": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "id": { "type": "string" },
+                  "name": { "type": "string" }
+                },
+                "required": ["id", "name"]
+              }
+            }
+          },
+          "required": ["items"]
+        }
+      },
+      "errors": []
+    }
+  ],
+  "errors": [
+    {
+      "name": "NotFound",
+      "statusCode": 404,
+      "description": "Resource not found",
+      "schema": {
+        "type": "object",
+        "properties": {
+          "name": { "const": "NotFound" },
+          "message": { "type": "string" }
+        },
+        "required": ["name", "message"]
+      }
+    },
+    {
+      "name": "ValidationError",
+      "statusCode": 400,
+      "description": "Input failed validation",
+      "schema": {
+        "type": "object",
+        "properties": {
+          "name": { "const": "ValidationError" },
+          "message": { "type": "string" },
+          "field": { "type": "string" }
+        },
+        "required": ["name", "message"]
+      }
+    }
+  ]
+}

package/src/codegen/bin/cli.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest'
-import { parseArgs, loadConfigFile, extractConfigPath, type CodegenConfig } from './cli.js'
+import { vi } from 'vitest'
+import { parseArgs, loadConfigFile, extractConfigPath, printPostRunHints, warnIfKotlinNoOpFlags, type CodegenConfig } from './cli.js'
 
 describe('parseArgs', () => {
   it('parses --url and --out', () => {
@@ -293,3 +294,201 @@ describe('config file support', () => {
     await expect(loadConfigFile('/nonexistent/config.json')).rejects.toThrow('Failed to load config')
   })
 })
+
+describe('cli — kotlin target', () => {
+  it('parses --target kotlin and --kotlin-package from CLI flags', () => {
+    const args = parseArgs(
+      ['--target', 'kotlin', '--kotlin-package', 'com.example.api', '--out', 'out', '--file', 'env.json'],
+    )
+    expect(args.target).toBe('kotlin')
+    expect(args.kotlin?.package).toBe('com.example.api')
+  })
+
+  it('reads kotlin.package from config when no CLI flag is provided', () => {
+    const config: CodegenConfig = {
+      target: 'kotlin',
+      kotlin: { package: 'com.example.api' },
+      outDir: 'out',
+      file: 'env.json',
+    }
+    const args = parseArgs(['--out', 'out', '--file', 'env.json'], config)
+    expect(args.target).toBe('kotlin')
+    expect(args.kotlin?.package).toBe('com.example.api')
+  })
+
+  it('CLI flag overrides config value', () => {
+    const config: CodegenConfig = {
+      target: 'kotlin',
+      kotlin: { package: 'old.pkg' },
+      outDir: 'out',
+      file: 'env.json',
+    }
+    const args = parseArgs(['--kotlin-package', 'new.pkg', '--out', 'out', '--file', 'env.json'], config)
+    expect(args.kotlin?.package).toBe('new.pkg')
+  })
+
+  it('errors when target is kotlin and no package is provided', () => {
+    expect(() =>
+      parseArgs(['--target', 'kotlin', '--out', 'out', '--file', 'env.json']),
+    ).toThrow(/--kotlin-package/)
+  })
+
+  it('--target ts is the default', () => {
+    const args = parseArgs(['--out', 'out', '--file', 'env.json'])
+    expect(args.target ?? 'ts').toBe('ts')
+  })
+})
+
+describe('cli — kotlin-serializer flag', () => {
+  it('parses --kotlin-serializer kotlinx', () => {
+    const args = parseArgs(['--target', 'kotlin', '--kotlin-package', 'p', '--kotlin-serializer', 'kotlinx', '--out', 'o', '--file', 'e.json'])
+    expect(args.kotlin?.serializer).toBe('kotlinx')
+  })
+
+  it('parses --kotlin-serializer none', () => {
+    const args = parseArgs(['--target', 'kotlin', '--kotlin-package', 'p', '--kotlin-serializer', 'none', '--out', 'o', '--file', 'e.json'])
+    expect(args.kotlin?.serializer).toBe('none')
+  })
+
+  it('reads kotlin.serializer from config', () => {
+    const args = parseArgs(['--out', 'o', '--file', 'e.json'], {
+      target: 'kotlin', kotlin: { package: 'p', serializer: 'none' }, outDir: 'o', file: 'e.json',
+    } as CodegenConfig)
+    expect(args.kotlin?.serializer).toBe('none')
+  })
+
+  it('CLI overrides config', () => {
+    const args = parseArgs(['--kotlin-serializer', 'kotlinx', '--out', 'o', '--file', 'e.json'], {
+      target: 'kotlin', kotlin: { package: 'p', serializer: 'none' }, outDir: 'o', file: 'e.json',
+    } as CodegenConfig)
+    expect(args.kotlin?.serializer).toBe('kotlinx')
+  })
+
+  it('throws on invalid value', () => {
+    expect(() => parseArgs(['--target', 'kotlin', '--kotlin-package', 'p', '--kotlin-serializer', 'bogus', '--out', 'o', '--file', 'e.json']))
+      .toThrow(/--kotlin-serializer/)
+  })
+})
+
+describe('cli — unsupported-unions flag', () => {
+  it('parses --unsupported-unions throw', () => {
+    const args = parseArgs(['--unsupported-unions', 'throw', '--out', 'o', '--file', 'e.json'])
+    expect(args.unsupportedUnions).toBe('throw')
+  })
+
+  it('parses --unsupported-unions fallback', () => {
+    const args = parseArgs(['--unsupported-unions', 'fallback', '--out', 'o', '--file', 'e.json'])
+    expect(args.unsupportedUnions).toBe('fallback')
+  })
+
+  it('reads unsupportedUnions from config', () => {
+    const args = parseArgs(['--out', 'o', '--file', 'e.json'], {
+      unsupportedUnions: 'fallback', outDir: 'o', file: 'e.json',
+    } as CodegenConfig)
+    expect(args.unsupportedUnions).toBe('fallback')
+  })
+
+  it('CLI overrides config', () => {
+    const args = parseArgs(['--unsupported-unions', 'throw', '--out', 'o', '--file', 'e.json'], {
+      unsupportedUnions: 'fallback', outDir: 'o', file: 'e.json',
+    } as CodegenConfig)
+    expect(args.unsupportedUnions).toBe('throw')
+  })
+
+  it('throws on invalid value', () => {
+    expect(() => parseArgs(['--unsupported-unions', 'bogus', '--out', 'o', '--file', 'e.json']))
+      .toThrow(/--unsupported-unions/)
+  })
+
+  it('default is undefined when not set', () => {
+    const args = parseArgs(['--out', 'o', '--file', 'e.json'])
+    expect(args.unsupportedUnions).toBeUndefined()
+  })
+})
+
+describe('cli — printPostRunHints', () => {
+  it('prints a setup-guide pointer for the kotlin target', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    try {
+      printPostRunHints({ target: 'kotlin' })
+      const matched = logSpy.mock.calls.some((c) => String(c[0]).includes('docs/codegen-kotlin.md'))
+      expect(matched).toBe(true)
+    } finally {
+      logSpy.mockRestore()
+    }
+  })
+
+  it('prints nothing for the ts target', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    try {
+      printPostRunHints({ target: 'ts' })
+      expect(logSpy).not.toHaveBeenCalled()
+    } finally {
+      logSpy.mockRestore()
+    }
+  })
+
+  it('prints nothing when target is undefined (default ts)', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    try {
+      printPostRunHints({})
+      expect(logSpy).not.toHaveBeenCalled()
+    } finally {
+      logSpy.mockRestore()
+    }
+  })
+})
+
+describe('cli — warnIfKotlinNoOpFlags', () => {
+  it('warns when --unsupported-unions is set with --target kotlin', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      warnIfKotlinNoOpFlags({ target: 'kotlin', unsupportedUnions: 'fallback' })
+      const matched = warnSpy.mock.calls.some((c) => String(c[0]).includes('--unsupported-unions is currently a no-op'))
+      expect(matched).toBe(true)
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
+  it('warns when --unsupported-unions is set to throw with --target kotlin', () => {
+    // Even 'throw' is a no-op since ajsc never throws on Kotlin untagged oneOf.
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      warnIfKotlinNoOpFlags({ target: 'kotlin', unsupportedUnions: 'throw' })
+      expect(warnSpy).toHaveBeenCalled()
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
+  it('does not warn when --unsupported-unions is unset', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      warnIfKotlinNoOpFlags({ target: 'kotlin' })
+      expect(warnSpy).not.toHaveBeenCalled()
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
+  it('does not warn for the ts target even when --unsupported-unions is set', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      warnIfKotlinNoOpFlags({ target: 'ts', unsupportedUnions: 'fallback' })
+      expect(warnSpy).not.toHaveBeenCalled()
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
+  it('does not warn when target is undefined', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      warnIfKotlinNoOpFlags({ unsupportedUnions: 'fallback' })
+      expect(warnSpy).not.toHaveBeenCalled()
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+})

package/src/codegen/bin/cli.ts

@@ -22,6 +22,10 @@ export interface CodegenConfig {
   selfContained?: boolean
   serviceName?: string
   cleanOutDir?: boolean
+  target?: 'ts' | 'kotlin' | 'swift'
+  kotlin?: { package: string; serializer?: 'kotlinx' | 'none' }
+  swift?: { serializer?: 'codable' | 'none'; accessLevel?: 'public' | 'internal' }
+  unsupportedUnions?: 'throw' | 'fallback'
 }
 
 export interface ParsedArgs {
@@ -37,6 +41,10 @@ export interface ParsedArgs {
   selfContained: boolean
   serviceName?: string
   cleanOutDir: boolean
+  target?: 'ts' | 'kotlin' | 'swift'
+  kotlin?: { package: string; serializer?: 'kotlinx' | 'none' }
+  swift?: { serializer?: 'codable' | 'none'; accessLevel?: 'public' | 'internal' }
+  unsupportedUnions?: 'throw' | 'fallback'
 }
 
 // ---------------------------------------------------------------------------
@@ -88,6 +96,12 @@ export function parseArgs(argv: string[], config?: CodegenConfig): ParsedArgs {
   let selfContained = config?.selfContained ?? true
   let serviceName: string | undefined = config?.serviceName
   let cleanOutDir = config?.cleanOutDir ?? false
+  let target: 'ts' | 'kotlin' | 'swift' | undefined = config?.target
+  let kotlinPackage: string | undefined = config?.kotlin?.package
+  let kotlinSerializer: 'kotlinx' | 'none' | undefined = config?.kotlin?.serializer
+  let swiftSerializer: 'codable' | 'none' | undefined = config?.swift?.serializer
+  let swiftAccessLevel: 'public' | 'internal' | undefined = config?.swift?.accessLevel
+  let unsupportedUnions: 'throw' | 'fallback' | undefined = config?.unsupportedUnions
   let configPath: string | undefined
 
   for (let i = 0; i < argv.length; i++) {
@@ -137,6 +151,43 @@ export function parseArgs(argv: string[], config?: CodegenConfig): ParsedArgs {
       cleanOutDir = true
     } else if (arg === '--no-clean-out-dir') {
       cleanOutDir = false
+    } else if (arg === '--target') {
+      const val = argv[++i]
+      if (val === 'ts' || val === 'kotlin' || val === 'swift') {
+        target = val
+      } else {
+        throw new Error(`Invalid --target value: ${val ?? '(missing)'} (expected 'ts', 'kotlin', or 'swift')`)
+      }
+    } else if (arg === '--kotlin-package') {
+      kotlinPackage = argv[++i]
+    } else if (arg === '--kotlin-serializer') {
+      const val = argv[++i]
+      if (val === 'kotlinx' || val === 'none') {
+        kotlinSerializer = val
+      } else {
+        throw new Error(`Invalid --kotlin-serializer value: ${val ?? '(missing)'} (expected 'kotlinx' or 'none')`)
+      }
+    } else if (arg === '--swift-serializer') {
+      const val = argv[++i]
+      if (val === 'codable' || val === 'none') {
+        swiftSerializer = val
+      } else {
+        throw new Error(`Invalid --swift-serializer value: ${val ?? '(missing)'} (expected 'codable' or 'none')`)
+      }
+    } else if (arg === '--swift-access-level') {
+      const val = argv[++i]
+      if (val === 'public' || val === 'internal') {
+        swiftAccessLevel = val
+      } else {
+        throw new Error(`Invalid --swift-access-level value: ${val ?? '(missing)'} (expected 'public' or 'internal')`)
+      }
+    } else if (arg === '--unsupported-unions') {
+      const val = argv[++i]
+      if (val === 'throw' || val === 'fallback') {
+        unsupportedUnions = val
+      } else {
+        throw new Error(`Invalid --unsupported-unions value: ${val ?? '(missing)'} (expected 'throw' or 'fallback')`)
+      }
     } else if (arg === '--config') {
       configPath = argv[++i]
     }
@@ -145,6 +196,14 @@ export function parseArgs(argv: string[], config?: CodegenConfig): ParsedArgs {
   // configPath is consumed by the caller (main) before parseArgs is called with the loaded config.
   // When called from main, config is already loaded. When called directly (tests), configPath is ignored.
 
+  // ---------------------------------------------------------------------------
+  // Validation — fails fast on user-controllable errors before envelope resolve.
+  // Runtime checks (emitter availability, etc.) happen later in pipeline.ts;
+  // those guards are aimed at non-CLI callers (direct API consumers, tests).
+  // The CLI resolves emitters before invoking `runPipeline`, so users only ever
+  // see flag-shape errors from this block, not pipeline-internal throws.
+  // ---------------------------------------------------------------------------
+
   if (outDir === undefined) {
     throw new Error('Missing required argument: --out <dir>')
   }
@@ -153,6 +212,15 @@ export function parseArgs(argv: string[], config?: CodegenConfig): ParsedArgs {
     throw new Error('Missing required input source: provide --url <url> or --file <path>')
   }
 
+  // Kotlin target requires a package; surface this before any I/O happens.
+  if (target === 'kotlin' && (kotlinPackage === undefined || kotlinPackage === '')) {
+    throw new Error('Missing required argument: --kotlin-package <pkg> (required when --target kotlin)')
+  }
+
+  // Swift target currently has no required flags. If that changes, add the
+  // guard here so the failure mode stays consistent (flag-shape errors fire
+  // from parseArgs; runtime/emitter wiring errors fire from pipeline.ts).
+
   return {
     url,
     file,
@@ -166,6 +234,24 @@ export function parseArgs(argv: string[], config?: CodegenConfig): ParsedArgs {
     selfContained,
     ...(serviceName !== undefined ? { serviceName } : {}),
     cleanOutDir,
+    ...(target !== undefined ? { target } : {}),
+    ...(kotlinPackage !== undefined
+      ? {
+          kotlin: {
+            package: kotlinPackage,
+            ...(kotlinSerializer !== undefined ? { serializer: kotlinSerializer } : {}),
+          },
+        }
+      : {}),
+    ...(swiftSerializer !== undefined || swiftAccessLevel !== undefined
+      ? {
+          swift: {
+            ...(swiftSerializer !== undefined ? { serializer: swiftSerializer } : {}),
+            ...(swiftAccessLevel !== undefined ? { accessLevel: swiftAccessLevel } : {}),
+          },
+        }
+      : {}),
+    ...(unsupportedUnions !== undefined ? { unsupportedUnions } : {}),
   }
 }
 
@@ -201,6 +287,29 @@ async function runWithWatch(parsed: ParsedArgs): Promise<void> {
     cleanOutDir: parsed.cleanOutDir,
   }
 
+  // Resolve the kotlin emitter once at watch start; it's stateless and reused per tick.
+  const kotlinWiring =
+    parsed.target === 'kotlin'
+      ? {
+          target: 'kotlin' as const,
+          kotlinPackage: parsed.kotlin!.package,
+          kotlinEmitter: await (
+            await import('../targets/kotlin/ajsc-adapter.js')
+          ).resolveProductionKotlinEmitter(),
+        }
+      : {}
+
+  // Resolve the swift emitter once at watch start; it's stateless and reused per tick.
+  const swiftWiring =
+    parsed.target === 'swift'
+      ? {
+          target: 'swift' as const,
+          swiftEmitter: await (
+            await import('../targets/swift/ajsc-adapter.js')
+          ).resolveProductionSwiftEmitter(),
+        }
+      : {}
+
   let lastHash: string | undefined
 
   const run = async (): Promise<void> => {
@@ -226,6 +335,12 @@ async function runWithWatch(parsed: ParsedArgs): Promise<void> {
         selfContained: parsed.selfContained,
         serviceName: parsed.serviceName,
         cleanOutDir: parsed.cleanOutDir,
+        ...(parsed.kotlin?.serializer !== undefined ? { kotlinSerializer: parsed.kotlin.serializer } : {}),
+        ...(parsed.unsupportedUnions !== undefined ? { unsupportedUnions: parsed.unsupportedUnions } : {}),
+        ...(parsed.swift?.serializer !== undefined ? { swiftSerializer: parsed.swift.serializer } : {}),
+        ...(parsed.swift?.accessLevel !== undefined ? { swiftAccessLevel: parsed.swift.accessLevel } : {}),
+        ...kotlinWiring,
+        ...swiftWiring,
       })
       console.log(`[ts-procedures-codegen] Generated client files → ${parsed.outDir}`)
     } catch (err) {
@@ -243,6 +358,45 @@ async function runWithWatch(parsed: ParsedArgs): Promise<void> {
 // Main
 // ---------------------------------------------------------------------------
 
+const KOTLIN_SETUP_GUIDE_URL =
+  'https://bitbucket.org/thermsio/ts-procedures/src/master/docs/codegen-kotlin.md'
+
+const SWIFT_SETUP_GUIDE_URL =
+  'https://bitbucket.org/thermsio/ts-procedures/src/master/docs/codegen-swift.md'
+
+export function printPostRunHints(parsed: { target?: 'ts' | 'kotlin' | 'swift' }): void {
+  if (parsed.target === 'kotlin') {
+    console.log(`[ts-procedures-codegen] Kotlin setup guide: ${KOTLIN_SETUP_GUIDE_URL}`)
+  }
+  if (parsed.target === 'swift') {
+    console.log(`[ts-procedures-codegen] Swift setup guide: ${SWIFT_SETUP_GUIDE_URL}`)
+  }
+}
+
+/**
+ * Warns about flags that are currently no-ops for the Kotlin target.
+ *
+ * Scope is intentionally Kotlin-only — the param type omits `'swift'` so a
+ * reader can tell at a glance this function will never act on swift. Other
+ * targets get their own warner if/when they grow no-op flags. The call site
+ * narrows `parsed.target` before invoking.
+ *
+ * Currently: `--unsupported-unions` is a no-op because ajsc v7.2's Kotlin
+ * emitter silently emits an empty data class for untagged oneOf regardless
+ * of the flag (see docs/codegen-kotlin.md#untagged-unions).
+ */
+export function warnIfKotlinNoOpFlags(parsed: {
+  target?: 'ts' | 'kotlin'
+  unsupportedUnions?: 'throw' | 'fallback'
+}): void {
+  if (parsed.target === 'kotlin' && parsed.unsupportedUnions !== undefined) {
+    console.warn(
+      '[ts-procedures-codegen] Note: --unsupported-unions is currently a no-op for --target kotlin ' +
+      '(ajsc v7.2 emits an empty data class regardless). See docs/codegen-kotlin.md#untagged-unions.',
+    )
+  }
+}
+
 async function main(): Promise<void> {
   const argv = process.argv.slice(2)
   const configPath = extractConfigPath(argv)
@@ -251,6 +405,15 @@ async function main(): Promise<void> {
     console.log(`[ts-procedures-codegen] Loaded config from ${configPath ?? DEFAULT_CONFIG_NAME}`)
   }
   const parsed = parseArgs(argv, config)
+  // The warner is intentionally Kotlin-only; pass the relevant fields and
+  // narrow `target` away from 'swift' here so the function's param type can
+  // stay tight.
+  if (parsed.target !== 'swift') {
+    warnIfKotlinNoOpFlags({
+      target: parsed.target,
+      ...(parsed.unsupportedUnions !== undefined ? { unsupportedUnions: parsed.unsupportedUnions } : {}),
+    })
+  }
 
   const source = parsed.url ?? parsed.file!
   console.log(`[ts-procedures-codegen] Reading docs from ${source}...`)
@@ -258,6 +421,23 @@ async function main(): Promise<void> {
   if (parsed.watch) {
     await runWithWatch(parsed)
   } else {
+    const kotlinWiring =
+      parsed.target === 'kotlin'
+        ? {
+            target: 'kotlin' as const,
+            kotlinPackage: parsed.kotlin!.package,
+            kotlinEmitter: await (await import('../targets/kotlin/ajsc-adapter.js')).resolveProductionKotlinEmitter(),
+          }
+        : {}
+
+    const swiftWiring =
+      parsed.target === 'swift'
+        ? {
+            target: 'swift' as const,
+            swiftEmitter: await (await import('../targets/swift/ajsc-adapter.js')).resolveProductionSwiftEmitter(),
+          }
+        : {}
+
     const result = await generateClient({
       url: parsed.url,
       file: parsed.file,
@@ -269,11 +449,18 @@ async function main(): Promise<void> {
       selfContained: parsed.selfContained,
       serviceName: parsed.serviceName,
       cleanOutDir: parsed.cleanOutDir,
+      ...(parsed.kotlin?.serializer !== undefined ? { kotlinSerializer: parsed.kotlin.serializer } : {}),
+      ...(parsed.unsupportedUnions !== undefined ? { unsupportedUnions: parsed.unsupportedUnions } : {}),
+      ...(parsed.swift?.serializer !== undefined ? { swiftSerializer: parsed.swift.serializer } : {}),
+      ...(parsed.swift?.accessLevel !== undefined ? { swiftAccessLevel: parsed.swift.accessLevel } : {}),
+      ...kotlinWiring,
+      ...swiftWiring,
     })
     if (parsed.dryRun) {
       console.log(`[ts-procedures-codegen] Dry run complete — ${result.length} files would be generated`)
     } else {
       console.log(`[ts-procedures-codegen] Generated ${result.length} files → ${parsed.outDir}`)
+      printPostRunHints(parsed)
     }
   }
 }