ts-procedures 6.0.0 → 6.0.2

package/agent_config/claude-code/agents/ts-procedures-architect.md

@@ -37,7 +37,7 @@ When asked to plan an API or procedure set:
 - AJV is configured with `allErrors: true`, `coerceTypes: true`, `removeAdditional: true`.
 - `schema.params` and `schema.input` are mutually exclusive — defining both throws `ProcedureRegistrationError`.
 - Path param names in route template (`:id`) must match `schema.input.pathParams` property names.
-- Use `DocRegistry` to compose route docs from multiple builders — never manually wire `/docs` endpoints. Use `DocRegistry.fromTaxonomy(appErrors)` to seed envelope errors from your taxonomy + framework defaults in one call.
+- Use `DocRegistry` to compose route docs from multiple builders — never manually wire `/docs` endpoints. Pass your taxonomy directly: `new DocRegistry({ errors: appErrors })` — framework defaults are auto-merged and deduped. For errors outside your taxonomy (middleware, infrastructure, doc-only), chain `.documentError(...docs)`.
 - Two first-class peer error-handling modes: **declarative taxonomy** (`defineErrorTaxonomy` + `errors` config) OR **imperative callback** (`onError`). Neither is deprecated. Pick the taxonomy for structured apps with typed client dispatch; pick `onError` for simple apps or full response control. Mixing both is allowed — the taxonomy handles what it covers, `onError` handles the tail. The anti-pattern is `instanceof` ladders inside `onError` (see anti-pattern #20 in the skill reference) — that's exactly what the taxonomy expresses declaratively.
 - Per-route `errors: ['UseCaseError', ...]` narrows typed errors on the generated client. Declare via `APIConfig<keyof typeof appErrors & string>` / `RPCConfig<keyof typeof appErrors & string>` for compile-time typo protection.
 - Generated `_errors.ts` emits real runtime classes extending `${Service}ProcedureError` — consumers catch with `instanceof ${Service}Errors.${Name}` and access `err.body`, `err.status`, `err.procedureName`, `err.scope`. Use the generated `create${Service}Client(config)` factory to wire the error registry automatically.

package/agent_config/claude-code/skills/ts-procedures/SKILL.md

@@ -171,7 +171,7 @@ The npm package ships user-facing documentation with narrative explanations and
 |------|--------|
 | `docs/core.md` | Procedures factory, Create, CreateStream, schema.input, error handling |
 | `docs/streaming.md` | Streaming procedures, AbortSignal, SSE patterns |
-| `docs/http-integrations.md` | Express RPC, Hono RPC/Stream/API builders, **error taxonomy (canonical)**, DocRegistry + `fromTaxonomy` |
+| `docs/http-integrations.md` | Express RPC, Hono RPC/Stream/API builders, **error taxonomy (canonical)**, DocRegistry (unified constructor, `.documentError()`) |
 | `docs/client-and-codegen.md` | Client code generation, `createApiClient`/`createClient`, typed error dispatch, per-route `Errors` unions, per-call options, client-level defaults, typed RequestMeta augmentation, CLI options |
 | `CHANGELOG.md` | Release notes — see `[6.0.0]` for the current peer error-handling model (taxonomy + `onError` + `onRequestError`), per-route errors, and client runtime error classes. |
 

package/agent_config/claude-code/skills/ts-procedures/anti-patterns.md

@@ -476,13 +476,13 @@ import { DocRegistry } from 'ts-procedures/http-docs'
 const docs = new DocRegistry({
   basePath: '/api',
   headers: [{ name: 'Authorization', description: 'Bearer token' }],
-  errors: DocRegistry.defaultErrors(),
+  errors: appErrors,  // your ErrorTaxonomy — framework defaults auto-merged
 }).from(rpcBuilder).from(apiBuilder).from(streamBuilder)
 
 app.get('/docs', (c) => c.json(docs.toJSON()))
 ```
 
-**Why:** `DocRegistry` provides a typed `DocEnvelope`, includes `defaultErrors()` with JSON Schemas for all 4 procedure error types, reads docs lazily (order-independent), and supports filtering and transformation via `toJSON()` options.
+**Why:** `DocRegistry` provides a typed `DocEnvelope`, auto-merges framework error defaults (`ProcedureError`, `ProcedureValidationError`, `ProcedureYieldValidationError`, `ProcedureRegistrationError`) with JSON Schemas, reads docs lazily (order-independent), and supports filtering and transformation via `toJSON()` options.
 
 ---
 

package/agent_config/claude-code/skills/ts-procedures/api-reference.md

@@ -295,13 +295,7 @@ When `toResponse` is omitted, the body defaults to `{ name: key, message: err.me
 
 Pre-built taxonomy covering `ProcedureValidationError` (400), `ProcedureYieldValidationError` (500), and direct `ProcedureError` (500, unwrapped throws only — wrapped ones fall through so user taxonomy / `unknownError` sees the real error). Applied as a fallback after the user taxonomy unless `includeDefaults: false`.
 
-### taxonomyToErrorDocs(taxonomy)
-
-```typescript
-function taxonomyToErrorDocs(taxonomy: ErrorTaxonomy): ErrorDoc[]
-```
-
-Converts a taxonomy to the `ErrorDoc[]` format consumed by `DocRegistry.errors` — single source of truth so the documented shape cannot drift from runtime behavior.
+Taxonomy-to-doc conversion is handled automatically by `DocRegistry` when you pass your taxonomy to the constructor. There is no public helper.
 
 ### resolveErrorResponse(params)
 
@@ -795,30 +789,24 @@ import type { DocEnvelope, DocRegistryConfig, DocRegistryOutputOptions, HeaderDo
 ```
 
 ```typescript
+import { DocRegistry } from 'ts-procedures/http-docs'
+import type { DocEnvelope, DocRegistryConfig, DocRegistryOutputOptions, HeaderDoc, ErrorDoc, DocSource } from 'ts-procedures/http-docs'
+
+interface DocRegistryConfig {
+  basePath?: string
+  headers?: HeaderDoc[]
+  errors?: ErrorTaxonomy | ErrorDoc[]   // polymorphic — pass taxonomy or raw docs
+  includeDefaults?: boolean              // default: true (auto-merges framework defaults)
+}
+
 class DocRegistry {
-  constructor(config?: {
-    basePath?: string
-    headers?: HeaderDoc[]
-    errors?: ErrorDoc[]
-  })
+  constructor(config?: DocRegistryConfig)
 
   from(source: DocSource<AnyHttpRouteDoc>): this
+  documentError(...docs: ErrorDoc[]): this
+  toJSON<T = DocEnvelope>(options?: DocRegistryOutputOptions<T>): T
 
-  toJSON<T = DocEnvelope>(options?: {
-    filter?: (route: AnyHttpRouteDoc) => boolean
-    transform?: (envelope: DocEnvelope) => T
-  }): T
-
-  // Framework error defaults derived from defaultErrorTaxonomy — single source
-  // of truth so runtime and documented shapes cannot drift.
   static defaultErrors(): ErrorDoc[]
-
-  // Convenience: seed envelope errors from a taxonomy + framework defaults
-  // in one call (deduped — user entries win when keys overlap).
-  static fromTaxonomy(
-    taxonomy: ErrorTaxonomy,
-    config?: Omit<DocRegistryConfig, 'errors'> & { includeDefaults?: boolean }
-  ): DocRegistry
 }
 ```
 
@@ -875,7 +863,7 @@ type AnyHttpRouteDoc = RPCHttpRouteDoc | APIHttpRouteDoc | StreamHttpRouteDoc
 
 - `from()` stores a **reference** to the builder — routes are read lazily at `toJSON()` time, so builders can be registered before or after `.build()`
 - `toJSON()` collects routes via `flatMap(source => source.docs)`, applies optional `filter`, builds envelope, then applies optional `transform`
-- `defaultErrors()` returns 4 `ErrorDoc` entries describing `ProcedureError` (500), `ProcedureValidationError` (400), `ProcedureYieldValidationError` (500), `ProcedureRegistrationError` (500) — each with a JSON Schema for the error response body shape
+- `defaultErrors()` returns 4 `ErrorDoc` entries describing `ProcedureError` (500), `ProcedureValidationError` (400), `ProcedureYieldValidationError` (500), `ProcedureRegistrationError` (500) — each with a JSON Schema for the error response body shape. Most consumers do not need to call this directly; the `DocRegistry` constructor auto-merges these unless `includeDefaults: false` is passed.
 - `JSON.stringify(registry)` works directly (calls `toJSON()` implicitly)
 
 ---

package/agent_config/claude-code/skills/ts-procedures/patterns.md

@@ -186,7 +186,7 @@ Seed the DocEnvelope with both taxonomy errors and framework defaults in one cal
 ```typescript
 import { DocRegistry } from 'ts-procedures/http-docs'
 
-const envelope = DocRegistry.fromTaxonomy(appErrors, { basePath: '/api' })
+const envelope = new DocRegistry({ errors: appErrors, basePath: '/api' })
   .from(apiApp)
   .from(rpcApp)
   .toJSON()
@@ -194,6 +194,13 @@ const envelope = DocRegistry.fromTaxonomy(appErrors, { basePath: '/api' })
 // envelope.routes[i].errors: per-route subset declared on config.errors
 ```
 
+```typescript
+// For errors outside your taxonomy (middleware, infrastructure, doc-only):
+const docsWithExtras = new DocRegistry({ errors: appErrors, basePath: '/api' })
+  .from(apiBuilder)
+  .documentError({ name: 'RateLimitExceeded', statusCode: 429, description: 'too many requests' })
+```
+
 ### Typed catch blocks on the client (via codegen)
 
 The codegen emits runtime error classes (not just types) and a registry object. `createApiClient` wires the registry automatically so non-2xx responses arrive as typed class instances.
@@ -805,7 +812,7 @@ import { DocRegistry } from 'ts-procedures/http-docs'
 const docs = new DocRegistry({
   basePath: '/api',
   headers: [{ name: 'Authorization', description: 'Bearer token', required: false }],
-  errors: DocRegistry.defaultErrors(),
+  errors: appErrors,  // your ErrorTaxonomy — framework defaults auto-merged and deduped
 })
   .from(rpcBuilder)
   .from(apiBuilder)
@@ -824,7 +831,7 @@ app.get('/docs', (c) => c.json(docs.toJSON({
 **Key points:**
 - `from()` stores a reference — register builders before or after `.build()`
 - `toJSON()` reads docs lazily, so late-registered procedures are included
-- `DocRegistry.defaultErrors()` provides error schemas for all 4 procedure error types
+- Pass your `ErrorTaxonomy` directly to `errors` — the constructor auto-merges framework defaults and dedupes; opt out with `includeDefaults: false`
 - Accepts any object satisfying `{ readonly docs: AnyHttpRouteDoc[] }` — not limited to built-in builders
 
 ---
@@ -926,7 +933,7 @@ import { DocRegistry } from 'ts-procedures/http-docs'
 const docs = new DocRegistry({
   basePath: '/api',
   headers: [{ name: 'Authorization', description: 'Bearer token' }],
-  errors: DocRegistry.defaultErrors(),
+  errors: appErrors,  // your ErrorTaxonomy — framework defaults auto-merged
 })
   .from(rpcBuilder)
   .from(apiBuilder)

package/agent_config/claude-code/skills/ts-procedures-review/checklist.md

@@ -74,7 +74,7 @@
 
 ### SUGGESTION
 - [ ] Route documentation accessed via `builder.docs` for OpenAPI generation
-- [ ] Uses `DocRegistry.fromTaxonomy(appErrors)` (or plain `DocRegistry` with explicit `errors`) to compose docs from multiple builders
+- [ ] Uses `new DocRegistry({ errors: appErrors })` to compose docs from multiple builders
 - [ ] Lifecycle hooks used for observability (logging, metrics)
 - [ ] Per-route `errors: [...]` declared so generated clients can narrow `catch` types
 
@@ -115,7 +115,7 @@
 
 ### SUGGESTION
 - [ ] Route documentation accessed via `builder.docs` for OpenAPI generation
-- [ ] Uses `DocRegistry.fromTaxonomy(appErrors)` to compose docs across builders instead of manual assembly
+- [ ] Uses `new DocRegistry({ errors: appErrors })` to compose docs across builders instead of manual assembly
 - [ ] Custom `queryParser` provided if complex query string formats needed
 - [ ] Lifecycle hooks used for observability (logging, metrics)
 

package/agent_config/copilot/copilot-instructions.md

@@ -218,7 +218,8 @@ class UseCaseError extends Error {
 }
 
 const appErrors = defineErrorTaxonomy({
-  // First-match wins — declare subclasses before base classes
+  // class: entries are topologically sorted (subclasses checked first) automatically.
+  // Predicate (match:) entries keep declared order — put narrower predicates first.
   UseCaseError: {
     class: UseCaseError,
     statusCode: 422,
@@ -254,7 +255,7 @@ const API = Procedures<Ctx, MyAPIConfig>()
 API.Create('GetUser', { path: '/users/:id', method: 'get', errors: ['UseCaseError'], /* ... */ }, ...)
 
 // Seed envelope errors from the taxonomy + framework defaults in one call
-const envelope = DocRegistry.fromTaxonomy(appErrors, { basePath: '/api' }).from(apiApp).toJSON()
+const envelope = new DocRegistry({ errors: appErrors, basePath: '/api' }).from(apiApp).toJSON()
 ```
 
 ### Client-side typed catch blocks (via codegen)

package/agent_config/cursor/cursorrules

@@ -218,7 +218,8 @@ class UseCaseError extends Error {
 }
 
 const appErrors = defineErrorTaxonomy({
-  // First-match wins — declare subclasses before base classes
+  // class: entries are topologically sorted (subclasses checked first) automatically.
+  // Predicate (match:) entries keep declared order — put narrower predicates first.
   UseCaseError: {
     class: UseCaseError,
     statusCode: 422,
@@ -254,7 +255,7 @@ const API = Procedures<Ctx, MyAPIConfig>()
 API.Create('GetUser', { path: '/users/:id', method: 'get', errors: ['UseCaseError'], /* ... */ }, ...)
 
 // Seed envelope errors from the taxonomy + framework defaults in one call
-const envelope = DocRegistry.fromTaxonomy(appErrors, { basePath: '/api' }).from(apiApp).toJSON()
+const envelope = new DocRegistry({ errors: appErrors, basePath: '/api' }).from(apiApp).toJSON()
 ```
 
 ### Client-side typed catch blocks (via codegen)

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

@@ -0,0 +1,24 @@
+export interface KotlinEmitResult {
+    code: string;
+    rootTypeName: string;
+    extractedTypeNames: string[];
+    imports: string[];
+}
+export interface KotlinEmitOptions {
+    rootTypeName: string;
+    inlineTypes?: boolean;
+    serializer?: 'kotlinx';
+    enumStyle?: string;
+    depluralize?: boolean;
+    arrayItemNaming?: string;
+    uncountableWords?: string[];
+}
+export interface KotlinEmitter {
+    emit(schema: Record<string, unknown>, opts: KotlinEmitOptions): KotlinEmitResult;
+}
+export declare function createStubKotlinEmitter(results: Record<string, KotlinEmitResult>): KotlinEmitter;
+/**
+ * Resolves the production Kotlin emitter from `ajsc`. Throws a clear error
+ * if the ajsc package does not yet expose `emitKotlin` (Phase A pending).
+ */
+export declare function resolveProductionKotlinEmitter(): Promise<KotlinEmitter>;

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

@@ -0,0 +1,33 @@
+export function createStubKotlinEmitter(results) {
+    return {
+        emit(_schema, opts) {
+            const result = results[opts.rootTypeName];
+            if (result == null) {
+                throw new Error(`[stub-kotlin-emitter] No stubbed result for rootTypeName "${opts.rootTypeName}". ` +
+                    `Provide one in the results map.`);
+            }
+            return result;
+        },
+    };
+}
+/**
+ * Resolves the production Kotlin emitter from `ajsc`. Throws a clear error
+ * if the ajsc package does not yet expose `emitKotlin` (Phase A pending).
+ */
+export async function resolveProductionKotlinEmitter() {
+    // TODO(ajsc-phase-a): replace dynamic import with a static import once ajsc ships emitKotlin.
+    const ajsc = await import('ajsc').catch(() => null);
+    const emitKotlin = ajsc?.emitKotlin;
+    if (typeof emitKotlin !== 'function') {
+        throw new Error('[ts-procedures-codegen] ajsc.emitKotlin is not available. ' +
+            'Kotlin codegen requires ajsc Phase A. See docs/superpowers/specs/2026-04-24-kotlin-swift-codegen-design.md.');
+    }
+    return {
+        emit(schema, opts) {
+            // ajsc's return shape is normalized to KotlinEmitResult here.
+            const r = emitKotlin(schema, opts);
+            return r;
+        },
+    };
+}
+//# sourceMappingURL=ajsc-adapter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ajsc-adapter.js","sourceRoot":"","sources":["../../../../src/codegen/targets/kotlin/ajsc-adapter.ts"],"names":[],"mappings":"AAqBA,MAAM,UAAU,uBAAuB,CACrC,OAAyC;IAEzC,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,6DAA6D,IAAI,CAAC,YAAY,KAAK;oBACjF,iCAAiC,CACpC,CAAA;YACH,CAAC;YACD,OAAO,MAAM,CAAA;QACf,CAAC;KACF,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,8BAA8B;IAClD,8FAA8F;IAC9F,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAA;IACnD,MAAM,UAAU,GAAI,IAAwC,EAAE,UAAU,CAAA;IACxE,IAAI,OAAO,UAAU,KAAK,UAAU,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CACb,4DAA4D;YAC5D,6GAA6G,CAC9G,CAAA;IACH,CAAC;IACD,OAAO;QACL,IAAI,CAAC,MAAM,EAAE,IAAI;YACf,8DAA8D;YAC9D,MAAM,CAAC,GAAI,UAA2D,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;YACpF,OAAO,CAAC,CAAA;QACV,CAAC;KACF,CAAA;AACH,CAAC"}

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

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

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

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { createStubKotlinEmitter } from './ajsc-adapter.js';
+describe('createStubKotlinEmitter', () => {
+    it('returns the configured EmitResult for the matching root name', () => {
+        const expected = {
+            code: '@Serializable data class User(val id: String)',
+            rootTypeName: 'User',
+            extractedTypeNames: [],
+            imports: ['kotlinx.serialization.Serializable'],
+        };
+        const emitter = createStubKotlinEmitter({ User: expected });
+        expect(emitter.emit({ type: 'object' }, { rootTypeName: 'User' })).toEqual(expected);
+    });
+    it('throws when asked to emit a name not in the stub map', () => {
+        const emitter = createStubKotlinEmitter({});
+        expect(() => emitter.emit({}, { rootTypeName: 'Missing' })).toThrow(/Missing/);
+    });
+});
+//# sourceMappingURL=ajsc-adapter.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ajsc-adapter.test.js","sourceRoot":"","sources":["../../../../src/codegen/targets/kotlin/ajsc-adapter.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,uBAAuB,EAAyB,MAAM,mBAAmB,CAAA;AAElF,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;IACvC,EAAE,CAAC,8DAA8D,EAAE,GAAG,EAAE;QACtE,MAAM,QAAQ,GAAqB;YACjC,IAAI,EAAE,+CAA+C;YACrD,YAAY,EAAE,MAAM;YACpB,kBAAkB,EAAE,EAAE;YACtB,OAAO,EAAE,CAAC,oCAAoC,CAAC;SAChD,CAAA;QACD,MAAM,OAAO,GAAG,uBAAuB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAA;QAC3D,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IACtF,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;QAC9D,MAAM,OAAO,GAAG,uBAAuB,CAAC,EAAE,CAAC,CAAA;QAC3C,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"}

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

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

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

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runPipeline } from '../../pipeline.js';
+import { resolveProductionKotlinEmitter } from './ajsc-adapter.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function kotlincAvailable() {
+    try {
+        execSync('kotlinc -version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+describe('kotlin codegen — kotlinc compile (gated)', () => {
+    it.skipIf(!kotlincAvailable() || process.env.TS_PROCEDURES_KOTLIN_E2E !== '1')('compiles generated output without errors', async () => {
+        const emitter = await resolveProductionKotlinEmitter();
+        const envelope = JSON.parse(await readFile(join(__dirname, '__fixtures__/users-envelope.json'), 'utf8'));
+        const files = await runPipeline({
+            envelope,
+            outDir: 'out',
+            dryRun: true,
+            target: 'kotlin',
+            kotlinPackage: 'com.example.api',
+            kotlinEmitter: emitter,
+        });
+        const dir = mkdtempSync(join(tmpdir(), 'tsp-kotlin-e2e-'));
+        for (const f of files) {
+            writeFileSync(join(dir, f.path.split('/').pop()), f.code);
+        }
+        // Compile against the kotlinx-serialization runtime jar present in the test env.
+        // If the jar isn't on the classpath, this fails; CI must provide it.
+        execSync(`kotlinc ${dir}/*.kt -d ${dir}/out.jar`, { stdio: 'inherit' });
+        expect(true).toBe(true); // reaching here means compile succeeded
+    });
+});
+//# sourceMappingURL=e2e-compile.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"e2e-compile.test.js","sourceRoot":"","sources":["../../../../src/codegen/targets/kotlin/e2e-compile.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,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,8BAA8B,EAAE,MAAM,mBAAmB,CAAA;AAElE,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACjD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;AAErC,SAAS,gBAAgB;IACvB,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,QAAQ,CAAC,0CAA0C,EAAE,GAAG,EAAE;IACxD,EAAE,CAAC,MAAM,CAAC,CAAC,gBAAgB,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC,wBAAwB,KAAK,GAAG,CAAC,CAC5E,0CAA0C,EAC1C,KAAK,IAAI,EAAE;QACT,MAAM,OAAO,GAAG,MAAM,8BAA8B,EAAE,CAAA;QACtD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CACzB,MAAM,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,kCAAkC,CAAC,EAAE,MAAM,CAAC,CAC5E,CAAA;QACD,MAAM,KAAK,GAAG,MAAM,WAAW,CAAC;YAC9B,QAAQ;YACR,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,IAAI;YACZ,MAAM,EAAE,QAAQ;YAChB,aAAa,EAAE,iBAAiB;YAChC,aAAa,EAAE,OAAO;SACvB,CAAC,CAAA;QACF,MAAM,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,iBAAiB,CAAC,CAAC,CAAA;QAC1D,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,aAAa,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAG,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAA;QAC5D,CAAC;QACD,iFAAiF;QACjF,qEAAqE;QACrE,QAAQ,CAAC,WAAW,GAAG,YAAY,GAAG,UAAU,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAA;QACvE,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAC,wCAAwC;IAClE,CAAC,CACF,CAAA;AACH,CAAC,CAAC,CAAA"}

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

@@ -0,0 +1,11 @@
+import type { AnyHttpRouteDoc } from '../../../implementations/types.js';
+import type { KotlinEmitter } from './ajsc-adapter.js';
+export interface EmitRouteResult {
+    /** Inner body of the `object 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 `object RouteName` identifier. */
+    routeName: string;
+}
+export declare function emitKotlinRoute(route: AnyHttpRouteDoc, emitter: KotlinEmitter, errorSchemas: Map<string, unknown>): EmitRouteResult;

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

@@ -0,0 +1,73 @@
+import { indent } from './format-kotlin.js';
+const COLON_PARAM_RE = /:([A-Za-z_][A-Za-z0-9_]*)/g;
+function toBracePath(template) {
+    return template.replace(COLON_PARAM_RE, '{$1}');
+}
+function pathParamNames(template) {
+    const names = [];
+    for (const match of template.matchAll(COLON_PARAM_RE))
+        names.push(match[1]);
+    return names;
+}
+function buildPathFn(bracePath, params) {
+    if (params.length === 0)
+        return `const val path = "${bracePath}"`;
+    let body = bracePath;
+    for (const name of params)
+        body = body.replace(`{${name}}`, `\${p.${name}}`);
+    return `fun path(p: PathParams): String = "${body}"`;
+}
+export function emitKotlinRoute(route, emitter, errorSchemas) {
+    const kind = route.kind;
+    if (kind === 'stream') {
+        console.warn(`[ts-procedures-codegen] Skipping stream route "${route.name}" — streams are out of scope for kotlin target.`);
+        return { code: '', imports: [], routeName: route.name };
+    }
+    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 lines = [
+        `const val method = "${method}"`,
+        `const val pathTemplate = "${bracePath}"`,
+        buildPathFn(bracePath, params),
+    ];
+    const imports = [];
+    const schema = route.schema ?? {};
+    const input = (schema.input ?? {});
+    // Per-slot emission. Order is fixed for deterministic output.
+    const slots = [
+        { key: 'pathParams', rootName: 'PathParams', source: input.pathParams },
+        { key: 'query', rootName: 'Query', source: input.query },
+        { key: 'body', rootName: 'Body', source: input.body },
+        { key: 'response', rootName: 'Response', source: schema.returnType },
+    ];
+    for (const slot of slots) {
+        if (slot.source == null)
+            continue;
+        const result = emitter.emit(slot.source, { rootTypeName: slot.rootName });
+        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), { rootTypeName: key });
+            inner.push(r.code);
+            imports.push(...r.imports);
+        }
+        lines.push('');
+        lines.push('object Errors {');
+        lines.push(indent(inner.join('\n\n'), 1));
+        lines.push('}');
+    }
+    return { code: lines.join('\n'), imports, routeName: route.name };
+}
+//# sourceMappingURL=emit-route-kotlin.js.map

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

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

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

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

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

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+import { emitKotlinRoute } from './emit-route-kotlin.js';
+import { createStubKotlinEmitter } from './ajsc-adapter.js';
+const ok = (code, rootTypeName) => ({
+    code,
+    rootTypeName,
+    extractedTypeNames: [],
+    imports: ['kotlinx.serialization.Serializable'],
+});
+const noErrors = new Map();
+describe('emitKotlinRoute', () => {
+    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 = createStubKotlinEmitter({
+            PathParams: ok('@Serializable data class PathParams(val id: String)', 'PathParams'),
+            Response: ok('@Serializable data class Response(val id: String, val name: String)', 'Response'),
+        });
+        const result = emitKotlinRoute(route, emitter, noErrors);
+        expect(result.imports).toContain('kotlinx.serialization.Serializable');
+        expect(result.code).toContain('const val method = "GET"');
+        expect(result.code).toContain('const val pathTemplate = "/users/{id}"');
+        expect(result.code).toContain('fun path(p: PathParams): String = "/users/${p.id}"');
+        expect(result.code).toContain('@Serializable data class PathParams(val id: String)');
+        expect(result.code).toContain('@Serializable data class Response(val id: String, val 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 = createStubKotlinEmitter({
+            Body: ok('@Serializable data class Body(val name: String)', 'Body'),
+            Response: ok('@Serializable data class Response(val id: String)', 'Response'),
+        });
+        const result = emitKotlinRoute(route, emitter, noErrors);
+        expect(result.code).toContain('const val path = "/users"');
+        expect(result.code).not.toContain('fun 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 = createStubKotlinEmitter({
+            PathParams: ok('@Serializable data class PathParams(val id: String)', 'PathParams'),
+            Response: ok('@Serializable data class Response(val id: String)', 'Response'),
+            NotFound: ok('@Serializable data class NotFound(val name: String, val message: String)', 'NotFound'),
+        });
+        const errorSchemas = new Map([['NotFound', { type: 'object' }]]);
+        const result = emitKotlinRoute(route, emitter, errorSchemas);
+        expect(result.code).toContain('object Errors {');
+        expect(result.code).toContain('@Serializable data class NotFound(val name: String, val 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 = emitKotlinRoute(route, createStubKotlinEmitter({}), new Map());
+        expect(result.code).not.toContain('object Errors {');
+    });
+    it('skips stream routes with a warning', () => {
+        const route = { kind: 'stream', name: 'WatchUsers', method: 'GET', path: '/users/stream', schema: {}, errors: [] };
+        const result = emitKotlinRoute(route, createStubKotlinEmitter({}), noErrors);
+        expect(result.code).toBe('');
+    });
+});
+//# sourceMappingURL=emit-route-kotlin.test.js.map

