ts-procedures 6.1.0 → 6.2.0

package/build/codegen/targets/swift/access-level.test.js

@@ -0,0 +1,98 @@
+import { describe, expect, it } from 'vitest';
+import { runPipeline } from '../../pipeline.js';
+import { resolveProductionSwiftEmitter } from './ajsc-adapter.js';
+/**
+ * End-to-end regression for `--swift-access-level`.
+ *
+ * Closes a coverage gap: existing unit tests verify our scope/route
+ * scaffolding (the outer `enum` keywords) honor the access level, but
+ * nothing asserts that real ajsc actually emits `internal struct` /
+ * `internal let` in its own output. If ajsc renamed `accessLevel` or
+ * changed its semantics, our codegen would silently regress to `public`.
+ *
+ * This test runs the production pipeline with the real ajsc emitter
+ * and pins the keyword presence in the generated source. No toolchain
+ * (no swiftc) is required — we only assert string contents.
+ */
+const envelope = {
+    basePath: '/api',
+    headers: [],
+    errors: [],
+    routes: [
+        {
+            kind: 'api',
+            name: 'GetThing',
+            scope: 'things',
+            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: {
+                    pathParams: {
+                        type: 'object',
+                        properties: { id: { type: 'string' } },
+                        required: ['id'],
+                    },
+                },
+                returnType: {
+                    type: 'object',
+                    properties: { id: { type: 'string' } },
+                    required: ['id'],
+                },
+            },
+            errors: [],
+        },
+    ],
+};
+describe('swift codegen — --swift-access-level (real ajsc)', () => {
+    it('emits `internal` keywords on ajsc-generated structs when accessLevel="internal"', async () => {
+        const emitter = await resolveProductionSwiftEmitter();
+        const files = await runPipeline({
+            envelope,
+            outDir: 'out',
+            dryRun: true,
+            target: 'swift',
+            swiftAccessLevel: 'internal',
+            swiftEmitter: emitter,
+        });
+        expect(files).toHaveLength(1);
+        const code = files[0].code;
+        // Real ajsc output for the PathParams + Response slots.
+        expect(code).toContain('internal struct PathParams');
+        expect(code).toContain('internal struct Response');
+        // Property declarations should also flip to internal.
+        expect(code).toContain('internal let id: String');
+        // Our scope/route scaffolding flips too — see emit-scope-swift.ts
+        // and emit-route-swift.ts, which both consume `accessLevel`.
+        expect(code).toContain('internal enum Things');
+        expect(code).toContain('internal enum GetThing');
+        // Hard guarantee: nothing in the file leaks `public` declarations.
+        // If ajsc silently ignored `accessLevel: 'internal'`, this would fail.
+        expect(code).not.toMatch(/\bpublic\s+(struct|enum|let|var|func|static)\b/);
+    });
+    it('emits `public` keywords on ajsc-generated structs when accessLevel defaults to public', async () => {
+        const emitter = await resolveProductionSwiftEmitter();
+        const files = await runPipeline({
+            envelope,
+            outDir: 'out',
+            dryRun: true,
+            target: 'swift',
+            // intentionally omit swiftAccessLevel — default is 'public'
+            swiftEmitter: emitter,
+        });
+        expect(files).toHaveLength(1);
+        const code = files[0].code;
+        expect(code).toContain('public struct PathParams');
+        expect(code).toContain('public struct Response');
+        expect(code).toContain('public enum Things');
+        expect(code).toContain('public enum GetThing');
+        // No `internal` declarations should appear when access level is public.
+        expect(code).not.toMatch(/\binternal\s+(struct|enum|let|var|func|static)\b/);
+    });
+});
+//# sourceMappingURL=access-level.test.js.map

package/build/codegen/targets/swift/access-level.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"access-level.test.js","sourceRoot":"","sources":["../../../../src/codegen/targets/swift/access-level.test.ts"],"names":[],"mappings":"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"}

package/build/codegen/targets/swift/ajsc-adapter.d.ts

@@ -0,0 +1,27 @@
+export interface SwiftEmitResult {
+    code: string;
+    rootTypeName: string;
+    extractedTypeNames: string[];
+    imports: string[];
+}
+export interface SwiftEmitOptions {
+    rootTypeName: string;
+    /** Always set true at our call sites; v7.2 default is false. */
+    inlineTypes?: boolean;
+    serializer?: 'codable' | 'none';
+    accessLevel?: 'public' | 'internal';
+    unsupportedUnions?: 'throw' | 'fallback';
+    arrayItemNaming?: string | false;
+    depluralize?: boolean;
+    uncountableWords?: string[];
+}
+export interface SwiftEmitter {
+    emit(schema: Record<string, unknown>, opts: SwiftEmitOptions): SwiftEmitResult;
+}
+export declare function createStubSwiftEmitter(results: Record<string, SwiftEmitResult>): SwiftEmitter;
+/**
+ * Resolves the production Swift emitter from `ajsc`. Throws a clear error
+ * if ajsc is not installed or does not expose `emitSwift` (e.g. consumer
+ * ran `npm install --omit=optional` since ajsc is in optionalDependencies).
+ */
+export declare function resolveProductionSwiftEmitter(): Promise<SwiftEmitter>;

package/build/codegen/targets/swift/ajsc-adapter.js

@@ -0,0 +1,38 @@
+export function createStubSwiftEmitter(results) {
+    return {
+        emit(_schema, opts) {
+            const result = results[opts.rootTypeName];
+            if (result == null) {
+                throw new Error(`[stub-swift-emitter] No stubbed result for rootTypeName "${opts.rootTypeName}". ` +
+                    `Provide one in the results map.`);
+            }
+            return result;
+        },
+    };
+}
+/**
+ * Resolves the production Swift emitter from `ajsc`. Throws a clear error
+ * if ajsc is not installed or does not expose `emitSwift` (e.g. consumer
+ * ran `npm install --omit=optional` since ajsc is in optionalDependencies).
+ */
+export async function resolveProductionSwiftEmitter() {
+    let ajsc = null;
+    let importError;
+    try {
+        ajsc = (await import('ajsc'));
+    }
+    catch (err) {
+        importError = err;
+    }
+    const emitSwift = ajsc?.emitSwift;
+    if (typeof emitSwift !== 'function') {
+        throw new Error('[ts-procedures-codegen] ajsc.emitSwift is not available. ' +
+            'Install ajsc (`npm install ajsc`) — it is an optional dependency.', importError !== undefined ? { cause: importError } : undefined);
+    }
+    return {
+        emit(schema, opts) {
+            return emitSwift(schema, opts);
+        },
+    };
+}
+//# sourceMappingURL=ajsc-adapter.js.map

package/build/codegen/targets/swift/ajsc-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ajsc-adapter.js","sourceRoot":"","sources":["../../../../src/codegen/targets/swift/ajsc-adapter.ts"],"names":[],"mappings":"AAuBA,MAAM,UAAU,sBAAsB,CACpC,OAAwC;IAExC,OAAO;QACL,IAAI,CAAC,OAAO,EAAE,IAAI;YAChB,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;YACzC,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;gBACnB,MAAM,IAAI,KAAK,CACb,4DAA4D,IAAI,CAAC,YAAY,KAAK;oBAChF,iCAAiC,CACpC,CAAA;YACH,CAAC;YACD,OAAO,MAAM,CAAA;QACf,CAAC;KACF,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,6BAA6B;IACjD,IAAI,IAAI,GAAmC,IAAI,CAAA;IAC/C,IAAI,WAAoB,CAAA;IACxB,IAAI,CAAC;QACH,IAAI,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,CAAC,CAA4B,CAAA;IAC1D,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,WAAW,GAAG,GAAG,CAAA;IACnB,CAAC;IACD,MAAM,SAAS,GAAG,IAAI,EAAE,SAAS,CAAA;IACjC,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CACb,2DAA2D;YAC3D,mEAAmE,EACnE,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS,CAC/D,CAAA;IACH,CAAC;IACD,OAAO;QACL,IAAI,CAAC,MAAM,EAAE,IAAI;YACf,OAAQ,SAAyD,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;QACjF,CAAC;KACF,CAAA;AACH,CAAC"}