package/build/codegen/targets/kotlin/emit-route-kotlin.test.js.map

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

package/build/codegen/targets/kotlin/emit-scope-kotlin.d.ts

@@ -0,0 +1,11 @@
+import type { ScopeGroup } from '../../group-routes.js';
+import type { KotlinEmitter } from './ajsc-adapter.js';
+export interface EmitScopeOptions {
+    kotlinPackage: string;
+    sourceHash: string;
+}
+export interface EmittedKotlinFile {
+    filename: string;
+    code: string;
+}
+export declare function emitKotlinScope(group: ScopeGroup, opts: EmitScopeOptions, emitter: KotlinEmitter, errorSchemas: Map<string, unknown>): EmittedKotlinFile;

package/build/codegen/targets/kotlin/emit-scope-kotlin.js

@@ -0,0 +1,35 @@
+import { emitKotlinRoute } from './emit-route-kotlin.js';
+import { kotlinPackageDecl, kotlinSourceHashHeader, kotlinImports, indent } from './format-kotlin.js';
+function pascalCase(scope) {
+    return scope
+        .split('-')
+        .filter((p) => p.length > 0)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join('');
+}
+export function emitKotlinScope(group, opts, emitter, errorSchemas) {
+    const scopeName = pascalCase(group.scopeKey);
+    const allImports = [];
+    const routeBlocks = [];
+    for (const route of group.routes) {
+        const r = emitKotlinRoute(route, emitter, errorSchemas);
+        if (r.code === '')
+            continue;
+        allImports.push(...r.imports);
+        const wrapped = `object ${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 === ''
+        ? `object ${scopeName} {\n}`
+        : `object ${scopeName} {\n${innerScope}\n}`;
+    const importsBlock = kotlinImports(allImports);
+    const parts = [
+        kotlinPackageDecl(opts.kotlinPackage),
+        kotlinSourceHashHeader(opts.sourceHash),
+        importsBlock,
+        scopeBlock,
+    ].filter((p) => p.length > 0);
+    return { filename: `${scopeName}.kt`, code: parts.join('\n\n') + '\n' };
+}
+//# sourceMappingURL=emit-scope-kotlin.js.map

package/build/codegen/targets/kotlin/emit-scope-kotlin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-scope-kotlin.js","sourceRoot":"","sources":["../../../../src/codegen/targets/kotlin/emit-scope-kotlin.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAYrG,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,KAAK;SACT,KAAK,CAAC,GAAG,CAAC;SACV,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;SAC3B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAClD,IAAI,CAAC,EAAE,CAAC,CAAA;AACb,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,KAAiB,EACjB,IAAsB,EACtB,OAAsB,EACtB,YAAkC;IAElC,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IAC5C,MAAM,UAAU,GAAa,EAAE,CAAA;IAC/B,MAAM,WAAW,GAAa,EAAE,CAAA;IAEhC,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjC,MAAM,CAAC,GAAG,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,CAAC,CAAA;QACvD,IAAI,CAAC,CAAC,IAAI,KAAK,EAAE;YAAE,SAAQ;QAC3B,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAA;QAC7B,MAAM,OAAO,GAAG,UAAU,CAAC,CAAC,SAAS,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAA;QAClE,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAC3B,CAAC;IAED,MAAM,UAAU,GAAG,WAAW,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAA;IACtF,MAAM,UAAU,GAAG,UAAU,KAAK,EAAE;QAClC,CAAC,CAAC,UAAU,SAAS,OAAO;QAC5B,CAAC,CAAC,UAAU,SAAS,OAAO,UAAU,KAAK,CAAA;IAE7C,MAAM,YAAY,GAAG,aAAa,CAAC,UAAU,CAAC,CAAA;IAC9C,MAAM,KAAK,GAAG;QACZ,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC;QACrC,sBAAsB,CAAC,IAAI,CAAC,UAAU,CAAC;QACvC,YAAY;QACZ,UAAU;KACX,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;IAE7B,OAAO,EAAE,QAAQ,EAAE,GAAG,SAAS,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,CAAA;AACzE,CAAC"}

package/build/codegen/targets/kotlin/emit-scope-kotlin.test.d.ts

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