package/build/codegen/targets/swift/ajsc-adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/codegen/targets/swift/ajsc-adapter.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { createStubSwiftEmitter, resolveProductionSwiftEmitter } from './ajsc-adapter.js';
+describe('createStubSwiftEmitter', () => {
+    it('returns the configured EmitResult for the matching root name', () => {
+        const expected = {
+            code: 'public struct User: Codable { public let id: String }',
+            rootTypeName: 'User',
+            extractedTypeNames: [],
+            imports: ['Foundation'],
+        };
+        const emitter = createStubSwiftEmitter({ User: expected });
+        expect(emitter.emit({ type: 'object' }, {
+            rootTypeName: 'User',
+            inlineTypes: true,
+            serializer: 'codable',
+            unsupportedUnions: 'throw',
+        })).toEqual(expected);
+    });
+    it('throws when asked to emit a name not in the stub map', () => {
+        const emitter = createStubSwiftEmitter({});
+        expect(() => emitter.emit({}, { rootTypeName: 'Missing' })).toThrow(/Missing/);
+    });
+});
+describe('resolveProductionSwiftEmitter', () => {
+    it('returns a working emitter that invokes ajsc.emitSwift when ajsc is installed', async () => {
+        const emitter = await resolveProductionSwiftEmitter();
+        const result = emitter.emit({ type: 'object', properties: { id: { type: 'string' } }, required: ['id'] }, { rootTypeName: 'Probe' });
+        expect(typeof result.code).toBe('string');
+        expect(result.code.length).toBeGreaterThan(0);
+        expect(result.rootTypeName).toBe('Probe');
+        expect(Array.isArray(result.imports)).toBe(true);
+    });
+    // Note: testing the failure path (ajsc unavailable) requires module mocking;
+    // we leave that as a manual-verification path. The error message is pinned
+    // by the message text below so any change requires updating both call sites.
+});
+//# sourceMappingURL=ajsc-adapter.test.js.map

package/build/codegen/targets/swift/ajsc-adapter.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ajsc-adapter.test.js","sourceRoot":"","sources":["../../../../src/codegen/targets/swift/ajsc-adapter.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,sBAAsB,EAAE,6BAA6B,EAAwB,MAAM,mBAAmB,CAAA;AAE/G,QAAQ,CAAC,wBAAwB,EAAE,GAAG,EAAE;IACtC,EAAE,CAAC,8DAA8D,EAAE,GAAG,EAAE;QACtE,MAAM,QAAQ,GAAoB;YAChC,IAAI,EAAE,uDAAuD;YAC7D,YAAY,EAAE,MAAM;YACpB,kBAAkB,EAAE,EAAE;YACtB,OAAO,EAAE,CAAC,YAAY,CAAC;SACxB,CAAA;QACD,MAAM,OAAO,GAAG,sBAAsB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAA;QAC1D,MAAM,CACJ,OAAO,CAAC,IAAI,CACV,EAAE,IAAI,EAAE,QAAQ,EAAE,EAClB;YACE,YAAY,EAAE,MAAM;YACpB,WAAW,EAAE,IAAI;YACjB,UAAU,EAAE,SAAS;YACrB,iBAAiB,EAAE,OAAO;SAC3B,CACF,CACF,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IACrB,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;QAC9D,MAAM,OAAO,GAAG,sBAAsB,CAAC,EAAE,CAAC,CAAA;QAC1C,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;IAChF,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,+BAA+B,EAAE,GAAG,EAAE;IAC7C,EAAE,CAAC,8EAA8E,EAAE,KAAK,IAAI,EAAE;QAC5F,MAAM,OAAO,GAAG,MAAM,6BAA6B,EAAE,CAAA;QACrD,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CACzB,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,EAC5E,EAAE,YAAY,EAAE,OAAO,EAAE,CAC1B,CAAA;QACD,MAAM,CAAC,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACzC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAA;QAC7C,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QACzC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAClD,CAAC,CAAC,CAAA;IACF,6EAA6E;IAC7E,2EAA2E;IAC3E,6EAA6E;AAC/E,CAAC,CAAC,CAAA"}

package/build/codegen/targets/swift/e2e-compile.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/codegen/targets/swift/e2e-compile.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { execFileSync, execSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runPipeline } from '../../pipeline.js';
+import { resolveProductionSwiftEmitter } from './ajsc-adapter.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function swiftcAvailable() {
+    try {
+        execSync('swiftc --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const RUN = process.env.TS_PROCEDURES_SWIFT_E2E === '1';
+/**
+ * E2E: real ajsc → real .swift output → real swiftc parse.
+ *
+ * Gated on (a) `swiftc` on PATH and (b) opt-in via env var so default
+ * `npm test` runs stay green for contributors without the toolchain.
+ *
+ * Unlike Kotlin, Swift's stdlib + Foundation already ship with `Codable`,
+ * so no extra classpath/jars are needed — `swiftc -parse` against a single
+ * file is sufficient to validate the output is syntactically well-formed.
+ */
+describe('swift codegen — swiftc compile (gated)', () => {
+    it.skipIf(!swiftcAvailable() || !RUN)('parses generated output without errors', async () => {
+        const emitter = await resolveProductionSwiftEmitter();
+        const envelope = JSON.parse(readFileSync(join(__dirname, '../../__fixtures__/users-envelope.json'), 'utf8'));
+        const files = await runPipeline({
+            envelope,
+            outDir: 'out',
+            dryRun: true,
+            target: 'swift',
+            swiftEmitter: emitter,
+        });
+        const dir = mkdtempSync(join(tmpdir(), 'tsp-swift-e2e-'));
+        const filePaths = [];
+        for (const f of files) {
+            const dest = join(dir, f.path.split('/').pop());
+            writeFileSync(dest, f.code);
+            filePaths.push(dest);
+        }
+        // -parse only checks syntax; no codegen, no linking, no module deps.
+        execFileSync('swiftc', ['-parse', ...filePaths], { stdio: 'inherit' });
+        // Sanity check — at least one .swift file was generated and persisted.
+        expect(filePaths.length).toBeGreaterThan(0);
+        for (const p of filePaths)
+            expect(existsSync(p)).toBe(true);
+    });
+});
+//# sourceMappingURL=e2e-compile.test.js.map

package/build/codegen/targets/swift/e2e-compile.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e-compile.test.js","sourceRoot":"","sources":["../../../../src/codegen/targets/swift/e2e-compile.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAC9E,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAA;AAEjE,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACjD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;AAErC,SAAS,eAAe;IACtB,IAAI,CAAC;QACH,QAAQ,CAAC,kBAAkB,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAA;QACjD,OAAO,IAAI,CAAA;IACb,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC;AAED,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,uBAAuB,KAAK,GAAG,CAAA;AAEvD;;;;;;;;;GASG;AACH,QAAQ,CAAC,wCAAwC,EAAE,GAAG,EAAE;IACtD,EAAE,CAAC,MAAM,CAAC,CAAC,eAAe,EAAE,IAAI,CAAC,GAAG,CAAC,CACnC,wCAAwC,EACxC,KAAK,IAAI,EAAE;QACT,MAAM,OAAO,GAAG,MAAM,6BAA6B,EAAE,CAAA;QACrD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CACzB,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,wCAAwC,CAAC,EAAE,MAAM,CAAC,CAChF,CAAA;QACD,MAAM,KAAK,GAAG,MAAM,WAAW,CAAC;YAC9B,QAAQ;YACR,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,OAAO;YACf,YAAY,EAAE,OAAO;SACtB,CAAC,CAAA;QAEF,MAAM,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,gBAAgB,CAAC,CAAC,CAAA;QACzD,MAAM,SAAS,GAAa,EAAE,CAAA;QAC9B,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAG,CAAC,CAAA;YAChD,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAA;YAC3B,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACtB,CAAC;QAED,qEAAqE;QACrE,YAAY,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,GAAG,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAA;QAEtE,uEAAuE;QACvE,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAA;QAC3C,KAAK,MAAM,CAAC,IAAI,SAAS;YAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC7D,CAAC,CACF,CAAA;AACH,CAAC,CAAC,CAAA"}

package/build/codegen/targets/swift/emit-route-swift.d.ts

@@ -0,0 +1,15 @@
+import type { AnyHttpRouteDoc } from '../../../implementations/types.js';
+import type { SwiftEmitter, SwiftEmitOptions } from './ajsc-adapter.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'>;
+export declare function emitSwiftRoute(route: AnyHttpRouteDoc, emitter: SwiftEmitter, errorSchemas: Map<string, unknown>, routeOpts?: EmitRouteOpts): EmitRouteResult;

package/build/codegen/targets/swift/emit-route-swift.js

@@ -0,0 +1,64 @@
+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';
+function buildPathFn(bracePath, params, access) {
+    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, routeOpts) {
+    const PASSTHROUGH_KEYS = ['serializer', 'accessLevel', 'unsupportedUnions', 'arrayItemNaming', 'depluralize', 'uncountableWords'];
+    return {
+        rootTypeName,
+        inlineTypes: true,
+        ...pickDefined(routeOpts, PASSTHROUGH_KEYS),
+    };
+}
+export function emitSwiftRoute(route, emitter, errorSchemas, routeOpts = {}) {
+    const kind = route.kind;
+    if (kind === 'stream') {
+        return { code: '', imports: [], routeName: route.name, skipped: true };
+    }
+    const isApi = kind === 'api' || 'fullPath' in route;
+    const rawPath = isApi ? route.fullPath : route.path;
+    const method = String(route.method).toUpperCase();
+    const bracePath = toBracePath(rawPath);
+    const params = pathParamNames(rawPath);
+    const access = routeOpts.accessLevel ?? 'public';
+    const lines = [
+        `${access} static let method = "${method}"`,
+        `${access} static let pathTemplate = "${bracePath}"`,
+        buildPathFn(bracePath, params, access),
+    ];
+    const imports = [];
+    // Per-slot emission. Order is fixed for deterministic output.
+    for (const slot of extractRouteSlots(route)) {
+        const result = emitter.emit(slot.source, 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.errors ?? [])
+        .filter((key) => errorSchemas.has(key));
+    if (routeErrorKeys.length > 0) {
+        const inner = [];
+        for (const key of routeErrorKeys) {
+            const r = emitter.emit(errorSchemas.get(key), 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 };
+}
+//# sourceMappingURL=emit-route-swift.js.map

package/build/codegen/targets/swift/emit-route-swift.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-route-swift.js","sourceRoot":"","sources":["../../../../src/codegen/targets/swift/emit-route-swift.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAgB7D,SAAS,WAAW,CAAC,SAAiB,EAAE,MAAgB,EAAE,MAAc;IACtE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,MAAM,uBAAuB,SAAS,GAAG,CAAA;IAC5E,IAAI,IAAI,GAAG,SAAS,CAAA;IACpB,KAAK,MAAM,IAAI,IAAI,MAAM;QAAE,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,GAAG,EAAE,QAAQ,IAAI,GAAG,CAAC,CAAA;IAC5E,OAAO,GAAG,MAAM,0DAA0D,IAAI,KAAK,CAAA;AACrF,CAAC;AAED,SAAS,WAAW,CAAC,YAAoB,EAAE,SAAwB;IACjE,MAAM,gBAAgB,GAAG,CAAC,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,aAAa,EAAE,kBAAkB,CAAU,CAAA;IAC1I,OAAO;QACL,YAAY;QACZ,WAAW,EAAE,IAAI;QACjB,GAAG,WAAW,CAAC,SAAS,EAAE,gBAAgB,CAAC;KAC5C,CAAA;AACH,CAAC;AAED,MAAM,UAAU,cAAc,CAC5B,KAAsB,EACtB,OAAqB,EACrB,YAAkC,EAClC,YAA2B,EAAE;IAE7B,MAAM,IAAI,GAAI,KAA2B,CAAC,IAAI,CAAA;IAC9C,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;QACtB,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA;IACxE,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,KAAK,KAAK,IAAI,UAAU,IAAI,KAAK,CAAA;IACnD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAE,KAA8B,CAAC,QAAQ,CAAC,CAAC,CAAE,KAA0B,CAAC,IAAI,CAAA;IACnG,MAAM,MAAM,GAAG,MAAM,CAAE,KAA4B,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,CAAA;IACzE,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,CAAC,CAAA;IACtC,MAAM,MAAM,GAAG,cAAc,CAAC,OAAO,CAAC,CAAA;IACtC,MAAM,MAAM,GAAG,SAAS,CAAC,WAAW,IAAI,QAAQ,CAAA;IAEhD,MAAM,KAAK,GAAa;QACtB,GAAG,MAAM,yBAAyB,MAAM,GAAG;QAC3C,GAAG,MAAM,+BAA+B,SAAS,GAAG;QACpD,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC;KACvC,CAAA;IACD,MAAM,OAAO,GAAa,EAAE,CAAA;IAE5B,8DAA8D;IAC9D,KAAK,MAAM,IAAI,IAAI,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAiC,EAAE,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAA;QAC1G,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACd,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QACvB,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,CAAA;IACjC,CAAC;IAED,sFAAsF;IACtF,gFAAgF;IAChF,iEAAiE;IACjE,MAAM,cAAc,GAAG,CAAE,KAA+B,CAAC,MAAM,IAAI,EAAE,CAAC;SACnE,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;IACzC,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC9B,MAAM,KAAK,GAAa,EAAE,CAAA;QAC1B,KAAK,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;YACjC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAA4B,EAAE,WAAW,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAA;YACrG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;YAClB,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAA;QAC5B,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACd,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,gBAAgB,CAAC,CAAA;QACrC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QACzC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACjB,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAA;AACnF,CAAC"}

package/build/codegen/targets/swift/emit-route-swift.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/codegen/targets/swift/emit-route-swift.test.js

@@ -0,0 +1,258 @@
+import { describe, expect, it } from 'vitest';
+import { emitSwiftRoute } from './emit-route-swift.js';
+import { createStubSwiftEmitter } from './ajsc-adapter.js';
+const ok = (code, rootTypeName) => ({
+    code,
+    rootTypeName,
+    extractedTypeNames: [],
+    imports: ['Foundation'],
+});
+const noErrors = new Map();
+function makeSpyEmitter(results) {
+    const calls = [];
+    const emitter = {
+        emit(schema, opts) {
+            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 = {
+            kind: 'api',
+            name: 'GetUser',
+            method: 'GET',
+            fullPath: '/users/:id',
+            schema: {
+                input: {
+                    pathParams: { type: 'object' },
+                },
+                returnType: { type: 'object' },
+            },
+            errors: [],
+        };
+        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: [],
+        };
+        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'],
+        };
+        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([['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'],
+        };
+        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: [] };
+        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'],
+        };
+        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'],
+        };
+        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: [],
+        };
+        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: [],
+        };
+        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: [],
+        };
+        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'],
+        };
+        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: [],
+        };
+        const result = emitSwiftRoute(route, createStubSwiftEmitter({}), noErrors, { accessLevel: 'internal' });
+        expect(result.code).toContain('internal static let path = "/users"');
+    });
+});
+//# sourceMappingURL=emit-route-swift.test.js.map